28#if defined(__PATH_GUIDING__)
30ccl_device float surface_shader_average_sample_weight_squared_roughness(
33 float avg_squared_roughness = 0.0f;
34 float sum_sample_weight = 0.0f;
35 for (
int i = 0; i < sd->num_closure; i++) {
36 const ccl_private ShaderClosure *sc = &sd->closure[i];
42 sum_sample_weight += sc->sample_weight;
45 avg_squared_roughness = avg_squared_roughness > 0.0f ?
46 avg_squared_roughness / sum_sample_weight :
48 return avg_squared_roughness;
62 const float surface_guiding_probability =
kernel_data.integrator.surface_guiding_probability;
63 const int guiding_directional_sampling_type =
64 kernel_data.integrator.guiding_directional_sampling_type;
65 const float guiding_roughness_threshold =
kernel_data.integrator.guiding_roughness_threshold;
69 float diffuse_sampling_fraction = 0.0f;
70 float bssrdf_sampling_fraction = 0.0f;
71 float bsdf_bssrdf_sampling_sum = 0.0f;
73 bool fully_opaque =
true;
75 for (
int i = 0; i < sd->num_closure; i++) {
76 ShaderClosure *sc = &sd->closure[i];
78 const float sweight = sc->sample_weight;
81 bsdf_bssrdf_sampling_sum += sweight;
83 diffuse_sampling_fraction += sweight;
86 bssrdf_sampling_fraction += sweight;
95 if (bsdf_bssrdf_sampling_sum > 0.0f) {
96 diffuse_sampling_fraction /= bsdf_bssrdf_sampling_sum;
97 bssrdf_sampling_fraction /= bsdf_bssrdf_sampling_sum;
103 float avg_roughness = surface_shader_average_sample_weight_squared_roughness(sd);
105 if (!fully_opaque || avg_roughness < guiding_roughness_threshold ||
107 (diffuse_sampling_fraction <= 0.0f)) ||
116 if (
kernel_data.integrator.guiding_directional_sampling_type ==
121 diffuse_sampling_fraction;
123 else if (
kernel_data.integrator.guiding_directional_sampling_type ==
149 const int filter_closures =
kernel_data.integrator.filter_closures;
158 bool has_bsdf_closure =
false;
159 for (
int i = 0; i < sd->num_closure; i++) {
165 const bool filter_glass = filter_glossy && filter_transmission;
172 sc->sample_weight = 0.0f;
178 sc->sample_weight = 0.0f;
182 has_bsdf_closure =
true;
185 if (!has_bsdf_closure) {
201 const float blur_pdf =
kernel_data.integrator.filter_glossy *
204 if (blur_pdf < 1.0f) {
205 const float blur_roughness =
sqrtf(1.0f - blur_pdf) * 0.5f;
207 for (
int i = 0; i < sd->num_closure; i++) {
224#ifdef WITH_CYCLES_DEBUG
229 const float2 org_roughness,
247 const uint light_shader_flags)
269 if ((light_shader_flags & exclude_glass) == exclude_glass) {
283 float sum_sample_weight,
284 const uint light_shader_flags,
285 float sum_pdf_roughness_squared,
290 for (
int i = 0; i < sd->num_closure; i++) {
291 const ccl_private ShaderClosure *sc = &sd->closure[i];
299 float bsdf_pdf = 0.0f;
302 if (bsdf_pdf != 0.0f) {
307 const float weight = bsdf_pdf * sc->sample_weight;
315 sum_sample_weight += sc->sample_weight;
319 r_avg_roughness_squared = (sum_pdf > 0.0f) ? sum_pdf_roughness_squared / sum_pdf : 0.0f;
321 return (sum_sample_weight > 0.0f) ? sum_pdf / sum_sample_weight : 0.0f;
329 const uint light_shader_flags,
334 float sum_pdf = 0.0f;
335 float sum_sample_weight = 0.0f;
336 float sum_pdf_roughness_squared = 0.0f;
338 for (
int i = 0; i < sd->num_closure; i++) {
339 const ccl_private ShaderClosure *sc = &sd->closure[i];
343 float bsdf_pdf = 0.0f;
346 if (bsdf_pdf != 0.0f) {
351 const float weight = bsdf_pdf * sc->sample_weight;
367 sum_sample_weight += sc->sample_weight;
373 if (sum_pdf > 0.0f) {
374 for (
int i = 0; i < sd->num_closure; i++) {
379 r_avg_roughness_squared = (sum_pdf > 0.0f) ? sum_pdf_roughness_squared / sum_pdf : 0.0f;
381 return (sum_sample_weight > 0.0f) ? sum_pdf / sum_sample_weight : 0.0f;
384#ifndef __KERNEL_CUDA__
394 const uint light_shader_flags,
408 r_avg_roughness_squared);
416#if defined(__PATH_GUIDING__) && PATH_GUIDING_LEVEL >= 4
424 if (
kernel_data.integrator.guiding_directional_sampling_type ==
427 pdf = (0.5f * guide_pdf * (1.0f - bssrdf_sampling_prob)) + 0.5f * pdf;
430 pdf = (guiding_sampling_prob * guide_pdf * (1.0f - bssrdf_sampling_prob)) +
431 (1.0f - guiding_sampling_prob) * pdf;
446 if (sd->num_closure > 1) {
450 for (
int i = 0; i < sd->num_closure; i++) {
451 const ccl_private ShaderClosure *sc = &sd->closure[i];
454 sum += sc->sample_weight;
458 const float r = (*rand_bsdf).z * sum;
459 float partial_sum = 0.0f;
461 for (
int i = 0; i < sd->num_closure; i++) {
462 const ccl_private ShaderClosure *sc = &sd->closure[i];
465 const float next_sum = partial_sum + sc->sample_weight;
471 (*rand_bsdf).z = (r - partial_sum) / sc->sample_weight;
475 partial_sum = next_sum;
480 return &sd->closure[sampled];
488 Spectrum weight = bssrdf_sc->weight;
490 if (sd->num_closure > 1) {
492 for (
int i = 0; i < sd->num_closure; i++) {
493 const ccl_private ShaderClosure *sc = &sd->closure[i];
496 sum += sc->sample_weight;
499 weight *= sum / bssrdf_sc->sample_weight;
505#if defined(__PATH_GUIDING__)
509ccl_device int surface_shader_bsdf_guided_sample_closure_mis(
526 r_avg_roughness_squared = 0.0f;
534 bool sample_guiding =
false;
537 if (use_surface_guiding && rand_bsdf_guiding < guiding_sampling_prob) {
538 sample_guiding =
true;
539 rand_bsdf_guiding /= guiding_sampling_prob;
542 rand_bsdf_guiding -= guiding_sampling_prob;
543 rand_bsdf_guiding /= (1.0f - guiding_sampling_prob);
551 *unguided_bsdf_pdf = 0.0f;
552 float guide_pdf = 0.0f;
554 if (sample_guiding) {
559 if (guide_pdf != 0.0f) {
563 kg, sd, *wo,
bsdf_eval, unguided_bsdf_pdfs, 0, r_avg_roughness_squared);
564 *bsdf_pdf = (guiding_sampling_prob * guide_pdf * (1.0f - bssrdf_sampling_prob)) +
565 ((1.0f - guiding_sampling_prob) * (*unguided_bsdf_pdf));
566 float sum_pdfs = 0.0f;
568 if (*unguided_bsdf_pdf > 0.0f) {
570 for (
int i = 0; i < sd->num_closure; i++) {
571 sum_pdfs += unguided_bsdf_pdfs[i];
572 if (rand_bsdf_guiding <= sum_pdfs) {
582 idx = (rand_bsdf_guiding > sum_pdfs) ? sd->num_closure - 1 : idx;
584 label =
bsdf_label(kg, &sd->closure[idx], *wo);
588 *unguided_bsdf_pdf = 0.0f;
601 kg, sd, sc, rand_bsdf, &eval, wo, unguided_bsdf_pdf, sampled_roughness, eta);
602# ifdef WITH_CYCLES_DEBUG
606 if (*unguided_bsdf_pdf > 0.0f) {
607 surface_shader_validate_bsdf_sample(kg, sc, *wo, label, *sampled_roughness, *eta);
611 if (*unguided_bsdf_pdf != 0.0f) {
617 if (sd->num_closure > 1) {
618 const float sweight = sc->sample_weight;
619 const float weight = (*unguided_bsdf_pdf) * sweight;
628 weight * roughness_squared,
629 r_avg_roughness_squared);
633 r_avg_roughness_squared = roughness_squared;
635 *bsdf_pdf = *unguided_bsdf_pdf;
637 if (use_surface_guiding) {
639 *bsdf_pdf *= 1.0f - guiding_sampling_prob;
640 *bsdf_pdf += guiding_sampling_prob * guide_pdf * (1.0f - bssrdf_sampling_prob);
650ccl_device int surface_shader_bsdf_guided_sample_closure_ris(
669 r_avg_roughness_squared = 0.0f;
684 *unguided_bsdf_pdf = 0.0f;
685 float guide_pdf = 0.0f;
687 if (use_surface_guiding && guiding_sampling_prob > 0.0f) {
694 float ris_avg_roughness_squared[2] = {0.0f, 0.0f};
698 ris_samples[0].
rand = rand_bsdf;
708 &ris_samples[0].eval,
710 &ris_samples[0].bsdf_pdf,
711 &ris_samples[0].sampled_roughness,
712 &ris_samples[0].eta);
715 &ris_samples[0].
bsdf_eval, sc, ris_samples[0].wo, ris_samples[0].eval * sc->weight);
716 if (ris_samples[0].bsdf_pdf > 0.0f) {
718 if (sd->num_closure > 1) {
719 const float sweight = sc->sample_weight;
720 const float weight = ris_samples[0].
bsdf_pdf * sweight;
729 weight * roughness_squared,
730 ris_avg_roughness_squared[0]);
734 ris_avg_roughness_squared[0] = roughness_squared;
738 ris_samples[0].
guide_pdf *= (1.0f - bssrdf_sampling_prob);
740 kg, ris_samples[0].wo);
741 ris_samples[0].
bsdf_pdf =
max(0.0f, ris_samples[0].bsdf_pdf);
750 kg,
make_float2(ris_samples[1].rand), &ris_samples[1].wo);
751 ris_samples[1].
guide_pdf *= (1.0f - bssrdf_sampling_prob);
753 kg, ris_samples[1].wo);
760 ris_avg_roughness_squared[1]);
763 ris_samples[1].
bsdf_pdf =
max(0.0f, ris_samples[1].bsdf_pdf);
768 int num_ris_candidates = 0;
769 float sum_ris_weights = 0.0f;
772 num_ris_candidates++;
779 num_ris_candidates++;
787 if (num_ris_candidates == 0 || !(sum_ris_weights > 1e-10f)) {
793 const float rand_ris_select = rand_bsdf_guiding * sum_ris_weights;
795 float sum_ris = 0.0f;
796 for (
int i = 0; i < 2; i++) {
798 if (rand_ris_select <= sum_ris) {
810 guide_pdf = ris_samples[ris_idx].
ris_target * (2.0f / sum_ris_weights);
811 *unguided_bsdf_pdf = ris_samples[ris_idx].
bsdf_pdf;
812 *mis_pdf = 0.5f * (ris_samples[ris_idx].
bsdf_pdf + ris_samples[ris_idx].
guide_pdf);
813 *bsdf_pdf = guide_pdf;
815 *wo = ris_samples[ris_idx].
wo;
816 label = ris_samples[ris_idx].
label;
819 *eta = ris_samples[ris_idx].
eta;
821 r_avg_roughness_squared = ris_avg_roughness_squared[ris_idx];
826 if (!(*bsdf_pdf > 1e-10f)) {
837 if (ris_idx == 1 && ris_samples[1].bsdf_pdf > 0.0f) {
841 float sum_pdfs = 0.0f;
843 for (
int i = 0; i < sd->num_closure; i++) {
844 sum_pdfs += unguided_bsdf_pdfs[i];
845 if (rnd <= sum_pdfs) {
854 idx = (rnd > sum_pdfs) ? sd->num_closure - 1 : idx;
856 label =
bsdf_label(kg, &sd->closure[idx], *wo);
868 kg, sd, sc, rand_bsdf, &eval, wo, unguided_bsdf_pdf, sampled_roughness, eta);
869# ifdef WITH_CYCLES_DEBUG
873 if (*unguided_bsdf_pdf > 0.0f) {
874 surface_shader_validate_bsdf_sample(kg, sc, *wo, label, *sampled_roughness, *eta);
878 if (*unguided_bsdf_pdf != 0.0f) {
884 if (sd->num_closure > 1) {
885 const float sweight = sc->sample_weight;
886 const float weight = (*unguided_bsdf_pdf) * sweight;
895 weight * roughness_squared,
896 r_avg_roughness_squared);
900 r_avg_roughness_squared = roughness_squared;
902 *bsdf_pdf = *unguided_bsdf_pdf;
903 *mis_pdf = *bsdf_pdf;
912ccl_device int surface_shader_bsdf_guided_sample_closure(
929 r_avg_roughness_squared = 0.0f;
930 if (
kernel_data.integrator.guiding_directional_sampling_type ==
932 kernel_data.integrator.guiding_directional_sampling_type ==
935 label = surface_shader_bsdf_guided_sample_closure_mis(kg,
946 r_avg_roughness_squared);
947 *mis_pdf = (*unguided_bsdf_pdf > 0.0f) ? *bsdf_pdf : 0.0f;
949 else if (
kernel_data.integrator.guiding_directional_sampling_type ==
952 label = surface_shader_bsdf_guided_sample_closure_ris(kg,
965 r_avg_roughness_squared);
967 if (!(*unguided_bsdf_pdf > 0.0f)) {
996 label =
bsdf_sample(kg, sd, sc, rand_bsdf, &eval, wo, pdf, sampled_roughness, eta);
1001 const float sweight = sc->sample_weight;
1004 if (sd->num_closure > 1) {
1005 const float weight = *pdf * sweight;
1014 weight * roughness_squared,
1015 r_avg_roughness_squared);
1018 r_avg_roughness_squared = roughness_squared;
1023 r_avg_roughness_squared = 0.0f;
1031 float roughness = 0.0f;
1032 float sum_weight = 0.0f;
1034 for (
int i = 0; i < sd->num_closure; i++) {
1035 const ccl_private ShaderClosure *sc = &sd->closure[i];
1041 if (value >= 0.0f) {
1044 sum_weight += weight;
1049 return (sum_weight > 0.0f) ? roughness / sum_weight : 1.0f;
1058 return sd->closure_transparent_extinction;
1076 for (
int i = 0; i < sd->num_closure; i++) {
1077 const ccl_private ShaderClosure *sc = &sd->closure[i];
1091 for (
int i = 0; i < sd->num_closure; i++) {
1092 const ccl_private ShaderClosure *sc = &sd->closure[i];
1106 for (
int i = 0; i < sd->num_closure; i++) {
1107 const ccl_private ShaderClosure *sc = &sd->closure[i];
1121 for (
int i = 0; i < sd->num_closure; i++) {
1122 const ccl_private ShaderClosure *sc = &sd->closure[i];
1132 const float ao_factor,
1138 for (
int i = 0; i < sd->num_closure; i++) {
1139 const ccl_private ShaderClosure *sc = &sd->closure[i];
1143 eval += sc->weight * ao_factor;
1152#ifdef __SUBSURFACE__
1157 for (
int i = 0; i < sd->num_closure; i++) {
1158 const ccl_private ShaderClosure *sc = &sd->closure[i];
1199 return sd->closure_emission_background;
1224 weight =
one_spectrum() - sd->closure_transparent_extinction;
1226 for (
int i = 0; i < sd->num_closure; i++) {
1240 for (
int i = 0; i < sd->num_closure; i++) {
1241 const ccl_private ShaderClosure *sc = &sd->closure[i];
1243 weight += sc->weight;
1253template<u
int64_t node_feature_mask,
typename ConstIntegratorGenericState>
1255 ConstIntegratorGenericState
state,
1259 const uint32_t path_flag,
1260 bool use_caustics_storage =
false)
1278 sd->num_closure = 0;
1279 sd->num_closure_left = max_closures;
1291 kg,
state, sd, buffer, path_visibility, path_flag);
CCL_NAMESPACE_BEGIN ccl_device_inline float bsdf_get_specular_roughness_squared(const ccl_private ShaderClosure *sc)
ccl_device Spectrum bsdf_eval(KernelGlobals kg, ccl_private ShaderData *sd, const ccl_private ShaderClosure *sc, const float3 wo, ccl_private float *pdf)
ccl_device_inline void bsdf_roughness_eta(const ccl_private ShaderClosure *sc, const float3 wo, ccl_private float2 *roughness, ccl_private float *eta)
ccl_device_inline float bsdf_get_roughness_pass_squared(const ccl_private ShaderClosure *sc)
ccl_device_inline int bsdf_label(const KernelGlobals kg, const ccl_private ShaderClosure *sc, const float3 wo)
ccl_device_inline int bsdf_sample(KernelGlobals kg, ccl_private ShaderData *sd, const ccl_private ShaderClosure *sc, const float3 rand, ccl_private Spectrum *eval, ccl_private float3 *wo, ccl_private float *pdf, ccl_private float2 *sampled_roughness, ccl_private float *eta)
ccl_device_inline Spectrum closure_albedo(KernelGlobals kg, const ccl_private ShaderData *sd, const ccl_private ShaderClosure *sc, const bool reflection, const bool transmission)
ccl_device void bsdf_blur(ccl_private ShaderClosure *sc, const float roughness)
ccl_device void bsdf_diffuse_setup(ccl_private ShaderData *sd, const float3 N, const Spectrum weight)
ccl_device_forceinline bool alpha_is_almost_specular(const float alpha_x, const float alpha_y)
#define kernel_assert(cond)
#define CLOSURE_IS_GLASS(type)
#define ccl_attr_maybe_unused
#define ccl_device_forceinline
#define KERNEL_FEATURE_PATH_GUIDING
#define kernel_data_fetch(name, index)
#define CLOSURE_IS_HOLDOUT(type)
#define CLOSURE_IS_BSDF_TRANSPARENT(type)
#define CLOSURE_IS_BSDF_TRANSMISSION(type)
#define CLOSURE_IS_BSDF(type)
#define KERNEL_FEATURE_OSL_SHADING
#define CLOSURE_IS_BSDF_GLOSSY(type)
#define ccl_device_inline
#define CLOSURE_IS_BSDF_DIFFUSE(type)
#define CLOSURE_IS_BSDF_OR_BSSRDF(type)
#define CLOSURE_IS_BSSRDF(type)
#define CAUSTICS_MAX_CLOSURE
#define CCL_NAMESPACE_END
ccl_device Spectrum emissive_simple_eval(const float3 Ng, const float3 wi)
VecBase< float, D > normalize(VecOp< float, D >) RET
float reduce_min(float2 a)
ccl_device_forceinline float guiding_surface_incoming_radiance_pdf(ccl_attr_maybe_unused KernelGlobals kg, ccl_attr_maybe_unused const float3 wo)
ccl_device_forceinline bool guiding_bsdf_init(ccl_attr_maybe_unused KernelGlobals kg, ccl_attr_maybe_unused const float3 P, ccl_attr_maybe_unused const float3 N, ccl_attr_maybe_unused ccl_private float &rand)
ccl_device_forceinline float guiding_bsdf_sample(ccl_attr_maybe_unused KernelGlobals kg, ccl_attr_maybe_unused const float2 rand_bsdf, ccl_attr_maybe_unused ccl_private float3 *wo)
ccl_device_forceinline bool calculate_ris_target(ccl_attr_maybe_unused ccl_private GuidingRISSample *ris_sample, ccl_attr_maybe_unused const ccl_private float guiding_sampling_prob)
ccl_device_forceinline float guiding_bsdf_pdf(ccl_attr_maybe_unused KernelGlobals kg, ccl_attr_maybe_unused const float3 wo)
void osl_eval_nodes(const ThreadKernelGlobalsCPU *kg, ConstIntegratorGenericState state, ShaderData *sd, PathRayVisibility path_visibility, uint32_t path_flag)
ccl_device void svm_eval_nodes(KernelGlobals kg, ConstIntegratorGenericState state, ccl_private ShaderData *sd, ccl_global float *render_buffer, const PathRayVisibility path_visibility, const uint32_t path_flag)
@ CLOSURE_BSDF_TRANSLUCENT_ID
uint32_t PathRayVisibility
@ FILTER_CLOSURE_EMISSION
@ FILTER_CLOSURE_TRANSPARENT
@ FILTER_CLOSURE_DIRECT_LIGHT
@ FILTER_CLOSURE_TRANSMISSION
@ SD_HAS_CONSTANT_EMISSION
@ PRNG_SURFACE_BSDF_GUIDING
@ PRNG_SURFACE_RIS_GUIDING_0
@ PRNG_SURFACE_RIS_GUIDING_1
@ PATH_RAY_VISIBILITY_CAMERA
@ PATH_RAY_VISIBILITY_SHADOW
@ SHADER_EXCLUDE_TRANSMIT
@ GUIDING_DIRECTIONAL_SAMPLING_TYPE_PRODUCT_MIS
@ GUIDING_DIRECTIONAL_SAMPLING_TYPE_RIS
@ GUIDING_DIRECTIONAL_SAMPLING_TYPE_ROUGHNESS
ccl_device_inline Spectrum rgb_to_spectrum(const float3 rgb)
CCL_NAMESPACE_BEGIN ccl_device_inline void bsdf_eval_init(ccl_private BsdfEval *eval, const ccl_private ShaderClosure *sc, const float3 wo, Spectrum value)
ccl_device_inline void bsdf_eval_accum(ccl_private BsdfEval *eval, const ccl_private ShaderClosure *sc, const float3 wo, Spectrum value)
ccl_device_inline Spectrum bsdf_eval_sum(const ccl_private BsdfEval *eval)
ccl_device_inline float safe_sqrtf(const float f)
ccl_device_inline bool isfinite_safe(const float f)
CCL_NAMESPACE_BEGIN ccl_device_inline float3 zero_float3()
ResultT eval(const Uniform &uni, const ViewMatrices view, ScreenThicknessParameters thickness_params, sampler2D hiz_tx, sampler2D screen_radiance_tx, sampler2D screen_normal_tx, float3 vP, float3 vN, float4 noise, float2 pixel_size, float search_distance, float angle_bias, const int slice_count, const int sample_count, const bool reversed, const bool ao_only)
ccl_device_inline float path_state_rng_1D(KernelGlobals kg, const ccl_private RNGState *rng_state, const int dimension)
ccl_device_inline float3 path_state_rng_3D(KernelGlobals kg, const ccl_private RNGState *rng_state, const int dimension)
#define INTEGRATOR_STATE_WRITE(state, nested_struct, member)
#define INTEGRATOR_STATE(state, nested_struct, member)
IntegratorStateCPU * IntegratorState
const IntegratorStateCPU * ConstIntegratorState
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_DENOISING KERNEL_STRUCT_VOLUME_STACK_SIZE surface_guiding_sampling_prob
ccl_device_inline uint integrator_state_lcg_init(ConstIntegratorShadowState state, const uint hash)
closure color bssrdf(string method, normal N, vector radius, color albedo) BUILTIN
float incoming_radiance_pdf
const ccl_device_inline ccl_private ShaderClosure * surface_shader_bsdf_bssrdf_pick(const ccl_private ShaderData *ccl_restrict sd, ccl_private float3 *rand_bsdf)
ccl_device int surface_shader_bsdf_sample_closure(KernelGlobals kg, ccl_private ShaderData *sd, const ccl_private ShaderClosure *sc, const float3 rand_bsdf, ccl_private BsdfEval *bsdf_eval, ccl_private float3 *wo, ccl_private float *pdf, ccl_private float2 *sampled_roughness, ccl_private float *eta, ccl_private float &r_avg_roughness_squared)
ccl_device float surface_shader_average_roughness(const ccl_private ShaderData *sd)
ccl_device Spectrum surface_shader_transmission(KernelGlobals kg, const ccl_private ShaderData *sd)
ccl_device void surface_shader_eval(KernelGlobals kg, ConstIntegratorGenericState state, ccl_private ShaderData *ccl_restrict sd, ccl_global float *ccl_restrict buffer, const PathRayVisibility path_visibility, const uint32_t path_flag, bool use_caustics_storage=false)
ccl_device_inline float surface_shader_bsdf_eval_pdfs(const KernelGlobals kg, ccl_private ShaderData *sd, const float3 wo, ccl_private BsdfEval *result_eval, ccl_private float *pdfs, const uint light_shader_flags, ccl_private float &r_avg_roughness_squared)
ccl_device_forceinline bool _surface_shader_exclude(ClosureType type, const uint light_shader_flags)
ccl_device float3 surface_shader_average_normal(const ccl_private ShaderData *sd)
ccl_device_inline float _surface_shader_bsdf_eval_mis(KernelGlobals kg, ccl_private ShaderData *sd, const float3 wo, const ccl_private ShaderClosure *skip_sc, ccl_private BsdfEval *result_eval, float sum_pdf, float sum_sample_weight, const uint light_shader_flags, float sum_pdf_roughness_squared, ccl_private float &r_avg_roughness_squared)
ccl_device Spectrum surface_shader_ao(const ccl_private ShaderData *sd, const float ao_factor, ccl_private float3 *N_)
ccl_device Spectrum surface_shader_transparency(const ccl_private ShaderData *sd)
ccl_device Spectrum surface_shader_background(const ccl_private ShaderData *sd)
ccl_device Spectrum surface_shader_glossy(KernelGlobals kg, const ccl_private ShaderData *sd)
ccl_device float surface_shader_bsdf_eval(KernelGlobals kg, ccl_attr_maybe_unused IntegratorState state, ccl_private ShaderData *sd, const float3 wo, ccl_private BsdfEval *bsdf_eval, const uint light_shader_flags, ccl_private float &r_avg_roughness_squared)
ccl_device Spectrum surface_shader_alpha(const ccl_private ShaderData *sd)
ccl_device Spectrum surface_shader_apply_holdout(ccl_private ShaderData *sd)
ccl_device Spectrum surface_shader_diffuse(KernelGlobals kg, const ccl_private ShaderData *sd)
ccl_device_inline Spectrum surface_shader_bssrdf_sample_weight(const ccl_private ShaderData *ccl_restrict sd, const ccl_private ShaderClosure *ccl_restrict bssrdf_sc)
ccl_device Spectrum surface_shader_emission(const ccl_private ShaderData *sd)
ccl_device bool surface_shader_constant_emission(KernelGlobals kg, const int shader, ccl_private Spectrum *eval)
CCL_NAMESPACE_BEGIN ccl_device_inline void surface_shader_prepare_closures(KernelGlobals kg, ConstIntegratorState state, ccl_private ShaderData *sd, const PathRayVisibility path_visibility)