Blender V5.3
gpu_shader_material_principled.bsl.hh
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2019-2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#pragma once
6
10
12 ShadingData &sd,
13 float3 weight,
14 const Specular specular,
15 const Transmission transmission,
16 const float3 N,
17 const float NV,
18 const bool thin_walled,
19 const bool multiggx,
20 ClosureReflection &reflection_data)
21{
22 if (transmission.weight == 0.0f) {
23 return weight;
24 }
25
26 const float3 F0 = F0_from_ior(specular.ior) * specular.tint;
27 const float3 F90 = float3(1.0f);
28 const float3 tint = thin_walled ? float3(1.0f) : sqrt(transmission.tint);
29 float3 R, T;
30 bsdf_lut(kg, F0, F90, tint, NV, specular.roughness, specular.ior, multiggx, R, T);
31
32 if (thin_walled) {
33 /* Adjust transmission tint based on relative path length. */
34 const float3 C = slab_transmittance_at_angle(transmission.tint, NV, specular.ior);
35
36 /* Account for internal reflections, t' = ctt + ct(rc)^2t + ct(rc)^4t + ... */
37 T = safe_divide(C * square(T), (1.0f - square(R * C)));
38 /* r' = r + ctrct + ct(rc)^3t + ... */
39 R *= (1.0f + T * C);
40 }
41
43 kg, sd, weight, transmission.weight, R, T, N, specular, thin_walled, reflection_data);
44
45 return weight;
46}
47
49 ShadingData &sd,
50 const float3 weight,
51 const Specular specular,
52 const float3 N,
53 const float NV,
54 const bool multiggx,
55 ClosureReflection &reflection_data)
56{
57 const float ior = openpbr_modulate_ior(specular.weight, specular.ior);
58 const float3 F0 = saturate(float3(F0_from_ior(ior)) * specular.tint);
59 const float3 F90 = float3(1.0f);
60
61 float3 reflectance, unused;
62 bsdf_lut(kg, F0, F90, float3(0.0f), NV, specular.roughness, ior, multiggx, reflectance, unused);
63
64 reflection_data.N = N;
65 reflection_data.roughness = specular.roughness;
66 reflection_data.color += weight * reflectance;
67 closure_eval(kg, sd, reflection_data);
68
69 /* Attenuate lower layers */
70 return weight * max((1.0f - math_reduce_max(reflectance)), 0.0f);
71}
72
73[[node]]
75 float metallic,
76 const float roughness,
77 const float ior,
78 float alpha,
79 const bool thin_wall,
80 float3 N,
81 const float float_weight,
82 const float /*diffuse_roughness*/,
83 const float subsurface_weight,
84 const float3 subsurface_radius,
85 const float subsurface_scale,
86 const float /*subsurface_ior*/,
87 const float subsurface_anisotropy,
88 const float specular_ior_level,
89 const float4 specular_tint,
90 const float /*anisotropic*/,
91 const float /*anisotropic_rotation*/,
92 const float3 /*T*/,
93 const float transmission_weight,
94 const float /*transmission_dispersion_scale*/,
95 const float /*transmission_dispersion_abbe_number*/,
96 const float coat_weight,
97 const float coat_roughness,
98 const float coat_ior,
99 const float4 coat_tint,
100 const float3 CN,
101 const float sheen_weight,
102 const float sheen_roughness,
103 const float4 sheen_tint,
104 const float4 emission,
105 const float emission_strength,
106 const float /*thin_film_thickness*/,
107 const float /*thin_film_ior*/,
108 const float do_multiscatter,
109 const float subsurface_random_walk_radius_scale,
111 ShadingData &sd,
112 Closure &result)
113{
114 /* Match Cycles. */
115 metallic = saturate(metallic);
116 alpha = saturate(alpha);
117 base_color = max(base_color, float4(0.0f));
118 const float3 clamped_base_color = min(base_color.rgb, float3(1.0f));
119
120 Subsurface subsurface;
121 subsurface.tint = clamped_base_color;
122 subsurface.anisotropy = clamp(subsurface_anisotropy, -1.0f, 1.0f);
123 subsurface.radius = subsurface_radius * subsurface_scale * subsurface_random_walk_radius_scale;
124 subsurface.radius = max(subsurface.radius, float3(0.0f));
125 subsurface.weight = saturate(subsurface_weight);
126 /* Not used by EEVEE */
127 /* subsurface_ior = clamp(subsurface_ior, 1.01f, 3.8f); */
128
129 Specular specular;
130 specular.tint = max(specular_tint.rgb, float3(0.0f));
131 specular.roughness = saturate(roughness);
132 specular.ior = max(ior, 1e-5f);
133 specular.weight = max(specular_ior_level * 2.0f, 0.0f);
134 /* Not used by EEVEE */
135 /* anisotropic = saturate(anisotropic); */
136
137 Transmission transmission;
138 transmission.tint = clamped_base_color;
139 transmission.weight = saturate(transmission_weight);
140 /* Not used by EEVEE */
141 /* transmission_dispersion_scale = saturate(transmission_dispersion_scale); */
142 /* transmission_dispersion_abbe_number = max(transmission_dispersion_abbe_number, 0.0f); */
143
144 Coat coat;
145 coat.tint = max(coat_tint.rgb, float3(0.0f));
146 coat.roughness = saturate(coat_roughness);
147 coat.N = normalize_fallback(CN, sd.N);
148 coat.ior = max(coat_ior, 1.0f);
149 coat.weight = saturate(coat_weight);
150
151 Fuzz fuzz;
152 fuzz.tint = max(sheen_tint.rgb, float3(0.0f));
153 fuzz.roughness = saturate(sheen_roughness);
154 fuzz.weight = max(sheen_weight, 0.0f);
155
156 /* Geometry. */
157 N = normalize_fallback(N, sd.N);
158 const float3 V = coordinate_impl(kg, sd, sd.P, sd.N).incoming;
159 const float NV = dot(N, V);
160 const bool multiggx = thin_wall || (do_multiscatter != 0.0f);
161
162 float3 weight = float3(float_weight);
163 ClosureDiffuse diffuse_data;
164 ClosureReflection reflection_data;
165
166 weight = openpbr_eval_transparency(kg, sd, weight, alpha);
167 weight = openpbr_eval_fuzz(kg, sd, weight, coat, fuzz, N, V, diffuse_data);
168 weight = openpbr_eval_coat(kg, sd, weight, coat, V);
169 weight = openpbr_eval_emission(kg, sd, weight, emission.rgb, emission_strength);
170 weight = openpbr_eval_metal(
171 kg, weight, clamped_base_color, specular, metallic, NV, multiggx, reflection_data);
173 kg, sd, weight, specular, transmission, N, NV, thin_wall, multiggx, reflection_data);
174 weight = principled_eval_gloss(kg, sd, weight, specular, N, NV, multiggx, reflection_data);
175 weight = openpbr_eval_subsurface(kg, sd, weight, subsurface, thin_wall, N, diffuse_data);
176 openpbr_eval_diffuse(kg, sd, weight, base_color.rgb, N, diffuse_data);
177
178 /* TODO(fclem): EEVEE implementation leaking. */
179 result = CLOSURE_DEFAULT;
180}
#define C
Definition RandGen.cpp:29
btScalar max
void bsdf_lut(KernelGlobals &kg, float3 F0, float3 F90, float3 transmission_tint, float cos_theta, float roughness, float ior, bool do_multiscatter, float3 &reflectance, float3 &transmittance)
float F0_from_ior(float eta)
Coordinates coordinate_impl(KernelGlobals &kg, const ShadingData &sd, float3 P, float3 N)
Closure closure_eval(KernelGlobals &kg, ShadingData &sd, ClosureDiffuse diffuse)
float math_reduce_max(float3 a)
#define resource_table
float dot(VecOp< float, D >, VecOp< float, D >) RET
#define sqrt
constexpr T clamp(T, U, U) RET
float3 openpbr_eval_metal(KernelGlobals &kg, const float3 weight, const float3 F0, const Specular specular, const float metalness, const float NV, const bool multiggx, ClosureReflection &reflection_data)
float3 openpbr_eval_coat(KernelGlobals &kg, ShadingData &sd, float3 weight, Coat coat, const float3 V)
float3 slab_transmittance_at_angle(const float3 color, const float cos_theta_i, const float ior)
float3 openpbr_eval_transparency(KernelGlobals &kg, ShadingData &sd, const float3 weight, const float opacity)
float3 openpbr_eval_fuzz(KernelGlobals &, ShadingData &, const float3 weight, const Coat coat, const Fuzz fuzz, const float3 N, const float3 V, ClosureDiffuse &diffuse_data)
float3 openpbr_eval_subsurface(KernelGlobals &kg, ShadingData &sd, const float3 weight, const Subsurface subsurface, const bool thin_walled, const float3 N, ClosureDiffuse &diffuse_data)
float3 openpbr_eval_emission(KernelGlobals &kg, ShadingData &sd, const float3 weight, const float3 color, const float luminance)
float openpbr_modulate_ior(const float specular_weight, const float specular_ior)
void openpbr_eval_diffuse(KernelGlobals &kg, ShadingData &sd, const float3 weight, const float3 color, const float3 N, ClosureDiffuse &diffuse_data)
float3 openpbr_eval_translucent(KernelGlobals &kg, ShadingData &sd, const float3 weight, const float transmission, const float3 reflectance, const float3 transmittance, const float3 N, const Specular specular, const bool thin_walled, ClosureReflection &reflection_data)
void node_bsdf_principled(float4 base_color, float metallic, const float roughness, const float ior, float alpha, const bool thin_wall, float3 N, const float float_weight, const float, const float subsurface_weight, const float3 subsurface_radius, const float subsurface_scale, const float, const float subsurface_anisotropy, const float specular_ior_level, const float4 specular_tint, const float, const float, const float3, const float transmission_weight, const float, const float, const float coat_weight, const float coat_roughness, const float coat_ior, const float4 coat_tint, const float3 CN, const float sheen_weight, const float sheen_roughness, const float4 sheen_tint, const float4 emission, const float emission_strength, const float, const float, const float do_multiscatter, const float subsurface_random_walk_radius_scale, KernelGlobals &kg, ShadingData &sd, Closure &result)
float3 principled_eval_translucent(KernelGlobals &kg, ShadingData &sd, float3 weight, const Specular specular, const Transmission transmission, const float3 N, const float NV, const bool thin_walled, const bool multiggx, ClosureReflection &reflection_data)
float3 principled_eval_gloss(KernelGlobals &kg, ShadingData &sd, const float3 weight, const Specular specular, const float3 N, const float NV, const bool multiggx, ClosureReflection &reflection_data)
float square(float v)
float safe_divide(float a, float b)
VecT normalize_fallback(VecT vector, VecT fallback)
#define N
#define T
#define R
#define saturate(a)
Definition smaa.cc:319
#define min(a, b)
Definition sort.cc:38
CCL_NAMESPACE_BEGIN struct Window V