Fix T51408: Cycles - Principled BSDF Shader - Transparency is not working as expected
authorPascal Schoen <pascal.schoen@adidas-group.com>
Thu, 18 May 2017 11:15:32 +0000 (13:15 +0200)
committerPascal Schoen <pascal.schoen@adidas-group.com>
Thu, 18 May 2017 11:18:19 +0000 (13:18 +0200)
Renamed the "Transparency" input of the Principled BSDF to
"Transmission" and "Refraction Roughness" to "Transmission Roughness".

intern/cycles/kernel/shaders/node_principled_bsdf.osl
intern/cycles/kernel/svm/svm_closure.h
intern/cycles/render/nodes.cpp
intern/cycles/render/nodes.h
source/blender/gpu/shaders/gpu_shader_material.glsl
source/blender/nodes/shader/nodes/node_shader_bsdf_principled.c

index 39c6c7e5fd9391fb7d84844e00e96370030e2a12..57f40789d49ddd401e08a354d2c54d1e73fb2ca1 100644 (file)
@@ -34,17 +34,17 @@ shader node_principled_bsdf(
        float Clearcoat = 0.0,
        float ClearcoatGloss = 1.0,
        float IOR = 1.45,
-       float Transparency = 0.0,
-       float RefractionRoughness = 0.0,
+       float Transmission = 0.0,
+       float TransmissionRoughness = 0.0,
        normal Normal = N,
        normal ClearcoatNormal = N,
        normal Tangent = normalize(dPdu),
        output closure color BSDF = 0)
 {
        float f = max(IOR, 1e-5);
-       float diffuse_weight = (1.0 - clamp(Metallic, 0.0, 1.0)) * (1.0 - clamp(Transparency, 0.0, 1.0));
-       float transp = clamp(Transparency, 0.0, 1.0) * (1.0 - clamp(Metallic, 0.0, 1.0));
-       float specular_weight = (1.0 - transp);
+       float diffuse_weight = (1.0 - clamp(Metallic, 0.0, 1.0)) * (1.0 - clamp(Transmission, 0.0, 1.0));
+       float final_transmission = clamp(Transmission, 0.0, 1.0) * (1.0 - clamp(Metallic, 0.0, 1.0));
+       float specular_weight = (1.0 - final_transmission);
 
        vector T = Tangent;
 
@@ -90,7 +90,7 @@ shader node_principled_bsdf(
                }
        }
 
