Blender V5.3
closures_setup.h
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2009-2010 Sony Pictures Imageworks Inc., et al. All Rights Reserved.
2 * SPDX-FileCopyrightText: 2011-2022 Blender Foundation
3 *
4 * SPDX-License-Identifier: BSD-3-Clause
5 *
6 * Adapted code from Open Shading Language. */
7
8#pragma once
9
11#include "kernel/closure/bsdf.h"
15
16#include "kernel/geom/object.h"
17
18#include "kernel/osl/types.h"
19
21
22#define OSL_CLOSURE_STRUCT_BEGIN(Upper, lower) \
23 struct ccl_align(8) Upper##Closure { \
24 const char *label;
25#define OSL_CLOSURE_STRUCT_END(Upper, lower) \
26 } \
27 ;
28#define OSL_CLOSURE_STRUCT_MEMBER(Upper, TYPE, type, name, key) type name;
29#define OSL_CLOSURE_STRUCT_ARRAY_MEMBER(Upper, TYPE, type, name, key, size) type name[size];
30
31#include "closures_template.h"
32
33struct ccl_align(8) LayerClosure {
34 const ccl_private OSLClosure *base;
35 const ccl_private OSLClosure *top;
36};
37
38/* If we failed to allocate a layer-able closure, we need to zero out the albedo
39 * so that lower layers aren't falsely blocked.
40 * Therefore, to keep the code clean, set it to zero at the start and overwrite
41 * later if it succeeded. */
43{
44 if (layer_albedo != nullptr) {
45 *layer_albedo = zero_float3();
46 }
47}
48
50 const PathRayVisibility path_visibility,
51 const int scattering)
52{
53 /* Caustic options */
54 if ((scattering & LABEL_GLOSSY) && (path_visibility & PATH_RAY_VISIBILITY_DIFFUSE)) {
55 const bool has_reflect = (scattering & LABEL_REFLECT);
56 const bool has_transmit = (scattering & LABEL_TRANSMIT);
57 const bool reflect_caustics_disabled = !kernel_data.integrator.caustics_reflective;
58 const bool refract_caustics_disabled = !kernel_data.integrator.caustics_refractive;
59
60 /* Reflective Caustics */
61 if (reflect_caustics_disabled && has_reflect && !has_transmit) {
62 return true;
63 }
64 /* Refractive Caustics */
65 if (refract_caustics_disabled && has_transmit && !has_reflect) {
66 return true;
67 }
68 /* Glass Caustics */
69 if (reflect_caustics_disabled && refract_caustics_disabled) {
70 return true;
71 }
72 }
73
74 return false;
75}
76
77/* Diffuse */
78
80 ccl_private ShaderData *sd,
81 const PathRayVisibility path_visibility,
82 const uint32_t /*path_flag*/,
83 const float3 weight,
84 const ccl_private DiffuseClosure *closure,
85 float3 * /*layer_albedo*/)
86{
87 if (osl_closure_skip(kg, path_visibility, LABEL_DIFFUSE)) {
88 return;
89 }
90
91 const float3 N = safe_normalize_fallback(closure->N, sd->N);
93}
94
95/* Deprecated form, will be removed in OSL 2.0. */
97 ccl_private ShaderData *sd,
98 const PathRayVisibility path_visibility,
99 const uint32_t /*path_flag*/,
100 const float3 weight,
101 const ccl_private OrenNayarClosure *closure,
102 float3 * /*layer_albedo*/)
103{
104 if (osl_closure_skip(kg, path_visibility, LABEL_DIFFUSE)) {
105 return;
106 }
107
108 const float3 N = safe_normalize_fallback(closure->N, sd->N);
109 const Spectrum color = rgb_to_spectrum(weight);
110 bsdf_oren_nayar_setup(sd, N, color, closure->roughness, color);
111}
112
114 KernelGlobals kg,
115 ccl_private ShaderData *sd,
116 const PathRayVisibility path_visibility,
117 const uint32_t /*path_flag*/,
118 const float3 weight,
119 const ccl_private OrenNayarDiffuseBSDFClosure *closure,
120 float3 * /*layer_albedo*/)
121{
122 if (osl_closure_skip(kg, path_visibility, LABEL_DIFFUSE)) {
123 return;
124 }
125
126 const float3 N = safe_normalize_fallback(closure->N, sd->N);
127 const Spectrum closure_weight = rgb_to_spectrum(weight * closure->albedo);
128 const Spectrum color = rgb_to_spectrum(closure->albedo);
129 bsdf_oren_nayar_setup(sd, N, closure_weight, closure->roughness, color);
130}
131
133 KernelGlobals kg,
134 ccl_private ShaderData *sd,
135 const PathRayVisibility path_visibility,
136 const uint32_t /*path_flag*/,
137 const float3 weight,
138 ccl_private const BurleyDiffuseBSDFClosure *closure,
139 float3 * /*layer_albedo*/)
140{
141 if (osl_closure_skip(kg, path_visibility, LABEL_DIFFUSE)) {
142 return;
143 }
144
145 ccl_private BurleyBsdf *bsdf = (ccl_private BurleyBsdf *)bsdf_alloc(
146 sd, sizeof(BurleyBsdf), rgb_to_spectrum(weight * closure->albedo));
147 if (!bsdf) {
148 return;
149 }
150
151 bsdf->N = safe_normalize_fallback(closure->N, sd->N);
152
153 sd->runtime_flag |= bsdf_burley_setup(bsdf, closure->roughness);
154}
155
157 ccl_private ShaderData *sd,
158 const PathRayVisibility path_visibility,
159 const uint32_t /*path_flag*/,
160 const float3 weight,
161 const ccl_private TranslucentClosure *closure,
162 float3 * /*layer_albedo*/)
163{
164 if (osl_closure_skip(kg, path_visibility, LABEL_DIFFUSE)) {
165 return;
166 }
167
168 const float3 N = safe_normalize_fallback(closure->N, sd->N);
170}
171
173 KernelGlobals kg,
174 ccl_private ShaderData *sd,
175 const PathRayVisibility path_visibility,
176 const uint32_t /*path_flag*/,
177 const float3 weight,
178 const ccl_private TranslucentBSDFClosure *closure,
179 float3 * /*layer_albedo*/)
180{
181 if (osl_closure_skip(kg, path_visibility, LABEL_DIFFUSE)) {
182 return;
183 }
184
185 const float3 N = safe_normalize_fallback(closure->N, sd->N);
186 bsdf_translucent_setup(sd, N, rgb_to_spectrum(weight * closure->albedo));
187}
188
190 ccl_private ShaderData *sd,
191 const PathRayVisibility path_visibility,
192 const uint32_t /*path_flag*/,
193 const float3 weight,
194 const ccl_private ReflectionClosure *closure,
195 float3 * /*layer_albedo*/)
196{
197 if (osl_closure_skip(kg, path_visibility, LABEL_SINGULAR)) {
198 return;
199 }
200
202 sd, sizeof(MicrofacetBsdf), rgb_to_spectrum(weight));
203 if (!bsdf) {
204 return;
205 }
206
207 bsdf->N = maybe_ensure_valid_specular_reflection(sd, safe_normalize_fallback(closure->N, sd->N));
208 bsdf->alpha_x = bsdf->alpha_y = 0.0f;
209
210 sd->runtime_flag |= bsdf_microfacet_ggx_setup(bsdf);
211}
212
214 ccl_private ShaderData *sd,
215 const PathRayVisibility path_visibility,
216 const uint32_t /*path_flag*/,
217 const float3 weight,
218 const ccl_private RefractionClosure *closure,
219 float3 * /*layer_albedo*/)
220{
221 if (osl_closure_skip(kg, path_visibility, LABEL_SINGULAR)) {
222 return;
223 }
224
226 sd, sizeof(MicrofacetBsdf), rgb_to_spectrum(weight));
227 if (!bsdf) {
228 return;
229 }
230
231 const bool backfacing = (sd->runtime_flag & SR_BACKFACING);
232
233 bsdf->N = maybe_ensure_valid_specular_reflection(sd, safe_normalize_fallback(closure->N, sd->N));
234 bsdf->ior = backfacing ? 1.0f / closure->ior : closure->ior;
235 bsdf->alpha_x = bsdf->alpha_y = 0.0f;
236
237 sd->runtime_flag |= bsdf_microfacet_ggx_refraction_setup(bsdf);
238}
239
241 ccl_private ShaderData *sd,
242 const PathRayVisibility /*path_visibility*/,
243 const uint32_t path_flag,
244 const float3 weight,
245 const ccl_private TransparentClosure * /*closure*/,
246 float3 * /*layer_albedo*/)
247{
248 bsdf_transparent_setup(sd, rgb_to_spectrum(weight), path_flag);
249}
250
252 KernelGlobals /*kg*/,
253 ccl_private ShaderData *sd,
254 const PathRayVisibility /*path_visibility*/,
255 const uint32_t path_flag,
256 const float3 weight,
257 const ccl_private TransparentBSDFClosure * /*closure*/,
258 float3 * /*layer_albedo*/)
259{
260 bsdf_transparent_setup(sd, rgb_to_spectrum(weight), path_flag);
261}
262
264 ccl_private ShaderData *sd,
265 const PathRayVisibility /*path_visibility*/,
266 const uint32_t /*path_flag*/,
267 const float3 weight,
268 const ccl_private RayPortalBSDFClosure *closure,
269 float3 * /*layer_albedo*/)
270{
271 bsdf_ray_portal_setup(sd, rgb_to_spectrum(weight), closure->position, closure->direction);
272}
273
275 ccl_private ShaderData *sd,
276 const PathRayVisibility path_visibility,
277 const uint32_t /*path_flag*/,
278 const float3 weight,
279 const ccl_private CoatBSDFClosure *closure,
280 float3 *layer_albedo)
281{
282 osl_zero_albedo(layer_albedo);
283
284 if (osl_closure_skip(kg, path_visibility, LABEL_GLOSSY | LABEL_REFLECT)) {
285 return;
286 }
287
288 Coat coat;
289 coat.tint = rgb_to_spectrum(closure->color);
290 coat.ior = closure->ior;
292 coat.roughness = closure->roughness;
293 coat.weight = rgb_to_spectrum(weight);
294 const Spectrum albedo = bsdf_coat_setup(kg, sd, path_visibility, coat);
295
296 if (layer_albedo) {
297 *layer_albedo = spectrum_to_rgb(albedo);
298 }
299}
300
301/* MaterialX closures */
303 ccl_private ShaderData *sd,
304 const PathRayVisibility path_visibility,
305 const uint32_t /*path_flag*/,
306 const float3 weight,
307 const ccl_private DielectricBSDFClosure *closure,
308 float3 *layer_albedo)
309{
310 osl_zero_albedo(layer_albedo);
311
312 if (osl_closure_skip(kg, path_visibility, LABEL_GLOSSY | LABEL_REFLECT)) {
313 return;
314 }
315
317 sd, sizeof(MicrofacetBsdf), rgb_to_spectrum(weight));
318 if (!bsdf) {
319 return;
320 }
321
324
325 if (!fresnel) {
326 return;
327 }
328
329 const bool backfacing = (sd->runtime_flag & SR_BACKFACING);
330
331 bsdf->N = maybe_ensure_valid_specular_reflection(sd, safe_normalize_fallback(closure->N, sd->N));
332 bsdf->alpha_x = closure->alpha_x;
333 bsdf->alpha_y = closure->alpha_y;
334 bsdf->ior = backfacing ? 1.0f / closure->ior : closure->ior;
335 bsdf->T = closure->T;
336
337 const bool beckmann = closure->distribution == make_string("beckmann", 14712237670914973463ull);
338 const bool multiggx = closure->distribution == make_string("multi_ggx", 16842698693386468366ull);
339
340 fresnel->thin_film = {closure->thinfilm_thickness, closure->thinfilm_ior};
341 fresnel->tint = {rgb_to_spectrum(closure->reflection_tint),
342 rgb_to_spectrum(closure->transmission_tint)};
343 if (backfacing) {
344 adjust_thin_film_ior_at_backface(fresnel->thin_film.ior, bsdf->ior);
345 }
346 bsdf_dielectric_tint_setup(kg, bsdf, sd, fresnel, beckmann, multiggx);
347
348 if (layer_albedo != nullptr) {
349 if (!(sd->runtime_flag & SR_BSDF_HAS_TRANSMISSION)) {
350 *layer_albedo = closure_layer_albedo(kg, sd, (ccl_private ShaderClosure *)bsdf);
351 }
352 else {
353 *layer_albedo = one_float3();
354 }
355 }
356}
357
359 ccl_private ShaderData *sd,
360 const PathRayVisibility path_visibility,
361 const uint32_t /*path_flag*/,
362 const float3 weight,
363 const ccl_private ConductorBSDFClosure *closure,
364 float3 * /*layer_albedo*/)
365{
366 if (osl_closure_skip(kg, path_visibility, LABEL_GLOSSY | LABEL_REFLECT)) {
367 return;
368 }
369
371 sd, sizeof(MicrofacetBsdf), rgb_to_spectrum(weight));
372 if (!bsdf) {
373 return;
374 }
375
377 sd, sizeof(FresnelConductor));
378 if (!fresnel) {
379 return;
380 }
381
382 bsdf->N = maybe_ensure_valid_specular_reflection(sd, safe_normalize_fallback(closure->N, sd->N));
383 bsdf->alpha_x = closure->alpha_x;
384 bsdf->alpha_y = closure->alpha_y;
385 bsdf->ior = 0.0f;
386 bsdf->T = closure->T;
387
388 bool preserve_energy = false;
389
390 /* Beckmann */
391 if (closure->distribution == make_string("beckmann", 14712237670914973463ull)) {
392 sd->runtime_flag |= bsdf_microfacet_beckmann_setup(bsdf);
393 }
394 /* GGX (either single- or multi-scattering) */
395 else {
396 sd->runtime_flag |= bsdf_microfacet_ggx_setup(bsdf);
397 preserve_energy = (closure->distribution == make_string("multi_ggx", 16842698693386468366ull));
398 }
399
400 fresnel->thin_film.thickness = closure->thinfilm_thickness;
401 fresnel->thin_film.ior = closure->thinfilm_ior;
402
403 fresnel->ior = {rgb_to_spectrum(closure->ior), rgb_to_spectrum(closure->extinction)};
404 bsdf_microfacet_setup_fresnel_conductor(kg, bsdf, sd->wi, fresnel, preserve_energy);
405}
406
408 KernelGlobals kg,
409 ccl_private ShaderData *sd,
410 const PathRayVisibility path_visibility,
411 const uint32_t /*path_flag*/,
412 const float3 weight,
413 const ccl_private GeneralizedSchlickBSDFClosure *closure,
414 float3 *layer_albedo)
415{
416 osl_zero_albedo(layer_albedo);
417
418 const bool has_reflection = !is_zero(closure->reflection_tint);
419 const bool has_transmission = !is_zero(closure->transmission_tint);
420
421 int label = LABEL_GLOSSY | LABEL_REFLECT;
422 if (has_transmission) {
423 label |= LABEL_TRANSMIT;
424 }
425
426 if (osl_closure_skip(kg, path_visibility, label)) {
427 return;
428 }
429
431 sd, sizeof(MicrofacetBsdf), rgb_to_spectrum(weight));
432 if (!bsdf) {
433 return;
434 }
435
438 if (!fresnel) {
439 return;
440 }
441
442 const bool backfacing = (sd->runtime_flag & SR_BACKFACING);
443
444 bsdf->N = maybe_ensure_valid_specular_reflection(sd, safe_normalize_fallback(closure->N, sd->N));
445 bsdf->alpha_x = closure->alpha_x;
446 bsdf->alpha_y = closure->alpha_y;
447 bsdf->T = closure->T;
448
449 if (closure->exponent < 0.0f) {
450 /* Trick for principled BSDF: Since we use the real Fresnel equation and remap
451 * to the F0...F90 range, this allows us to use the real IOR.
452 * Computing it back from F0 might give a different result in case of specular
453 * tinting. */
454 const float ior = backfacing ? 1.0f / -closure->exponent : -closure->exponent;
455 bsdf->ior = bsdf_glass_ior(sd, ior, closure->inv_abbe);
456 }
457 else {
458 const float ior = ior_from_F0(average(closure->f0));
459 bsdf->ior = backfacing ? 1.0f / ior : ior;
460 }
461
462 bool preserve_energy = false;
463
464 /* Beckmann */
465 if (closure->distribution == make_string("beckmann", 14712237670914973463ull)) {
466 if (has_reflection && has_transmission) {
467 sd->runtime_flag |= bsdf_microfacet_beckmann_glass_setup(bsdf);
468 }
469 else if (has_transmission) {
470 sd->runtime_flag |= bsdf_microfacet_beckmann_refraction_setup(bsdf);
471 }
472 else {
473 sd->runtime_flag |= bsdf_microfacet_beckmann_setup(bsdf);
474 }
475 }
476 /* GGX (either single- or multi-scattering) */
477 else {
478 if (has_reflection && has_transmission) {
479 sd->runtime_flag |= bsdf_microfacet_ggx_glass_setup(bsdf);
480 }
481 else if (has_transmission) {
482 sd->runtime_flag |= bsdf_microfacet_ggx_refraction_setup(bsdf);
483 }
484 else {
485 sd->runtime_flag |= bsdf_microfacet_ggx_setup(bsdf);
486 }
487
488 preserve_energy = (closure->distribution == make_string("multi_ggx", 16842698693386468366ull));
489 }
490
491 const bool reflective_caustics = (kernel_data.integrator.caustics_reflective ||
492 (path_visibility & PATH_RAY_VISIBILITY_DIFFUSE) == 0);
493 const bool refractive_caustics = (kernel_data.integrator.caustics_refractive ||
494 (path_visibility & PATH_RAY_VISIBILITY_DIFFUSE) == 0);
495
496 fresnel->tint.reflectance = reflective_caustics ? rgb_to_spectrum(closure->reflection_tint) :
498 fresnel->tint.transmittance = refractive_caustics ? rgb_to_spectrum(closure->transmission_tint) :
500 fresnel->f0 = rgb_to_spectrum(closure->f0);
501 fresnel->f90 = rgb_to_spectrum(closure->f90);
502 fresnel->exponent = closure->exponent;
503 fresnel->thin_film.thickness = closure->thinfilm_thickness;
504 fresnel->thin_film.ior = closure->thinfilm_ior;
505 if (backfacing) {
506 adjust_thin_film_ior_at_backface(fresnel->thin_film.ior, bsdf->ior);
507 }
508 bsdf_microfacet_setup_fresnel_generalized_schlick(kg, bsdf, sd->wi, fresnel, preserve_energy);
509
510 if (layer_albedo != nullptr) {
511 if (has_reflection && !has_transmission) {
512 *layer_albedo = closure_layer_albedo(kg, sd, (ccl_private ShaderClosure *)bsdf);
513 }
514 else {
515 *layer_albedo = one_float3();
516 }
517 }
518}
519
521 ccl_private ShaderData *sd,
522 const PathRayVisibility path_visibility,
523 const uint32_t path_flag,
524 const float3 weight,
525 const ccl_private ThinGlassClosure *closure,
526 float3 *layer_albedo)
527{
528 osl_zero_albedo(layer_albedo);
529
530 const bool has_reflection = !is_zero(closure->reflection_tint);
531 const bool has_transmission = !is_zero(closure->transmission_tint);
532
533 int label = alpha_is_almost_specular(closure->alpha, closure->alpha) ? LABEL_SINGULAR :
535 if (has_transmission) {
536 label |= LABEL_TRANSMIT;
537 }
538 if (has_reflection) {
539 label |= LABEL_REFLECT;
540 }
541
542 if (osl_closure_skip(kg, path_visibility, label)) {
543 return;
544 }
545
546 const bool reflective_caustics = (kernel_data.integrator.caustics_reflective ||
547 (path_visibility & PATH_RAY_VISIBILITY_DIFFUSE) == 0);
548 const bool refractive_caustics = (kernel_data.integrator.caustics_refractive ||
549 (path_visibility & PATH_RAY_VISIBILITY_DIFFUSE) == 0);
550
551 const float3 valid_reflection_N = maybe_ensure_valid_specular_reflection(
552 sd, safe_normalize_fallback(closure->N, sd->N));
553 const FresnelThinFilm thinfilm = {closure->thinfilm_thickness, closure->thinfilm_ior};
554 const FresnelCoeff tint = {rgb_to_spectrum(closure->reflection_tint),
555 rgb_to_spectrum(closure->transmission_tint)};
556 const FresnelCoeff fresnel = bsdf_thin_glass_setup(kg,
557 sd,
558 reflective_caustics,
559 refractive_caustics,
560 tint,
561 rgb_to_spectrum(weight),
562 valid_reflection_N,
563 closure->alpha,
564 closure->ior,
565 thinfilm,
566 path_visibility,
567 path_flag);
568
569 if (layer_albedo != nullptr) {
570 *layer_albedo = fresnel.transmittance * !!has_transmission +
571 fresnel.reflectance * !!has_reflection;
572 }
573}
574
576 ccl_private ShaderData *sd,
577 const PathRayVisibility path_visibility,
578 const uint32_t /*path_flag*/,
579 const float3 weight,
580 const ccl_private ThinSubsurfaceClosure *closure,
581 float3 *layer_albedo)
582{
583 osl_zero_albedo(layer_albedo);
584
585 if (osl_closure_skip(kg, path_visibility, LABEL_DIFFUSE)) {
586 return;
587 }
588
589 const float3 N = safe_normalize_fallback(closure->N, sd->N);
591 sd, N, rgb_to_spectrum(weight), closure->anisotropy, closure->roughness, closure->color);
592}
593
594/* Standard microfacet closures */
595
597 ccl_private ShaderData *sd,
598 const PathRayVisibility path_visibility,
599 const uint32_t /*path_flag*/,
600 const float3 weight,
601 const ccl_private MicrofacetClosure *closure,
602 float3 *layer_albedo)
603{
604 osl_zero_albedo(layer_albedo);
605
606 const int label = (closure->refract) ? LABEL_TRANSMIT : LABEL_REFLECT;
607 if (osl_closure_skip(kg, path_visibility, LABEL_GLOSSY | label)) {
608 return;
609 }
610
612 sd, sizeof(MicrofacetBsdf), rgb_to_spectrum(weight));
613 if (!bsdf) {
614 return;
615 }
616
617 const bool backfacing = (sd->runtime_flag & SR_BACKFACING);
618
619 bsdf->N = maybe_ensure_valid_specular_reflection(sd, safe_normalize_fallback(closure->N, sd->N));
620 bsdf->alpha_x = closure->alpha_x;
621 bsdf->alpha_y = closure->alpha_y;
622 bsdf->ior = backfacing ? 1.0f / closure->ior : closure->ior;
623 bsdf->T = closure->T;
624
625 /* Beckmann */
626 if (closure->distribution == make_string("beckmann", 14712237670914973463ull)) {
627 if (closure->refract == 1) {
628 sd->runtime_flag |= bsdf_microfacet_beckmann_refraction_setup(bsdf);
629 }
630 else if (closure->refract == 2) {
631 sd->runtime_flag |= bsdf_microfacet_beckmann_glass_setup(bsdf);
632 }
633 else {
634 sd->runtime_flag |= bsdf_microfacet_beckmann_setup(bsdf);
635 }
636 }
637 /* Ashikhmin-Shirley */
638 else if (closure->distribution == make_string("ashikhmin_shirley", 11318482998918370922ull)) {
639 sd->runtime_flag |= bsdf_ashikhmin_shirley_setup(bsdf);
640 }
641 /* GGX (either single- or multi-scattering) */
642 else {
643 if (closure->refract == 1) {
644 sd->runtime_flag |= bsdf_microfacet_ggx_refraction_setup(bsdf);
645 }
646 else if (closure->refract == 2) {
647 sd->runtime_flag |= bsdf_microfacet_ggx_glass_setup(bsdf);
648 }
649 else {
650 sd->runtime_flag |= bsdf_microfacet_ggx_setup(bsdf);
651 }
652
653 if (closure->distribution == make_string("multi_ggx", 16842698693386468366ull)) {
654 /* Since there's no dedicated color input, the weight is the best we got. */
656 }
657 }
658
659 if (layer_albedo != nullptr) {
660 if (closure->refract == 0) {
661 *layer_albedo = closure_layer_albedo(kg, sd, (ccl_private ShaderClosure *)bsdf);
662 }
663 else {
664 *layer_albedo = one_float3();
665 }
666 }
667}
668
669/* Special-purpose Microfacet closures */
670
672 KernelGlobals kg,
673 ccl_private ShaderData *sd,
674 const PathRayVisibility path_visibility,
675 const uint32_t /*path_flag*/,
676 const float3 weight,
677 const ccl_private MicrofacetF82TintClosure *closure,
678 float3 * /*layer_albedo*/)
679{
680 if (osl_closure_skip(kg, path_visibility, LABEL_GLOSSY | LABEL_REFLECT)) {
681 return;
682 }
683
685 sd, sizeof(MicrofacetBsdf), rgb_to_spectrum(weight));
686 if (!bsdf) {
687 return;
688 }
689
691 sd, sizeof(FresnelF82Tint));
692 if (!fresnel) {
693 return;
694 }
695
696 bsdf->N = maybe_ensure_valid_specular_reflection(sd, safe_normalize_fallback(closure->N, sd->N));
697 bsdf->alpha_x = closure->alpha_x;
698 bsdf->alpha_y = closure->alpha_y;
699 bsdf->ior = 0.0f;
700 bsdf->T = closure->T;
701
702 bool preserve_energy = false;
703
704 /* Beckmann */
705 if (closure->distribution == make_string("beckmann", 14712237670914973463ull)) {
706 sd->runtime_flag |= bsdf_microfacet_beckmann_setup(bsdf);
707 }
708 /* GGX (either single- or multi-scattering) */
709 else {
710 sd->runtime_flag |= bsdf_microfacet_ggx_setup(bsdf);
711 preserve_energy = (closure->distribution == make_string("multi_ggx", 16842698693386468366ull));
712 }
713
714 fresnel->f0 = rgb_to_spectrum(closure->f0);
715 fresnel->thin_film.thickness = closure->thinfilm_thickness;
716 fresnel->thin_film.ior = closure->thinfilm_ior;
717
719 kg, bsdf, sd->wi, fresnel, rgb_to_spectrum(closure->f82), preserve_energy);
720}
721
723 KernelGlobals kg,
724 ccl_private ShaderData *sd,
725 const PathRayVisibility path_visibility,
726 const uint32_t /*path_flag*/,
727 const float3 weight,
728 const ccl_private MicrofacetMultiGGXGlassClosure *closure,
729 float3 * /*layer_albedo*/)
730{
731 /* Technically, the MultiGGX closure may also transmit. However,
732 * since this is set statically and only used for caustic flags, this
733 * is probably as good as it gets. */
734 if (osl_closure_skip(kg, path_visibility, LABEL_GLOSSY | LABEL_REFLECT)) {
735 return;
736 }
737
739 sd, sizeof(MicrofacetBsdf), rgb_to_spectrum(weight));
740 if (!bsdf) {
741 return;
742 }
743
744 const bool backfacing = (sd->runtime_flag & SR_BACKFACING);
745
746 bsdf->N = maybe_ensure_valid_specular_reflection(sd, safe_normalize_fallback(closure->N, sd->N));
747 bsdf->alpha_x = closure->alpha_x;
748 bsdf->alpha_y = bsdf->alpha_x;
749 bsdf->ior = backfacing ? 1.0f / closure->ior : closure->ior;
750
751 bsdf->T = zero_float3();
752
753 sd->runtime_flag |= bsdf_microfacet_ggx_glass_setup(bsdf);
754 bsdf_microfacet_setup_fresnel_constant(kg, bsdf, sd->wi, rgb_to_spectrum(closure->color));
755}
756
758 KernelGlobals kg,
759 ccl_private ShaderData *sd,
760 const PathRayVisibility path_visibility,
761 const uint32_t /*path_flag*/,
762 const float3 weight,
763 const ccl_private MicrofacetMultiGGXClosure *closure,
764 float3 *layer_albedo)
765{
766 osl_zero_albedo(layer_albedo);
767
768 if (osl_closure_skip(kg, path_visibility, LABEL_GLOSSY | LABEL_REFLECT)) {
769 return;
770 }
771
773 sd, sizeof(MicrofacetBsdf), rgb_to_spectrum(weight));
774 if (!bsdf) {
775 return;
776 }
777
778 bsdf->N = maybe_ensure_valid_specular_reflection(sd, safe_normalize_fallback(closure->N, sd->N));
779 bsdf->alpha_x = closure->alpha_x;
780 bsdf->alpha_y = closure->alpha_y;
781 bsdf->ior = 1.0f;
782
783 bsdf->T = closure->T;
784
785 sd->runtime_flag |= bsdf_microfacet_ggx_setup(bsdf);
786 bsdf_microfacet_setup_fresnel_constant(kg, bsdf, sd->wi, rgb_to_spectrum(closure->color));
787
788 if (layer_albedo != nullptr) {
789 *layer_albedo = closure_layer_albedo(kg, sd, (ccl_private ShaderClosure *)bsdf);
790 }
791}
792
793/* Ashikhmin Velvet */
794
796 KernelGlobals kg,
797 ccl_private ShaderData *sd,
798 const PathRayVisibility path_visibility,
799 const uint32_t /*path_flag*/,
800 const float3 weight,
801 const ccl_private AshikhminVelvetClosure *closure,
802 float3 * /*layer_albedo*/)
803{
804 if (osl_closure_skip(kg, path_visibility, LABEL_DIFFUSE)) {
805 return;
806 }
807
809 sd, sizeof(VelvetBsdf), rgb_to_spectrum(weight));
810 if (!bsdf) {
811 return;
812 }
813
814 bsdf->N = maybe_ensure_valid_specular_reflection(sd, safe_normalize_fallback(closure->N, sd->N));
815 bsdf->sigma = closure->sigma;
816
817 sd->runtime_flag |= bsdf_ashikhmin_velvet_setup(bsdf);
818}
819
820/* Sheen */
822 ccl_private ShaderData *sd,
823 const PathRayVisibility path_visibility,
824 const uint32_t /*path_flag*/,
825 const float3 weight,
826 const ccl_private SheenBSDFClosure *closure,
827 float3 *layer_albedo)
828{
829 osl_zero_albedo(layer_albedo);
830
831 if (osl_closure_skip(kg, path_visibility, LABEL_DIFFUSE)) {
832 return;
833 }
834
835 const float3 N = safe_normalize_fallback(closure->N, sd->N);
836 const Spectrum color = rgb_to_spectrum(closure->albedo);
837 const Spectrum albedo = bsdf_sheen_setup(
838 kg, sd, rgb_to_spectrum(weight) * color, N, closure->roughness);
839
840 if (layer_albedo) {
841 *layer_albedo = spectrum_to_rgb(albedo);
842 }
843}
844
846 ccl_private ShaderData *sd,
847 const PathRayVisibility path_visibility,
848 const uint32_t /*path_flag*/,
849 const float3 weight,
850 const ccl_private DiffuseToonClosure *closure,
851 float3 * /*layer_albedo*/)
852{
853 if (osl_closure_skip(kg, path_visibility, LABEL_DIFFUSE)) {
854 return;
855 }
856
858 sd, sizeof(ToonBsdf), rgb_to_spectrum(weight));
859 if (!bsdf) {
860 return;
861 }
862
863 bsdf->N = maybe_ensure_valid_specular_reflection(sd, safe_normalize_fallback(closure->N, sd->N));
864 bsdf->size = closure->size;
865 bsdf->smooth = closure->smooth;
866
867 sd->runtime_flag |= bsdf_diffuse_toon_setup(bsdf);
868}
869
871 ccl_private ShaderData *sd,
872 const PathRayVisibility path_visibility,
873 const uint32_t /*path_flag*/,
874 const float3 weight,
875 const ccl_private GlossyToonClosure *closure,
876 float3 * /*layer_albedo*/)
877{
878 if (osl_closure_skip(kg, path_visibility, LABEL_GLOSSY)) {
879 return;
880 }
881
883 sd, sizeof(ToonBsdf), rgb_to_spectrum(weight));
884 if (!bsdf) {
885 return;
886 }
887
888 bsdf->N = maybe_ensure_valid_specular_reflection(sd, safe_normalize_fallback(closure->N, sd->N));
889 bsdf->size = closure->size;
890 bsdf->smooth = closure->smooth;
891
892 sd->runtime_flag |= bsdf_glossy_toon_setup(bsdf);
893}
894
895/* Variable cone emissive closure
896 *
897 * This primitive emits in a cone having a configurable penumbra area where the light decays to 0
898 * reaching the outer_angle limit. It can also behave as a lambertian emitter if the provided
899 * angles are PI/2, which is the default
900 */
902 ccl_private ShaderData *sd,
903 const PathRayVisibility path_visibility,
904 const uint32_t path_flag,
905 float3 weight,
906 const ccl_private GenericEmissiveClosure * /*closure*/,
907 float3 * /*layer_albedo*/)
908{
909 if (sd->runtime_flag & SR_IS_VOLUME_SHADER_EVAL) {
910 if ((path_visibility & PATH_RAY_VISIBILITY_SHADOW) || (path_flag & PATH_RAY_EXTINCTION)) {
911 /* Don't need emission for shadows and extinction. */
912 return;
913 }
914 weight *= object_volume_density(kg, sd->object);
915 }
916 emission_setup(sd, rgb_to_spectrum(weight));
917}
918
919/* Generic background closure
920 *
921 * We only have a background closure for the shaders to return a color in background shaders. No
922 * methods, only the weight is taking into account
923 */
925 KernelGlobals /*kg*/,
926 ccl_private ShaderData *sd,
927 const PathRayVisibility /*path_visibility*/,
928 const uint32_t /*path_flag*/,
929 const float3 weight,
930 const ccl_private GenericBackgroundClosure * /*closure*/,
931 float3 * /*layer_albedo*/)
932{
934}
935
936/* Uniform EDF
937 *
938 * This is a duplicate of emission above except an emittance value can be passed to the weight.
939 * This is for MaterialX closure compatibility found in `stdosl.h`.
940 */
942 ccl_private ShaderData *sd,
943 const PathRayVisibility path_visibility,
944 const uint32_t path_flag,
945 float3 weight,
946 const ccl_private UniformEDFClosure *closure,
947 float3 * /*layer_albedo*/)
948{
949 weight *= closure->emittance;
950 if (sd->runtime_flag & SR_IS_VOLUME_SHADER_EVAL) {
951 if ((path_visibility & PATH_RAY_VISIBILITY_SHADOW) || (path_flag & PATH_RAY_EXTINCTION)) {
952 /* Don't need emission for shadows and extinction. */
953 return;
954 }
955 weight *= object_volume_density(kg, sd->object);
956 }
957 emission_setup(sd, rgb_to_spectrum(weight));
958}
959
960/* Holdout closure
961 *
962 * This will be used by the shader to mark the amount of holdout for the current shading point. No
963 * parameters, only the weight will be used
964 */
966 ccl_private ShaderData *sd,
967 const PathRayVisibility /*path_visibility*/,
968 const uint32_t /*path_flag*/,
969 const float3 weight,
970 const ccl_private HoldoutClosure * /*closure*/,
971 float3 * /*layer_albedo*/)
972{
973 closure_alloc(sd, sizeof(ShaderClosure), CLOSURE_HOLDOUT_ID, rgb_to_spectrum(weight));
974 sd->runtime_flag |= SR_HOLDOUT;
975}
976
978 ccl_private ShaderData *sd,
979 const PathRayVisibility /*path_visibility*/,
980 const uint32_t /*path_flag*/,
981 const float3 weight,
982 const ccl_private DiffuseRampClosure *closure,
983 float3 * /*layer_albedo*/)
984{
985 ccl_private DiffuseRampBsdf *bsdf = (ccl_private DiffuseRampBsdf *)bsdf_alloc(
986 sd, sizeof(DiffuseRampBsdf), rgb_to_spectrum(weight));
987
988 if (!bsdf) {
989 return;
990 }
991
992 bsdf->N = safe_normalize_fallback(closure->N, sd->N);
993
994 bsdf->colors = (float3 *)closure_alloc_extra(sd, sizeof(float3) * 8);
995 if (!bsdf->colors) {
996 return;
997 }
998
999 for (int i = 0; i < 8; i++) {
1000 bsdf->colors[i] = closure->colors[i];
1001 }
1002
1003 sd->runtime_flag |= bsdf_diffuse_ramp_setup(bsdf);
1004}
1005
1007 ccl_private ShaderData *sd,
1008 const PathRayVisibility /*path_visibility*/,
1009 const uint32_t /*path_flag*/,
1010 const float3 weight,
1011 const ccl_private PhongRampClosure *closure,
1012 float3 * /*layer_albedo*/)
1013{
1014 ccl_private PhongRampBsdf *bsdf = (ccl_private PhongRampBsdf *)bsdf_alloc(
1015 sd, sizeof(PhongRampBsdf), rgb_to_spectrum(weight));
1016 if (!bsdf) {
1017 return;
1018 }
1019
1020 bsdf->N = maybe_ensure_valid_specular_reflection(sd, safe_normalize_fallback(closure->N, sd->N));
1021 bsdf->exponent = closure->exponent;
1022
1023 bsdf->colors = (float3 *)closure_alloc_extra(sd, sizeof(float3) * 8);
1024 if (!bsdf->colors) {
1025 return;
1026 }
1027
1028 for (int i = 0; i < 8; i++) {
1029 bsdf->colors[i] = closure->colors[i];
1030 }
1031
1032 sd->runtime_flag |= bsdf_phong_ramp_setup(bsdf);
1033}
1034
1036 ccl_private ShaderData *sd,
1037 const PathRayVisibility /*path_visibility*/,
1038 const uint32_t path_flag,
1039 const float3 weight,
1040 const ccl_private BSSRDFClosure *closure,
1041 float3 * /*layer_albedo*/)
1042{
1043 ClosureType type;
1044 if (closure->method == make_string("burley", 186330084368958868ull)) {
1046 }
1047 else if (closure->method == make_string("random_walk", 11360609267673527222ull)) {
1049 }
1050 else if (closure->method == make_string("random_walk_skin", 3096325052680726300ull)) {
1052 }
1053 else if (closure->method == make_string("random_walk_legacy", 3162086485308246001ull)) {
1055 }
1056 else {
1057 return;
1058 }
1059
1061 if (!bssrdf) {
1062 return;
1063 }
1064
1065 bssrdf->radius = closure->radius;
1066
1067 bssrdf->albedo = closure->albedo;
1069 safe_normalize_fallback(closure->N, sd->N));
1070 bssrdf->alpha = closure->roughness;
1071 bssrdf->ior = closure->ior;
1072 bssrdf->anisotropy = closure->anisotropy;
1073
1074 sd->runtime_flag |= bssrdf_setup(sd, bssrdf, path_flag, type);
1075}
1076
1077/* MaterialX-compatible subsurface_bssrdf */
1079 KernelGlobals /*kg*/,
1080 ccl_private ShaderData *sd,
1081 const PathRayVisibility /*path_visibility*/,
1082 const uint32_t path_flag,
1083 const float3 weight,
1084 const ccl_private SubsurfaceBSSRDFClosure *closure,
1085 float3 * /*layer_albedo*/)
1086{
1087 ccl_private Bssrdf *bssrdf = bssrdf_alloc(sd, rgb_to_spectrum(closure->albedo * weight));
1088 if (!bssrdf) {
1089 return;
1090 }
1091
1092#if OSL_LIBRARY_VERSION_CODE >= 11401
1093 bssrdf->radius = closure->radius;
1094#else
1095 bssrdf->radius = closure->transmission_depth * closure->transmission_color;
1096#endif
1097
1098 bssrdf->albedo = closure->albedo;
1100 safe_normalize_fallback(closure->N, sd->N));
1101 bssrdf->alpha = 1.0f;
1102 bssrdf->ior = 1.4f;
1103 bssrdf->anisotropy = closure->anisotropy;
1104
1105 sd->runtime_flag |= bssrdf_setup(sd, bssrdf, path_flag, CLOSURE_BSSRDF_RANDOM_WALK_ID);
1106}
1107
1108/* Hair */
1109
1111 ccl_private ShaderData *sd,
1112 const PathRayVisibility path_visibility,
1113 const uint32_t /*path_flag*/,
1114 const float3 weight,
1115 const ccl_private HairReflectionClosure *closure,
1116 float3 * /*layer_albedo*/)
1117{
1118 if (osl_closure_skip(kg, path_visibility, LABEL_GLOSSY)) {
1119 return;
1120 }
1121
1123 sd, sizeof(HairBsdf), rgb_to_spectrum(weight));
1124 if (!bsdf) {
1125 return;
1126 }
1127
1128 bsdf->N = maybe_ensure_valid_specular_reflection(sd, safe_normalize_fallback(closure->N, sd->N));
1129 bsdf->T = closure->T;
1130 bsdf->roughness1 = closure->roughness1;
1131 bsdf->roughness2 = closure->roughness2;
1132 bsdf->offset = closure->offset;
1133
1134 sd->runtime_flag |= bsdf_hair_reflection_setup(bsdf);
1135}
1136
1138 KernelGlobals kg,
1139 ccl_private ShaderData *sd,
1140 const PathRayVisibility path_visibility,
1141 const uint32_t /*path_flag*/,
1142 const float3 weight,
1143 const ccl_private HairTransmissionClosure *closure,
1144 float3 * /*layer_albedo*/)
1145{
1146 if (osl_closure_skip(kg, path_visibility, LABEL_GLOSSY)) {
1147 return;
1148 }
1149
1151 sd, sizeof(HairBsdf), rgb_to_spectrum(weight));
1152 if (!bsdf) {
1153 return;
1154 }
1155
1156 bsdf->N = maybe_ensure_valid_specular_reflection(sd, safe_normalize_fallback(closure->N, sd->N));
1157 bsdf->T = closure->T;
1158 bsdf->roughness1 = closure->roughness1;
1159 bsdf->roughness2 = closure->roughness2;
1160 bsdf->offset = closure->offset;
1161
1162 sd->runtime_flag |= bsdf_hair_transmission_setup(bsdf);
1163}
1164
1166 ccl_private ShaderData *sd,
1167 const PathRayVisibility path_visibility,
1168 const uint32_t /*path_flag*/,
1169 const float3 weight,
1170 const ccl_private ChiangHairClosure *closure,
1171 float3 * /*layer_albedo*/)
1172{
1173#ifdef __HAIR__
1174 if (osl_closure_skip(kg, path_visibility, LABEL_GLOSSY)) {
1175 return;
1176 }
1177
1179 sd, sizeof(ChiangHairBSDF), rgb_to_spectrum(weight));
1180 if (!bsdf) {
1181 return;
1182 }
1183
1184 bsdf->N = maybe_ensure_valid_specular_reflection(sd, safe_normalize_fallback(closure->N, sd->N));
1185 bsdf->sigma = closure->sigma;
1186 bsdf->v = closure->v;
1187 bsdf->s = closure->s;
1188 bsdf->alpha = closure->alpha;
1189 bsdf->eta = closure->eta;
1190 bsdf->m0_roughness = closure->m0_roughness;
1191
1192 sd->runtime_flag |= bsdf_hair_chiang_setup(sd, bsdf);
1193#endif
1194}
1195
1197 ccl_private ShaderData *sd,
1198 const PathRayVisibility path_visibility,
1199 const uint32_t path_flag,
1200 const float3 weight,
1201 const ccl_private HuangHairClosure *closure,
1202 float3 * /*layer_albedo*/)
1203{
1204#ifdef __HAIR__
1205 if (osl_closure_skip(kg, path_visibility, LABEL_GLOSSY)) {
1206 return;
1207 }
1208
1209 if (closure->r_lobe <= 0.0f && closure->tt_lobe <= 0.0f && closure->trt_lobe <= 0.0f) {
1210 return;
1211 }
1212
1214 sd, sizeof(HuangHairBSDF), rgb_to_spectrum(weight));
1215 if (!bsdf) {
1216 return;
1217 }
1218
1220 sd, sizeof(HuangHairExtra));
1221 if (!extra) {
1222 return;
1223 }
1224
1225 bsdf->N = safe_normalize_fallback(closure->N, sd->N);
1226 bsdf->sigma = closure->sigma;
1227 bsdf->roughness = closure->roughness;
1228 bsdf->tilt = closure->tilt;
1229 bsdf->eta = closure->eta;
1230 bsdf->aspect_ratio = closure->aspect_ratio;
1231
1232 bsdf->extra = extra;
1233 bsdf->extra->R = closure->r_lobe;
1234 bsdf->extra->TT = closure->tt_lobe;
1235 bsdf->extra->TRT = closure->trt_lobe;
1236
1237 bsdf->extra->pixel_coverage = 1.0f;
1238
1239 /* For camera ray, check if the hair covers more than one pixel, in which case a nearfield model
1240 * is needed to prevent ribbon-like appearance. */
1241 if ((path_visibility & PATH_RAY_VISIBILITY_CAMERA) && (sd->type & PRIMITIVE_CURVE)) {
1242 /* Interpolate radius between curve keys. */
1243 const KernelCurve kcurve = kernel_data_fetch(curves, sd->prim);
1244 const int k0 = kcurve.first_key + PRIMITIVE_UNPACK_SEGMENT(sd->type);
1245 const int k1 = k0 + 1;
1246 const int position_offset = kernel_data_fetch(objects, sd->object).position_offset;
1247 const float radius = mix(kernel_data_fetch(curve_keys, position_offset + k0).w,
1248 kernel_data_fetch(curve_keys, position_offset + k1).w,
1249 sd->u);
1250
1251 bsdf->extra->pixel_coverage = 0.5f * sd->dP / radius;
1252 }
1253
1254 sd->runtime_flag |= bsdf_hair_huang_setup(sd, bsdf, path_flag);
1255#endif
1256}
1257
1258/* Volume */
1259
1261 KernelGlobals kg,
1262 ccl_private ShaderData *sd,
1263 const PathRayVisibility /*path_visibility*/,
1264 const uint32_t /*path_flag*/,
1265 float3 weight,
1266 const ccl_private VolumeAbsorptionClosure * /*closure*/,
1267 float3 * /*layer_albedo*/)
1268{
1269 volume_extinction_setup(sd, rgb_to_spectrum(weight * object_volume_density(kg, sd->object)));
1270}
1271
1273 KernelGlobals kg,
1274 ccl_private ShaderData *sd,
1275 const PathRayVisibility /*path_visibility*/,
1276 const uint32_t /*path_flag*/,
1277 float3 weight,
1278 const ccl_private VolumeHenyeyGreensteinClosure *closure,
1279 float3 * /*layer_albedo*/)
1280{
1281 weight *= object_volume_density(kg, sd->object);
1283
1285 sd, sizeof(HenyeyGreensteinVolume), rgb_to_spectrum(weight));
1286 if (!volume) {
1287 return;
1288 }
1289
1290 volume->g = closure->g;
1291
1292 sd->runtime_flag |= volume_henyey_greenstein_setup(volume);
1293}
1294
1296 KernelGlobals /*kg*/,
1297 ccl_private ShaderData *sd,
1298 const PathRayVisibility /*path_visibility*/,
1299 const uint32_t /*path_flag*/,
1300 const float3 weight,
1301 const ccl_private VolumeFournierForandClosure *closure,
1302 float3 * /*layer_albedo*/)
1303{
1305
1307 sd, sizeof(FournierForandVolume), rgb_to_spectrum(weight));
1308 if (!volume) {
1309 return;
1310 }
1311
1312 sd->runtime_flag |= volume_fournier_forand_setup(volume, closure->B, closure->IOR);
1313}
1314
1316 ccl_private ShaderData *sd,
1317 const PathRayVisibility /*path_visibility*/,
1318 const uint32_t /*path_flag*/,
1319 const float3 weight,
1320 const ccl_private VolumeDraineClosure *closure,
1321 float3 * /*layer_albedo*/)
1322{
1324
1326 sd, sizeof(DraineVolume), rgb_to_spectrum(weight));
1327 if (!volume) {
1328 return;
1329 }
1330
1331 volume->g = closure->g;
1332 volume->alpha = closure->alpha;
1333
1334 sd->runtime_flag |= volume_draine_setup(volume);
1335}
1336
1338 ccl_private ShaderData *sd,
1339 const PathRayVisibility /*path_visibility*/,
1340 const uint32_t /*path_flag*/,
1341 const float3 weight,
1342 const ccl_private VolumeRayleighClosure * /*closure*/,
1343 float3 * /*layer_albedo*/)
1344{
1346
1348 sd, sizeof(RayleighVolume), rgb_to_spectrum(weight));
1349 if (!volume) {
1350 return;
1351 }
1352
1353 sd->runtime_flag |= volume_rayleigh_setup(volume);
1354}
1355
1357 ccl_private ShaderData *sd,
1358 const PathRayVisibility /*path_visibility*/,
1359 const uint32_t /*path_flag*/,
1360 float3 weight,
1361 const ccl_private AnisotropicVDFClosure *closure,
1362 float3 * /*layer_albedo*/)
1363{
1364 if (!(sd->runtime_flag & SR_IS_VOLUME_SHADER_EVAL)) {
1365 return;
1366 }
1367
1368 weight *= object_volume_density(kg, sd->object) * closure->extinction;
1370
1372 sd, sizeof(HenyeyGreensteinVolume), rgb_to_spectrum(weight * closure->albedo));
1373 if (!volume) {
1374 return;
1375 }
1376
1377 volume->g = closure->anisotropy;
1378
1379 sd->runtime_flag |= volume_henyey_greenstein_setup(volume);
1380}
1381
CCL_NAMESPACE_BEGIN ccl_device ccl_private ShaderClosure * closure_alloc(ccl_private ShaderData *sd, const uint size, ClosureType type, Spectrum weight)
Definition alloc.h:11
ccl_device_inline ccl_private ShaderClosure * bsdf_alloc(ccl_private ShaderData *sd, const int size, Spectrum weight)
Definition alloc.h:76
ccl_device ccl_private void * closure_alloc_extra(ccl_private ShaderData *sd, const int size)
Definition alloc.h:34
ccl_device_inline Spectrum closure_layer_albedo(KernelGlobals kg, const ccl_private ShaderData *sd, const ccl_private ShaderClosure *sc)
Definition bsdf.h:743
CCL_NAMESPACE_BEGIN ccl_device int bsdf_ashikhmin_shirley_setup(ccl_private MicrofacetBsdf *bsdf)
ccl_device int bsdf_ashikhmin_velvet_setup(ccl_private VelvetBsdf *bsdf)
ccl_device void bsdf_translucent_setup(ccl_private ShaderData *sd, const float3 N, const Spectrum weight)
ccl_device void bsdf_diffuse_setup(ccl_private ShaderData *sd, const float3 N, const Spectrum weight)
ccl_device int bsdf_hair_reflection_setup(ccl_private HairBsdf *bsdf)
Definition bsdf_hair.h:27
ccl_device int bsdf_hair_transmission_setup(ccl_private HairBsdf *bsdf)
Definition bsdf_hair.h:35
ccl_device void bsdf_microfacet_setup_fresnel_conductor(KernelGlobals kg, ccl_private MicrofacetBsdf *bsdf, const float3 wi, ccl_private FresnelConductor *fresnel, const bool preserve_energy)
ccl_device void bsdf_microfacet_setup_fresnel_generalized_schlick(KernelGlobals kg, ccl_private MicrofacetBsdf *bsdf, const float3 wi, ccl_private FresnelGeneralizedSchlick *fresnel, const bool preserve_energy)
ccl_device Spectrum bsdf_coat_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility ray_visibility, ccl_private Coat &coat)
ccl_device int bsdf_microfacet_beckmann_glass_setup(ccl_private MicrofacetBsdf *bsdf)
ccl_device int bsdf_microfacet_beckmann_setup(ccl_private MicrofacetBsdf *bsdf)
ccl_device void bsdf_microfacet_setup_fresnel_f82_tint(KernelGlobals kg, ccl_private MicrofacetBsdf *bsdf, const float3 wi, ccl_private FresnelF82Tint *fresnel, const Spectrum f82_tint, const bool preserve_energy)
ccl_device void bsdf_dielectric_tint_setup(KernelGlobals kg, ccl_private MicrofacetBsdf *bsdf, ccl_private ShaderData *sd, ccl_private FresnelDielectricTint *fresnel, const bool is_beckmann=false, const bool preserve_energy=true)
ccl_device void bsdf_microfacet_setup_fresnel_constant(KernelGlobals kg, ccl_private MicrofacetBsdf *bsdf, const float3 wi, const Spectrum color)
ccl_device_forceinline bool alpha_is_almost_specular(const float alpha_x, const float alpha_y)
ccl_device FresnelCoeff bsdf_thin_glass_setup(KernelGlobals kg, ccl_private ShaderData *sd, const bool reflective, const bool refractive, const FresnelCoeff tint, const Spectrum weight, const float3 N, const float alpha, const float ior, const FresnelThinFilm thinfilm, const PathRayVisibility ray_visibility, const uint32_t path_flag)
ccl_device int bsdf_microfacet_beckmann_refraction_setup(ccl_private MicrofacetBsdf *bsdf)
ccl_device_inline float bsdf_glass_ior(ccl_private ShaderData *sd, float ior, const float inv_abbe)
ccl_device_inline void adjust_thin_film_ior_at_backface(ccl_private float &film_ior, const float inv_bulk_ior)
ccl_device int bsdf_microfacet_ggx_glass_setup(ccl_private MicrofacetBsdf *bsdf)
ccl_device int bsdf_microfacet_ggx_setup(ccl_private MicrofacetBsdf *bsdf)
ccl_device int bsdf_microfacet_ggx_refraction_setup(ccl_private MicrofacetBsdf *bsdf)
ccl_device void bsdf_oren_nayar_setup(ccl_private ShaderData *sd, const float3 N, const Spectrum weight, const float roughness, const Spectrum color)
ccl_device_inline void bsdf_thin_subsurface_setup(ccl_private ShaderData *sd, const float3 N, const Spectrum weight, const float anisotropy, const float roughness, const Spectrum color)
ccl_device void bsdf_ray_portal_setup(ccl_private ShaderData *sd, const Spectrum weight, const float3 position, float3 direction)
ccl_device Spectrum bsdf_sheen_setup(KernelGlobals kg, ccl_private ShaderData *sd, const Spectrum weight, const float3 N, const float roughness)
Definition bsdf_sheen.h:30
ccl_device int bsdf_diffuse_toon_setup(ccl_private ToonBsdf *bsdf)
Definition bsdf_toon.h:35
ccl_device int bsdf_glossy_toon_setup(ccl_private ToonBsdf *bsdf)
Definition bsdf_toon.h:119
CCL_NAMESPACE_BEGIN ccl_device void bsdf_transparent_setup(ccl_private ShaderData *sd, const Spectrum weight, const uint32_t path_flag)
ccl_device float3 maybe_ensure_valid_specular_reflection(ccl_private ShaderData *sd, const float3 N)
Definition bsdf_util.h:399
ccl_device_inline ccl_private Bssrdf * bssrdf_alloc(ccl_private ShaderData *sd, Spectrum weight)
Definition bssrdf.h:270
ccl_device int bssrdf_setup(ccl_private ShaderData *sd, ccl_private Bssrdf *bssrdf, const uint32_t path_flag, ClosureType type)
Definition bssrdf.h:288
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
Definition btQuadWord.h:119
ccl_device void osl_closure_microfacet_multi_ggx_glass_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t, const float3 weight, const ccl_private MicrofacetMultiGGXGlassClosure *closure, float3 *)
ccl_device void osl_closure_hair_chiang_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t, const float3 weight, const ccl_private ChiangHairClosure *closure, float3 *)
ccl_device void osl_closure_fournier_forand_setup(KernelGlobals, ccl_private ShaderData *sd, const PathRayVisibility, const uint32_t, const float3 weight, const ccl_private VolumeFournierForandClosure *closure, float3 *)
ccl_device void osl_closure_draine_setup(KernelGlobals, ccl_private ShaderData *sd, const PathRayVisibility, const uint32_t, const float3 weight, const ccl_private VolumeDraineClosure *closure, float3 *)
ccl_device_forceinline bool osl_closure_skip(KernelGlobals kg, const PathRayVisibility path_visibility, const int scattering)
ccl_device void osl_closure_microfacet_multi_ggx_aniso_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t, const float3 weight, const ccl_private MicrofacetMultiGGXClosure *closure, float3 *layer_albedo)
ccl_device void osl_closure_uniform_edf_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t path_flag, float3 weight, const ccl_private UniformEDFClosure *closure, float3 *)
ccl_device void osl_closure_translucent_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t, const float3 weight, const ccl_private TranslucentClosure *closure, float3 *)
ccl_device void osl_closure_thin_subsurface_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t, const float3 weight, const ccl_private ThinSubsurfaceClosure *closure, float3 *layer_albedo)
ccl_device void osl_closure_phong_ramp_setup(KernelGlobals, ccl_private ShaderData *sd, const PathRayVisibility, const uint32_t, const float3 weight, const ccl_private PhongRampClosure *closure, float3 *)
ccl_device void osl_closure_transparent_setup(KernelGlobals, ccl_private ShaderData *sd, const PathRayVisibility, const uint32_t path_flag, const float3 weight, const ccl_private TransparentClosure *, float3 *)
ccl_device void osl_closure_holdout_setup(KernelGlobals, ccl_private ShaderData *sd, const PathRayVisibility, const uint32_t, const float3 weight, const ccl_private HoldoutClosure *, float3 *)
ccl_device void osl_closure_hair_reflection_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t, const float3 weight, const ccl_private HairReflectionClosure *closure, float3 *)
ccl_device void osl_closure_dielectric_bsdf_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t, const float3 weight, const ccl_private DielectricBSDFClosure *closure, float3 *layer_albedo)
ccl_device void osl_closure_rayleigh_setup(KernelGlobals, ccl_private ShaderData *sd, const PathRayVisibility, const uint32_t, const float3 weight, const ccl_private VolumeRayleighClosure *, float3 *)
ccl_device void osl_closure_coat_bsdf_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t, const float3 weight, const ccl_private CoatBSDFClosure *closure, float3 *layer_albedo)
ccl_device void osl_closure_anisotropic_vdf_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility, const uint32_t, float3 weight, const ccl_private AnisotropicVDFClosure *closure, float3 *)
ccl_device void osl_closure_ray_portal_bsdf_setup(KernelGlobals, ccl_private ShaderData *sd, const PathRayVisibility, const uint32_t, const float3 weight, const ccl_private RayPortalBSDFClosure *closure, float3 *)
ccl_device void osl_closure_thin_glass_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t path_flag, const float3 weight, const ccl_private ThinGlassClosure *closure, float3 *layer_albedo)
ccl_device void osl_closure_refraction_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t, const float3 weight, const ccl_private RefractionClosure *closure, float3 *)
ccl_device void osl_closure_absorption_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility, const uint32_t, float3 weight, const ccl_private VolumeAbsorptionClosure *, float3 *)
ccl_device void osl_closure_sheen_bsdf_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t, const float3 weight, const ccl_private SheenBSDFClosure *closure, float3 *layer_albedo)
ccl_device void osl_closure_reflection_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t, const float3 weight, const ccl_private ReflectionClosure *closure, float3 *)
ccl_device void osl_closure_emission_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t path_flag, float3 weight, const ccl_private GenericEmissiveClosure *, float3 *)
ccl_device void osl_closure_translucent_bsdf_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t, const float3 weight, const ccl_private TranslucentBSDFClosure *closure, float3 *)
ccl_device void osl_closure_conductor_bsdf_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t, const float3 weight, const ccl_private ConductorBSDFClosure *closure, float3 *)
ccl_device void osl_closure_microfacet_f82_tint_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t, const float3 weight, const ccl_private MicrofacetF82TintClosure *closure, float3 *)
ccl_device void osl_closure_oren_nayar_diffuse_bsdf_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t, const float3 weight, const ccl_private OrenNayarDiffuseBSDFClosure *closure, float3 *)
ccl_device void osl_closure_burley_diffuse_bsdf_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t, const float3 weight, ccl_private const BurleyDiffuseBSDFClosure *closure, float3 *)
ccl_device void osl_closure_hair_huang_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t path_flag, const float3 weight, const ccl_private HuangHairClosure *closure, float3 *)
ccl_device_forceinline void osl_zero_albedo(float3 *layer_albedo)
ccl_device void osl_closure_background_setup(KernelGlobals, ccl_private ShaderData *sd, const PathRayVisibility, const uint32_t, const float3 weight, const ccl_private GenericBackgroundClosure *, float3 *)
ccl_device void osl_closure_henyey_greenstein_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility, const uint32_t, float3 weight, const ccl_private VolumeHenyeyGreensteinClosure *closure, float3 *)
ccl_device void osl_closure_diffuse_ramp_setup(KernelGlobals, ccl_private ShaderData *sd, const PathRayVisibility, const uint32_t, const float3 weight, const ccl_private DiffuseRampClosure *closure, float3 *)
ccl_device void osl_closure_hair_transmission_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t, const float3 weight, const ccl_private HairTransmissionClosure *closure, float3 *)
ccl_device void osl_closure_generalized_schlick_bsdf_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t, const float3 weight, const ccl_private GeneralizedSchlickBSDFClosure *closure, float3 *layer_albedo)
ccl_device void osl_closure_subsurface_bssrdf_setup(KernelGlobals, ccl_private ShaderData *sd, const PathRayVisibility, const uint32_t path_flag, const float3 weight, const ccl_private SubsurfaceBSSRDFClosure *closure, float3 *)
ccl_device void osl_closure_oren_nayar_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t, const float3 weight, const ccl_private OrenNayarClosure *closure, float3 *)
ccl_device void osl_closure_diffuse_toon_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t, const float3 weight, const ccl_private DiffuseToonClosure *closure, float3 *)
ccl_device void osl_closure_transparent_bsdf_setup(KernelGlobals, ccl_private ShaderData *sd, const PathRayVisibility, const uint32_t path_flag, const float3 weight, const ccl_private TransparentBSDFClosure *, float3 *)
ccl_device void osl_closure_glossy_toon_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t, const float3 weight, const ccl_private GlossyToonClosure *closure, float3 *)
ccl_device void osl_closure_microfacet_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t, const float3 weight, const ccl_private MicrofacetClosure *closure, float3 *layer_albedo)
ccl_device void osl_closure_diffuse_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t, const float3 weight, const ccl_private DiffuseClosure *closure, float3 *)
ccl_device void osl_closure_ashikhmin_velvet_setup(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t, const float3 weight, const ccl_private AshikhminVelvetClosure *closure, float3 *)
ccl_device void osl_closure_bssrdf_setup(KernelGlobals, ccl_private ShaderData *sd, const PathRayVisibility, const uint32_t path_flag, const float3 weight, const ccl_private BSSRDFClosure *closure, float3 *)
#define kernel_data
#define ccl_device_forceinline
#define kernel_data_fetch(name, index)
#define PRIMITIVE_UNPACK_SEGMENT(type)
#define zero_spectrum
#define ccl_private
#define ccl_align(...)
#define CCL_NAMESPACE_END
ccl_device void emission_setup(ccl_private ShaderData *sd, const Spectrum weight)
Definition emissive.h:29
CCL_NAMESPACE_BEGIN ccl_device void background_setup(ccl_private ShaderData *sd, const Spectrum weight)
Definition emissive.h:16
float ior_from_F0(const float F0)
bool is_zero(float3x3 a)
float average(float2 a)
CCL_NAMESPACE_BEGIN ccl_device void volume_extinction_setup(ccl_private ShaderData *sd, Spectrum weight)
ccl_device_inline float object_volume_density(KernelGlobals kg, const int object)
ccl_device_inline DeviceString make_string(const char *str, const size_t hash)
ClosureType
@ CLOSURE_BSSRDF_BURLEY_ID
@ CLOSURE_BSSRDF_RANDOM_WALK_ID
@ CLOSURE_BSSRDF_RANDOM_WALK_LEGACY_ID
@ CLOSURE_HOLDOUT_ID
@ CLOSURE_BSSRDF_RANDOM_WALK_SKIN_ID
uint32_t PathRayVisibility
@ SR_BSDF_HAS_TRANSMISSION
@ SR_BACKFACING
@ SR_IS_VOLUME_SHADER_EVAL
@ SR_HOLDOUT
@ PRIMITIVE_CURVE
@ PATH_RAY_EXTINCTION
@ PATH_RAY_VISIBILITY_CAMERA
@ PATH_RAY_VISIBILITY_SHADOW
@ PATH_RAY_VISIBILITY_DIFFUSE
@ LABEL_TRANSMIT
@ LABEL_DIFFUSE
@ LABEL_SINGULAR
@ LABEL_GLOSSY
@ LABEL_REFLECT
ccl_device_inline float3 spectrum_to_rgb(Spectrum s)
ccl_device_inline Spectrum rgb_to_spectrum(const float3 rgb)
ccl_device_inline float3 safe_normalize_fallback(const float3 a, const float3 fallback)
ccl_device_inline float3 one_float3()
Definition math_float3.h:26
CCL_NAMESPACE_BEGIN ccl_device_inline float3 zero_float3()
Definition math_float3.h:17
#define N
#define mix
#define ccl_device
closure color bssrdf(string method, normal N, vector radius, color albedo) BUILTIN
Spectrum reflectance
Spectrum transmittance
float3 Spectrum
ccl_device int volume_draine_setup(ccl_private DraineVolume *volume)
ccl_device int volume_fournier_forand_setup(ccl_private FournierForandVolume *volume, float B, float IOR)
ccl_device int volume_henyey_greenstein_setup(ccl_private HenyeyGreensteinVolume *volume)
ccl_device int volume_rayleigh_setup(ccl_private RayleighVolume *volume)