-       if (transp > 1e-5) {
+       if (final_transmission > 1e-5) {
                color Cspec0 = BaseColor * SpecularTint + color(1.0, 1.0, 1.0) * (1.0 - SpecularTint);
                float eta = backfacing() ? 1.0 / f : f;
 
@@ -98,18 +98,18 @@ shader node_principled_bsdf(
                        float cosNO = dot(Normal, I);
                        float Fr = fresnel_dielectric_cos(cosNO, eta);
 
-               float refl_roughness = Roughness;
-               if (Roughness <= 1e-2)
-                       refl_roughness = 0.0;
+                       float refl_roughness = Roughness;
+                       if (Roughness <= 1e-2)
+                               refl_roughness = 0.0;
 
-                       float refraction_roughness = refl_roughness;
+                       float transmission_roughness = refl_roughness;
                        if (distribution == "GGX")
-                               refraction_roughness = 1.0 - (1.0 - refl_roughness) * (1.0 - RefractionRoughness);
+                               transmission_roughness = 1.0 - (1.0 - refl_roughness) * (1.0 - TransmissionRoughness);
 
-                       BSDF = BSDF + transp * (Fr * microfacet_ggx_fresnel(Normal, refl_roughness * refl_roughness, eta, BaseColor, Cspec0) +
-                              (1.0 - Fr) * BaseColor * microfacet_ggx_refraction(Normal, refraction_roughness * refraction_roughness, eta));
+                       BSDF = BSDF + final_transmission * (Fr * microfacet_ggx_fresnel(Normal, refl_roughness * refl_roughness, eta, BaseColor, Cspec0) +
+                              (1.0 - Fr) * BaseColor * microfacet_ggx_refraction(Normal, transmission_roughness * transmission_roughness, eta));
                } else {
-                       BSDF = BSDF + transp * microfacet_multi_ggx_glass_fresnel(Normal, Roughness * Roughness, eta, BaseColor, Cspec0);
+                       BSDF = BSDF + final_transmission * microfacet_multi_ggx_glass_fresnel(Normal, Roughness * Roughness, eta, BaseColor, Cspec0);
                }
        }
 
index 7918c640175e73773c63999d022769a43cc3eec5..0e1aedf2918f9d584761eb1153e8a12ce045b624 100644 (file)
@@ -79,14 +79,14 @@ ccl_device void svm_node_closure_bsdf(KernelGlobals *kg, ShaderData *sd, float *
 #ifdef __PRINCIPLED__
                case CLOSURE_BSDF_PRINCIPLED_ID: {
                        uint specular_offset, roughness_offset, specular_tint_offset, anisotropic_offset, sheen_offset,
-                               sheen_tint_offset, clearcoat_offset, clearcoat_gloss_offset, eta_offset, transparency_offset,
-                               anisotropic_rotation_offset, refraction_roughness_offset;
+                               sheen_tint_offset, clearcoat_offset, clearcoat_gloss_offset, eta_offset, transmission_offset,
+                               anisotropic_rotation_offset, transmission_roughness_offset;
                        uint4 data_node2 = read_node(kg, offset);
 
                        float3 T = stack_load_float3(stack, data_node.y);
                        decode_node_uchar4(data_node.z, &specular_offset, &roughness_offset, &specular_tint_offset, &anisotropic_offset);
                        decode_node_uchar4(data_node.w, &sheen_offset, &sheen_tint_offset, &clearcoat_offset, &clearcoat_gloss_offset);
-                       decode_node_uchar4(data_node2.x, &eta_offset, &transparency_offset, &anisotropic_rotation_offset, &refraction_roughness_offset);
+                       decode_node_uchar4(data_node2.x, &eta_offset, &transmission_offset, &anisotropic_rotation_offset, &transmission_roughness_offset);
 
                        // get Disney principled parameters
                        float metallic = param1;
@@ -99,9 +99,9 @@ ccl_device void svm_node_closure_bsdf(KernelGlobals *kg, ShaderData *sd, float *
                        float sheen_tint = stack_load_float(stack, sheen_tint_offset);
                        float clearcoat = stack_load_float(stack, clearcoat_offset);
                        float clearcoat_gloss = stack_load_float(stack, clearcoat_gloss_offset);
-                       float transparency = stack_load_float(stack, transparency_offset);
+                       float transmission = stack_load_float(stack, transmission_offset);
                        float anisotropic_rotation = stack_load_float(stack, anisotropic_rotation_offset);
-                       float refraction_roughness = stack_load_float(stack, refraction_roughness_offset);
+                       float transmission_roughness = stack_load_float(stack, transmission_roughness_offset);
                        float eta = fmaxf(stack_load_float(stack, eta_offset), 1e-5f);
 
                        ClosureType distribution = stack_valid(data_node2.y) ? (ClosureType) data_node2.y : CLOSURE_BSDF_MICROFACET_MULTI_GGX_GLASS_ID;
@@ -118,10 +118,10 @@ ccl_device void svm_node_closure_bsdf(KernelGlobals *kg, ShaderData *sd, float *
                        float fresnel = fresnel_dielectric_cos(cosNO, ior);
 
                        // calculate weights of the diffuse and specular part
-                       float diffuse_weight = (1.0f - saturate(metallic)) * (1.0f - saturate(transparency));
+                       float diffuse_weight = (1.0f - saturate(metallic)) * (1.0f - saturate(transmission));
                        
-                       float transp = saturate(transparency) * (1.0f - saturate(metallic));
-                       float specular_weight = (1.0f - transp);
+                       float final_transmission = saturate(transmission) * (1.0f - saturate(metallic));
+                       float specular_weight = (1.0f - final_transmission);
 
                        // get the base color
                        uint4 data_base_color = read_node(kg, offset);
@@ -300,8 +300,8 @@ ccl_device void svm_node_closure_bsdf(KernelGlobals *kg, ShaderData *sd, float *
 #ifdef __CAUSTICS_TRICKS__
                        if(kernel_data.integrator.caustics_reflective || kernel_data.integrator.caustics_refractive || (path_flag & PATH_RAY_DIFFUSE) == 0) {
 #endif
-                               if(transp > CLOSURE_WEIGHT_CUTOFF) {
-                                       float3 glass_weight = weight * transp;
+                               if(final_transmission > CLOSURE_WEIGHT_CUTOFF) {
+                                       float3 glass_weight = weight * final_transmission;
                                        float3 cspec0 = base_color * specular_tint + make_float3(1.0f, 1.0f, 1.0f) * (1.0f - specular_tint);
 
                                        if(roughness <= 5e-2f || distribution == CLOSURE_BSDF_MICROFACET_GGX_GLASS_ID) { /* use single-scatter GGX */
@@ -342,12 +342,12 @@ ccl_device void svm_node_closure_bsdf(KernelGlobals *kg, ShaderData *sd, float *
                                                                bsdf->N = N;
 
                                                                if(distribution == CLOSURE_BSDF_MICROFACET_GGX_GLASS_ID)
-                                                                       refraction_roughness = 1.0f - (1.0f - refl_roughness) * (1.0f - refraction_roughness);
+                                                                       transmission_roughness = 1.0f - (1.0f - refl_roughness) * (1.0f - transmission_roughness);
                                                                else
-                                                                       refraction_roughness = refl_roughness;
+                                                                       transmission_roughness = refl_roughness;
 
-                                                               bsdf->alpha_x = refraction_roughness * refraction_roughness;
-                                                               bsdf->alpha_y = refraction_roughness * refraction_roughness;
+                                                               bsdf->alpha_x = transmission_roughness * transmission_roughness;
+                                                               bsdf->alpha_y = transmission_roughness * transmission_roughness;
                                                                bsdf->ior = ior;
 
                                                                /* setup bsdf */
index 9b565c3ede11cb376d20c36ca4d1afd03aa36ced..57b475e5cd00f9b9f149d919d57f99662d3af038 100644 (file)
@@ -2316,8 +2316,8 @@ NODE_DEFINE(PrincipledBsdfNode)
        SOCKET_IN_FLOAT(clearcoat, "Clearcoat", 0.0f);
        SOCKET_IN_FLOAT(clearcoat_gloss, "Clearcoat Gloss", 0.0f);
        SOCKET_IN_FLOAT(ior, "IOR", 0.0f);
-       SOCKET_IN_FLOAT(transparency, "Transparency", 0.0f);
-       SOCKET_IN_FLOAT(refraction_roughness, "Refraction Roughness", 0.0f);
+       SOCKET_IN_FLOAT(transmission, "Transmission", 0.0f);
+       SOCKET_IN_FLOAT(transmission_roughness, "Transmission Roughness", 0.0f);
        SOCKET_IN_FLOAT(anisotropic_rotation, "Anisotropic Rotation", 0.0f);
        SOCKET_IN_NORMAL(normal, "Normal", make_float3(0.0f, 0.0f, 0.0f), SocketType::LINK_NORMAL);
        SOCKET_IN_NORMAL(clearcoat_normal, "Clearcoat Normal", make_float3(0.0f, 0.0f, 0.0f), SocketType::LINK_NORMAL);
@@ -2352,7 +2352,7 @@ void PrincipledBsdfNode::attributes(Shader *shader, AttributeRequestSet *attribu
 void PrincipledBsdfNode::compile(SVMCompiler& compiler, ShaderInput *p_metallic, ShaderInput *p_subsurface, ShaderInput *p_subsurface_radius,
        ShaderInput *p_specular, ShaderInput *p_roughness, ShaderInput *p_specular_tint, ShaderInput *p_anisotropic,
        ShaderInput *p_sheen, ShaderInput *p_sheen_tint, ShaderInput *p_clearcoat, ShaderInput *p_clearcoat_gloss,
-       ShaderInput *p_ior, ShaderInput *p_transparency, ShaderInput *p_anisotropic_rotation, ShaderInput *p_refraction_roughness)
+       ShaderInput *p_ior, ShaderInput *p_transmission, ShaderInput *p_anisotropic_rotation, ShaderInput *p_transmission_roughness)
 {
        ShaderInput *base_color_in = input("Base Color");
        ShaderInput *subsurface_color_in = input("Subsurface Color");
@@ -2376,8 +2376,8 @@ void PrincipledBsdfNode::compile(SVMCompiler& compiler, ShaderInput *p_metallic,
        int clearcoat_offset = compiler.stack_assign(p_clearcoat);
        int clearcoat_gloss_offset = compiler.stack_assign(p_clearcoat_gloss);
        int ior_offset = compiler.stack_assign(p_ior);
-       int transparency_offset = compiler.stack_assign(p_transparency);
-       int refraction_roughness_offset = compiler.stack_assign(p_refraction_roughness);
+       int transmission_offset = compiler.stack_assign(p_transmission);
+       int transmission_roughness_offset = compiler.stack_assign(p_transmission_roughness);
        int anisotropic_rotation_offset = compiler.stack_assign(p_anisotropic_rotation);
        int subsurface_radius_offset = compiler.stack_assign(p_subsurface_radius);
 
@@ -2393,7 +2393,7 @@ void PrincipledBsdfNode::compile(SVMCompiler& compiler, ShaderInput *p_metallic,
                compiler.encode_uchar4(specular_offset, roughness_offset, specular_tint_offset, anisotropic_offset),
                compiler.encode_uchar4(sheen_offset, sheen_tint_offset, clearcoat_offset, clearcoat_gloss_offset));
 
-       compiler.add_node(compiler.encode_uchar4(ior_offset, transparency_offset, anisotropic_rotation_offset, refraction_roughness_offset),
+       compiler.add_node(compiler.encode_uchar4(ior_offset, transmission_offset, anisotropic_rotation_offset, transmission_roughness_offset),
                distribution, SVM_STACK_INVALID, SVM_STACK_INVALID);
 
        float3 bc_default = get_float3(base_color_in->socket_type);
@@ -2419,8 +2419,8 @@ void PrincipledBsdfNode::compile(SVMCompiler& compiler)
 {
        compile(compiler, input("Metallic"), input("Subsurface"), input("Subsurface Radius"), input("Specular"),
                input("Roughness"), input("Specular Tint"), input("Anisotropic"), input("Sheen"), input("Sheen Tint"),
-               input("Clearcoat"), input("Clearcoat Gloss"), input("IOR"), input("Transparency"),
-               input("Anisotropic Rotation"), input("Refraction Roughness"));
+               input("Clearcoat"), input("Clearcoat Gloss"), input("IOR"), input("Transmission"),
+               input("Anisotropic Rotation"), input("Transmission Roughness"));
 }
 
 void PrincipledBsdfNode::compile(OSLCompiler& compiler)
index a56313bd5d41a6f1581167177bcce63713e88e6c..aac6ce2f375c242eaed779be2fea0fc10a8d94fc 100644 (file)
@@ -378,13 +378,13 @@ public:
        void compile(SVMCompiler& compiler, ShaderInput *metallic, ShaderInput *subsurface, ShaderInput *subsurface_radius,
                ShaderInput *specular, ShaderInput *roughness, ShaderInput *specular_tint, ShaderInput *anisotropic,
                ShaderInput *sheen, ShaderInput *sheen_tint, ShaderInput *clearcoat, ShaderInput *clearcoat_gloss,
-               ShaderInput *ior, ShaderInput *transparency, ShaderInput *anisotropic_rotation, ShaderInput *refraction_roughness);
+               ShaderInput *ior, ShaderInput *transmission, ShaderInput *anisotropic_rotation, ShaderInput *transmission_roughness);
 
        float3 base_color;
        float3 subsurface_color, subsurface_radius;
        float metallic, subsurface, specular, roughness, specular_tint, anisotropic,
-               sheen, sheen_tint, clearcoat, clearcoat_gloss, ior, transparency,
-               anisotropic_rotation, refraction_roughness;
+               sheen, sheen_tint, clearcoat, clearcoat_gloss, ior, transmission,
+               anisotropic_rotation, transmission_roughness;
        float3 normal, clearcoat_normal, tangent;
        float surface_mix_weight;
        ClosureType distribution, distribution_orig;
index 42561d7baaf114bb6a6d71073c556331dd08d377..5c52b7fd1530bf1b185e8468c1acdc9ffe1bb0e1 100644 (file)
@@ -2621,7 +2621,7 @@ void node_bsdf_toon(vec4 color, float size, float tsmooth, vec3 N, out vec4 resu
 
 void node_bsdf_principled(vec4 base_color, float subsurface, vec3 subsurface_radius, vec4 subsurface_color, float metallic, float specular,
        float specular_tint, float roughness, float anisotropic, float anisotropic_rotation, float sheen, float sheen_tint, float clearcoat,
-       float clearcoat_gloss, float ior, float transparency, float refraction_roughness, vec3 N, vec3 CN, vec3 T, vec3 I, out vec4 result)
+       float clearcoat_gloss, float ior, float transmission, float transmission_roughness, vec3 N, vec3 CN, vec3 T, vec3 I, out vec4 result)
 {
        /* ambient light */
        // TODO: set ambient light to an appropriate value
index 8b0bfa36324d797f5520fa0822ebc581c40cdb9f..44288db182ac4ca770eb036f70764ae905d7f2bd 100644 (file)
@@ -45,8 +45,8 @@ static bNodeSocketTemplate sh_node_bsdf_principled_in[] = {
        {       SOCK_FLOAT, 1, N_("Clearcoat"),                         0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
        {       SOCK_FLOAT, 1, N_("Clearcoat Gloss"),           1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
        {       SOCK_FLOAT, 1, N_("IOR"),                                       1.45f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
-       {       SOCK_FLOAT, 1, N_("Transparency"),                      0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
-       {       SOCK_FLOAT, 1, N_("Refraction Roughness"),      0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+       {       SOCK_FLOAT, 1, N_("Transmission"),                      0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+       {       SOCK_FLOAT, 1, N_("Transmission Roughness"),0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
        {       SOCK_VECTOR, 1, N_("Normal"),                           0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
        {       SOCK_VECTOR, 1, N_("Clearcoat Normal"),         0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
        {       SOCK_VECTOR, 1, N_("Tangent"),                          0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
@@ -86,7 +86,7 @@ static void node_shader_update_principled(bNodeTree *UNUSED(ntree), bNode *node)
        int distribution = node->custom1;
 
        for (sock = node->inputs.first; sock; sock = sock->next) {
-               if (STREQ(sock->name, "Refraction Roughness")) {
+               if (STREQ(sock->name, "Transmission Roughness")) {
                        if (distribution == SHD_GLOSSY_GGX)
                                sock->flag &= ~SOCK_UNAVAIL;
                        else