archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

Implemented the OSL part of the Disney shader

Browse Source
This commit is contained in:
Pascal Schön
2016-09-06 15:16:09 +02:00
parent 5f880293ae
commit 02c315aeb0
7 changed files with 317 additions and 19 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
intern/cycles/kernel/closure/bsdf_disney_sheen.h
View File

@@ -133,7 +133,7 @@ ccl_device int bsdf_disney_sheen_sample(const ShaderClosure *sc,
else {
*pdf = 0;
}
return LABEL_DIFFUSE;
return LABEL_REFLECT|LABEL_DIFFUSE;
}
CCL_NAMESPACE_END

33
intern/cycles/kernel/osl/osl_bssrdf.cpp
View File

@@ -80,6 +80,8 @@ public:
bssrdf->albedo = albedo.x;
bssrdf->sharpness = sharpness;
bssrdf->N = params.N;
bssrdf->baseColor = params.baseColor;
bssrdf->roughness = params.roughness;
ccl_fetch(sd, flag) |= bssrdf_setup(bssrdf, (ClosureType)type);
}
@@ -91,6 +93,8 @@ public:
bssrdf->albedo = albedo.y;
bssrdf->sharpness = sharpness;
bssrdf->N = params.N;
bssrdf->baseColor = params.baseColor;
bssrdf->roughness = params.roughness;
ccl_fetch(sd, flag) |= bssrdf_setup(bssrdf, (ClosureType)type);
}
@@ -102,6 +106,8 @@ public:
bssrdf->albedo = albedo.z;
bssrdf->sharpness = sharpness;
bssrdf->N = params.N;
bssrdf->baseColor = params.baseColor;
bssrdf->roughness = params.roughness;
ccl_fetch(sd, flag) |= bssrdf_setup(bssrdf, (ClosureType)type);
}
}
@@ -182,5 +188,32 @@ ClosureParam *closure_bssrdf_burley_params()
CCLOSURE_PREPARE(closure_bssrdf_burley_prepare, BurleyBSSRDFClosure)
/* Disney */
class DisneyBSSRDFClosure : public CBSSRDFClosure {
public:
void setup(ShaderData *sd, int path_flag, float3 weight)
{
alloc(sd, path_flag, weight, CLOSURE_BSSRDF_DISNEY_ID);
}
};
ClosureParam *closure_bssrdf_disney_params()
{
static ClosureParam params[] = {
CLOSURE_FLOAT3_PARAM(DisneyBSSRDFClosure, params.N),
CLOSURE_FLOAT3_PARAM(DisneyBSSRDFClosure, radius),
CLOSURE_FLOAT_PARAM(DisneyBSSRDFClosure, params.texture_blur),
CLOSURE_FLOAT3_PARAM(DisneyBSSRDFClosure, params.baseColor),
CLOSURE_FLOAT3_PARAM(DisneyBSSRDFClosure, albedo),
CLOSURE_FLOAT_PARAM(DisneyBSSRDFClosure, params.roughness),
CLOSURE_STRING_KEYPARAM(DisneyBSSRDFClosure, label, "label"),
CLOSURE_FINISH_PARAM(DisneyBSSRDFClosure)
};
return params;
}
CCLOSURE_PREPARE(closure_bssrdf_disney_prepare, DisneyBSSRDFClosure)
CCL_NAMESPACE_END

226
intern/cycles/kernel/osl/osl_closures.cpp
View File

@@ -187,6 +187,7 @@ BSDF_CLOSURE_CLASS_END(DisneyDiffuse, disney_diffuse)
BSDF_CLOSURE_CLASS_BEGIN(DisneySheen, disney_sheen, DisneySheenBsdf, LABEL_DIFFUSE)
CLOSURE_FLOAT3_PARAM(DisneySheenClosure, params.N),
CLOSURE_FLOAT3_PARAM(DisneySheenClosure, params.baseColor),
CLOSURE_FLOAT_PARAM(DisneySheenClosure, params.sheen),
CLOSURE_FLOAT_PARAM(DisneySheenClosure, params.sheenTint),
BSDF_CLOSURE_CLASS_END(DisneySheen, disney_sheen)
@@ -455,6 +456,18 @@ void OSLShader::register_closures(OSLShadingSystem *ss_)
closure_bsdf_microfacet_multi_ggx_glass_params(), closure_bsdf_microfacet_multi_ggx_glass_prepare);
register_closure(ss, "microfacet_multi_ggx_aniso", id++,
closure_bsdf_microfacet_multi_ggx_aniso_params(), closure_bsdf_microfacet_multi_ggx_aniso_prepare);
register_closure(ss, "microfacet_ggx_fresnel", id++,
closure_bsdf_microfacet_ggx_fresnel_params(), closure_bsdf_microfacet_ggx_fresnel_prepare);
register_closure(ss, "microfacet_ggx_aniso_fresnel", id++,
closure_bsdf_microfacet_ggx_aniso_fresnel_params(), closure_bsdf_microfacet_ggx_aniso_fresnel_prepare);
register_closure(ss, "microfacet_ggx_refraction_fresnel", id++,
closure_bsdf_microfacet_ggx_refraction_fresnel_params(), closure_bsdf_microfacet_ggx_refraction_fresnel_prepare);
register_closure(ss, "microfacet_multi_ggx_fresnel", id++,
closure_bsdf_microfacet_multi_ggx_fresnel_params(), closure_bsdf_microfacet_multi_ggx_fresnel_prepare);
register_closure(ss, "microfacet_multi_ggx_glass_fresnel", id++,
closure_bsdf_microfacet_multi_ggx_glass_fresnel_params(), closure_bsdf_microfacet_multi_ggx_glass_fresnel_prepare);
register_closure(ss, "microfacet_multi_ggx_aniso_fresnel", id++,
closure_bsdf_microfacet_multi_ggx_aniso_fresnel_params(), closure_bsdf_microfacet_multi_ggx_aniso_fresnel_prepare);
register_closure(ss, "microfacet_beckmann", id++,
bsdf_microfacet_beckmann_params(), bsdf_microfacet_beckmann_prepare);
register_closure(ss, "microfacet_beckmann_aniso", id++,
@@ -496,6 +509,8 @@ void OSLShader::register_closures(OSLShadingSystem *ss_)
closure_bssrdf_gaussian_params(), closure_bssrdf_gaussian_prepare);
register_closure(ss, "bssrdf_burley", id++,
closure_bssrdf_burley_params(), closure_bssrdf_burley_prepare);
register_closure(ss, "bssrdf_disney", id++,
closure_bssrdf_disney_params(), closure_bssrdf_disney_prepare);
register_closure(ss, "hair_reflection", id++,
bsdf_hair_reflection_params(), bsdf_hair_reflection_prepare);
@@ -526,6 +541,112 @@ bool CBSDFClosure::skip(const ShaderData *sd, int path_flag, int scattering)
return false;
}
/* GGX closures with Fresnel */
class MicrofacetFresnelClosure : public CBSDFClosure {
public:
MicrofacetBsdf params;
float3 color;
float3 cspec0;
MicrofacetBsdf *alloc(ShaderData *sd, int path_flag, float3 weight)
{
/* Technically, the MultiGGX Glass closure may also transmit. However,
* since this is set statically and only used for caustic flags, this
* is probably as good as it gets. */
if (!skip(sd, path_flag, LABEL_GLOSSY | LABEL_REFLECT)) {
MicrofacetBsdf *bsdf = (MicrofacetBsdf*)bsdf_alloc_osl(sd, sizeof(MicrofacetBsdf), weight, &params);
MicrofacetExtra *extra = (MicrofacetExtra*)closure_alloc_extra(sd, sizeof(MicrofacetExtra));
if (bsdf && extra) {
bsdf->extra = extra;
bsdf->extra->color = color;
bsdf->extra->cspec0 = cspec0;
return bsdf;
}
}
return NULL;
}
};
class MicrofacetGGXFresnelClosure : public MicrofacetFresnelClosure {
public:
void setup(ShaderData *sd, int path_flag, float3 weight)
{
MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight);
sd->flag |= (bsdf) ? bsdf_microfacet_ggx_setup(bsdf, true) : 0;
}
};
ClosureParam *closure_bsdf_microfacet_ggx_fresnel_params()
{
static ClosureParam params[] = {
CLOSURE_FLOAT3_PARAM(MicrofacetGGXFresnelClosure, params.N),
CLOSURE_FLOAT_PARAM(MicrofacetGGXFresnelClosure, params.alpha_x),
CLOSURE_FLOAT_PARAM(MicrofacetGGXFresnelClosure, params.ior),
CLOSURE_FLOAT3_PARAM(MicrofacetGGXFresnelClosure, color),
CLOSURE_FLOAT3_PARAM(MicrofacetGGXFresnelClosure, cspec0),
CLOSURE_STRING_KEYPARAM(MicrofacetGGXFresnelClosure, label, "label"),
CLOSURE_FINISH_PARAM(MicrofacetGGXFresnelClosure)
};
return params;
}
CCLOSURE_PREPARE(closure_bsdf_microfacet_ggx_fresnel_prepare, MicrofacetGGXFresnelClosure);
class MicrofacetGGXAnisoFresnelClosure : public MicrofacetFresnelClosure {
public:
void setup(ShaderData *sd, int path_flag, float3 weight)
{
MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight);
sd->flag |= (bsdf) ? bsdf_microfacet_ggx_aniso_setup(bsdf, true) : 0;
}
};
ClosureParam *closure_bsdf_microfacet_ggx_aniso_fresnel_params()
{
static ClosureParam params[] = {
CLOSURE_FLOAT3_PARAM(MicrofacetGGXFresnelClosure, params.N),
CLOSURE_FLOAT3_PARAM(MicrofacetGGXFresnelClosure, params.T),
CLOSURE_FLOAT_PARAM(MicrofacetGGXFresnelClosure, params.alpha_x),
CLOSURE_FLOAT_PARAM(MicrofacetGGXFresnelClosure, params.alpha_y),
CLOSURE_FLOAT_PARAM(MicrofacetGGXFresnelClosure, params.ior),
CLOSURE_FLOAT3_PARAM(MicrofacetGGXFresnelClosure, color),
CLOSURE_FLOAT3_PARAM(MicrofacetGGXFresnelClosure, cspec0),
CLOSURE_STRING_KEYPARAM(MicrofacetGGXFresnelClosure, label, "label"),
CLOSURE_FINISH_PARAM(MicrofacetGGXFresnelClosure)
};
return params;
}
CCLOSURE_PREPARE(closure_bsdf_microfacet_ggx_aniso_fresnel_prepare, MicrofacetGGXAnisoFresnelClosure);
class MicrofacetGGXRefractionFresnelClosure : public MicrofacetFresnelClosure {
public:
MicrofacetGGXRefractionFresnelClosure() : MicrofacetFresnelClosure() {}
void setup(ShaderData *sd, int path_flag, float3 weight)
{
MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight);
sd->flag |= (bsdf) ? bsdf_microfacet_ggx_refraction_setup(bsdf, true) : 0;
}
};
ClosureParam *closure_bsdf_microfacet_ggx_refraction_fresnel_params()
{
static ClosureParam params[] = {
CLOSURE_FLOAT3_PARAM(MicrofacetGGXFresnelClosure, params.N),
CLOSURE_FLOAT_PARAM(MicrofacetGGXFresnelClosure, params.alpha_x),
CLOSURE_FLOAT_PARAM(MicrofacetGGXFresnelClosure, params.ior),
CLOSURE_FLOAT3_PARAM(MicrofacetGGXFresnelClosure, color),
CLOSURE_FLOAT3_PARAM(MicrofacetGGXFresnelClosure, cspec0),
CLOSURE_STRING_KEYPARAM(MicrofacetGGXFresnelClosure, label, "label"),
CLOSURE_FINISH_PARAM(MicrofacetGGXFresnelClosure)
};
return params;
}
CCLOSURE_PREPARE(closure_bsdf_microfacet_ggx_refraction_fresnel_prepare, MicrofacetGGXRefractionFresnelClosure);
/* Multiscattering GGX closures */
class MicrofacetMultiClosure : public CBSDFClosure {
@@ -623,5 +744,110 @@ ClosureParam *closure_bsdf_microfacet_multi_ggx_glass_params()
}
CCLOSURE_PREPARE(closure_bsdf_microfacet_multi_ggx_glass_prepare, MicrofacetMultiGGXGlassClosure);
/* Multiscattering GGX closures with Fresnel */
class MicrofacetMultiFresnelClosure : public CBSDFClosure {
public:
MicrofacetBsdf params;
float3 color;
float3 cspec0;
MicrofacetBsdf *alloc(ShaderData *sd, int path_flag, float3 weight)
{
/* Technically, the MultiGGX Glass closure may also transmit. However,
* since this is set statically and only used for caustic flags, this
* is probably as good as it gets. */
if (!skip(sd, path_flag, LABEL_GLOSSY | LABEL_REFLECT)) {
MicrofacetBsdf *bsdf = (MicrofacetBsdf*)bsdf_alloc_osl(sd, sizeof(MicrofacetBsdf), weight, &params);
MicrofacetExtra *extra = (MicrofacetExtra*)closure_alloc_extra(sd, sizeof(MicrofacetExtra));
if (bsdf && extra) {
bsdf->extra = extra;
bsdf->extra->color = color;
bsdf->extra->cspec0 = cspec0;
return bsdf;
}
}
return NULL;
}
};
class MicrofacetMultiGGXFresnelClosure : public MicrofacetMultiFresnelClosure {
public:
void setup(ShaderData *sd, int path_flag, float3 weight)
{
MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight);
sd->flag |= (bsdf) ? bsdf_microfacet_multi_ggx_setup(bsdf, true) : 0;
}
};
ClosureParam *closure_bsdf_microfacet_multi_ggx_fresnel_params()
{
static ClosureParam params[] = {
CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXFresnelClosure, params.N),
CLOSURE_FLOAT_PARAM(MicrofacetMultiGGXFresnelClosure, params.alpha_x),
CLOSURE_FLOAT_PARAM(MicrofacetMultiGGXFresnelClosure, params.ior),
CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXFresnelClosure, color),
CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXFresnelClosure, cspec0),
CLOSURE_STRING_KEYPARAM(MicrofacetMultiGGXFresnelClosure, label, "label"),
CLOSURE_FINISH_PARAM(MicrofacetMultiGGXFresnelClosure)
};
return params;
}
CCLOSURE_PREPARE(closure_bsdf_microfacet_multi_ggx_fresnel_prepare, MicrofacetMultiGGXFresnelClosure);
class MicrofacetMultiGGXAnisoFresnelClosure : public MicrofacetMultiFresnelClosure {
public:
void setup(ShaderData *sd, int path_flag, float3 weight)
{
MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight);
sd->flag |= (bsdf) ? bsdf_microfacet_multi_ggx_aniso_setup(bsdf, true) : 0;
}
};
ClosureParam *closure_bsdf_microfacet_multi_ggx_aniso_fresnel_params()
{
static ClosureParam params[] = {
CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXFresnelClosure, params.N),
CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXFresnelClosure, params.T),
CLOSURE_FLOAT_PARAM(MicrofacetMultiGGXFresnelClosure, params.alpha_x),
CLOSURE_FLOAT_PARAM(MicrofacetMultiGGXFresnelClosure, params.alpha_y),
CLOSURE_FLOAT_PARAM(MicrofacetMultiGGXFresnelClosure, params.ior),
CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXFresnelClosure, color),
CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXFresnelClosure, cspec0),
CLOSURE_STRING_KEYPARAM(MicrofacetMultiGGXFresnelClosure, label, "label"),
CLOSURE_FINISH_PARAM(MicrofacetMultiGGXFresnelClosure)
};
return params;
}
CCLOSURE_PREPARE(closure_bsdf_microfacet_multi_ggx_aniso_fresnel_prepare, MicrofacetMultiGGXAnisoFresnelClosure);
class MicrofacetMultiGGXGlassFresnelClosure : public MicrofacetMultiFresnelClosure {
public:
MicrofacetMultiGGXGlassFresnelClosure() : MicrofacetMultiFresnelClosure() {}
void setup(ShaderData *sd, int path_flag, float3 weight)
{
MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight);
sd->flag |= (bsdf) ? bsdf_microfacet_multi_ggx_glass_setup(bsdf, false) : 0;
}
};
ClosureParam *closure_bsdf_microfacet_multi_ggx_glass_fresnel_params()
{
static ClosureParam params[] = {
CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXFresnelClosure, params.N),
CLOSURE_FLOAT_PARAM(MicrofacetMultiGGXFresnelClosure, params.alpha_x),
CLOSURE_FLOAT_PARAM(MicrofacetMultiGGXFresnelClosure, params.ior),
CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXFresnelClosure, color),
CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXFresnelClosure, cspec0),
CLOSURE_STRING_KEYPARAM(MicrofacetMultiGGXFresnelClosure, label, "label"),
CLOSURE_FINISH_PARAM(MicrofacetMultiGGXFresnelClosure)
};
return params;
}
CCLOSURE_PREPARE(closure_bsdf_microfacet_multi_ggx_glass_fresnel_prepare, MicrofacetMultiGGXGlassFresnelClosure);
CCL_NAMESPACE_END

14
intern/cycles/kernel/osl/osl_closures.h
View File

@@ -51,10 +51,17 @@ OSL::ClosureParam *closure_bsdf_phong_ramp_params();
OSL::ClosureParam *closure_bssrdf_cubic_params();
OSL::ClosureParam *closure_bssrdf_gaussian_params();
OSL::ClosureParam *closure_bssrdf_burley_params();
OSL::ClosureParam *closure_bssrdf_disney_params();
OSL::ClosureParam *closure_henyey_greenstein_volume_params();
OSL::ClosureParam *closure_bsdf_microfacet_multi_ggx_params();
OSL::ClosureParam *closure_bsdf_microfacet_multi_ggx_glass_params();
OSL::ClosureParam *closure_bsdf_microfacet_multi_ggx_aniso_params();
OSL::ClosureParam *closure_bsdf_microfacet_ggx_fresnel_params();
OSL::ClosureParam *closure_bsdf_microfacet_ggx_refraction_fresnel_params();
OSL::ClosureParam *closure_bsdf_microfacet_ggx_aniso_fresnel_params();
OSL::ClosureParam *closure_bsdf_microfacet_multi_ggx_fresnel_params();
OSL::ClosureParam *closure_bsdf_microfacet_multi_ggx_glass_fresnel_params();
OSL::ClosureParam *closure_bsdf_microfacet_multi_ggx_aniso_fresnel_params();
void closure_emission_prepare(OSL::RendererServices *, int id, void *data);
void closure_background_prepare(OSL::RendererServices *, int id, void *data);
@@ -65,10 +72,17 @@ void closure_bsdf_phong_ramp_prepare(OSL::RendererServices *, int id, void *data
void closure_bssrdf_cubic_prepare(OSL::RendererServices *, int id, void *data);
void closure_bssrdf_gaussian_prepare(OSL::RendererServices *, int id, void *data);
void closure_bssrdf_burley_prepare(OSL::RendererServices *, int id, void *data);
void closure_bssrdf_disney_prepare(OSL::RendererServices *, int id, void *data);
void closure_henyey_greenstein_volume_prepare(OSL::RendererServices *, int id, void *data);
void closure_bsdf_microfacet_multi_ggx_prepare(OSL::RendererServices *, int id, void *data);
void closure_bsdf_microfacet_multi_ggx_glass_prepare(OSL::RendererServices *, int id, void *data);
void closure_bsdf_microfacet_multi_ggx_aniso_prepare(OSL::RendererServices *, int id, void *data);
void closure_bsdf_microfacet_ggx_fresnel_prepare(OSL::RendererServices *, int id, void *data);
void closure_bsdf_microfacet_ggx_refraction_fresnel_prepare(OSL::RendererServices *, int id, void *data);
void closure_bsdf_microfacet_ggx_aniso_fresnel_prepare(OSL::RendererServices *, int id, void *data);
void closure_bsdf_microfacet_multi_ggx_fresnel_prepare(OSL::RendererServices *, int id, void *data);
void closure_bsdf_microfacet_multi_ggx_glass_fresnel_prepare(OSL::RendererServices *, int id, void *data);
void closure_bsdf_microfacet_multi_ggx_aniso_fresnel_prepare(OSL::RendererServices *, int id, void *data);
#define CCLOSURE_PREPARE(name, classname) \
void name(RendererServices *, int id, void *data) \

48
intern/cycles/kernel/shaders/node_disney_bsdf.osl
View File

@@ -41,28 +41,46 @@ shader node_disney_bsdf(
float f = max(IOR, 1e-5);
float eta = backfacing() ? 1.0 / f : f;
float cosNO = dot(Normal, I);
float Fr = fresnel_dielectric_cos(cosNO, eta);
//float Fr = fresnel_dielectric_cos(cosNO, eta);
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);
if (diffuse_weight > 0.0) {
BSDF = (((Subsurface * BaseColor * bssrdf_burley(Normal, vector(1.0, 1.0, 1.0), 0.0, BaseColor)) + disney_diffuse(Normal, BaseColor, Roughness) * (1.0 - Subsurface))
+ disney_sheen(Normal, BaseColor, Sheen, SheenTint)) * diffuse_weight;
if (diffuse_weight > 1e-5) {
BSDF = bssrdf_disney(Normal, vector(Subsurface, Subsurface, Subsurface), 0.0, BaseColor, SubsurfaceColor, Roughness);
if (Sheen != 0.0) {
BSDF = BSDF + disney_sheen(Normal, BaseColor, Sheen, SheenTint);
}
BSDF = BSDF * diffuse_weight;
}
if (Specular != 0.0 || Metallic != 0.0) {
BSDF = BSDF + specular_weight * disney_specular(Normal, Tangent, BaseColor, Metallic, Specular,
SpecularTint, Roughness, Anisotropic)
+ (1.0 - specular_weight) * (Fr * disney_specular(Normal, Tangent, BaseColor, 0.0, 12.5,
SpecularTint, Roughness, 0.0) + (1.0 - Fr) * BaseColor * microfacet_ggx_refraction(Normal, Roughness * Roughness, eta));
} else if (transp > 0.0) {
BSDF = BSDF + transp * (disney_specular(Normal, Tangent, BaseColor, 0.0, 12.5, SpecularTint, Roughness, 0.0)
+ BaseColor * microfacet_ggx_refraction(Normal, Roughness * Roughness, eta));
if (specular_weight > 1e-5) {
float aspect = sqrt(1.0 - Anisotropic * 0.9);
float r2 = Roughness * Roughness;
float alpha_x = max(0.001, r2 / aspect);
float alpha_y = max(0.001, r2 * aspect);
float m_cdlum = 0.3 * BaseColor[0] + 0.6 * BaseColor[1] + 0.1 * BaseColor[2]; // luminance approx.
color m_ctint = m_cdlum > 0.0 ? BaseColor / m_cdlum : color(0.0, 0.0, 0.0); // normalize lum. to isolate hue+sat
color tmp_col = color(1.0, 1.0, 1.0) * (1.0 - SpecularTint) + m_ctint * SpecularTint;
color Cspec0 = (Specular * 0.08 * tmp_col) * (1.0 - Metallic) + BaseColor * Metallic;
BSDF = BSDF + specular_weight * microfacet_multi_ggx_aniso_fresnel(Normal, Tangent, alpha_x, alpha_y, (2.0 / (1.0 - sqrt(0.08 * Specular))) - 1.0, BaseColor, Cspec0);
}
if (Clearcoat != 0.0) {
BSDF = BSDF + disney_clearcoat(ClearcoatNormal, Clearcoat, ClearcoatGloss);
if (transp > 1e-5) {
color Cspec0 = BaseColor * SpecularTint + color(1.0, 1.0, 1.0) * (1.0 - SpecularTint);
//BSDF = BaseColor * microfacet_multi_ggx_glass(Normal, Roughness, eta, BaseColor);
BSDF = BSDF + transp * microfacet_multi_ggx_glass_fresnel(Normal, Roughness * Roughness, eta, BaseColor, Cspec0);
}
if (Clearcoat > 1e-5) {
BSDF = BSDF + 0.25 * Clearcoat * microfacet_ggx_fresnel(Normal, 0.1 * (1.0 - ClearcoatGloss) + 0.001 * ClearcoatGloss, 1.5, color(1, 1, 1), color(0.04, 0.04, 0.04));
}
}

7
intern/cycles/kernel/shaders/stdosl.h
View File

@@ -530,6 +530,12 @@ closure color microfacet_ggx_refraction(normal N, float ag, float eta) BUILTIN;
closure color microfacet_multi_ggx(normal N, float ag, color C) BUILTIN;
closure color microfacet_multi_ggx_aniso(normal N, vector T, float ax, float ay, color C) BUILTIN;
closure color microfacet_multi_ggx_glass(normal N, float ag, float eta, color C) BUILTIN;
closure color microfacet_ggx_fresnel(normal N, float ag, float eta, color C, color Cspec0) BUILTIN;
closure color microfacet_ggx_aniso_fresnel(normal N, vector T, float ax, float ay, float eta, color C, color Cspec0) BUILTIN;
closure color microfacet_ggx_refraction_fresnel(normal N, float ag, float eta, color C, color Cspec0) BUILTIN;
closure color microfacet_multi_ggx_fresnel(normal N, float ag, float eta, color C, color Cspec0) BUILTIN;
closure color microfacet_multi_ggx_aniso_fresnel(normal N, vector T, float ax, float ay, float eta, color C, color Cspec0) BUILTIN;
closure color microfacet_multi_ggx_glass_fresnel(normal N, float ag, float eta, color C, color Cspec0) BUILTIN;
closure color microfacet_beckmann(normal N, float ab) BUILTIN;
closure color microfacet_beckmann_aniso(normal N, vector T, float ax, float ay) BUILTIN;
closure color microfacet_beckmann_refraction(normal N, float ab, float eta) BUILTIN;
@@ -549,6 +555,7 @@ closure color disney_clearcoat(normal N, float clearcoat, float clearcoatGloss)
closure color bssrdf_cubic(normal N, vector radius, float texture_blur, float sharpness) BUILTIN;
closure color bssrdf_gaussian(normal N, vector radius, float texture_blur) BUILTIN;
closure color bssrdf_burley(normal N, vector radius, float texture_blur, color albedo) BUILTIN;
closure color bssrdf_disney(normal N, vector radius, float texture_blur, color baseColor, color subsurfaceColor, float roughness) BUILTIN;
// Hair
closure color hair_reflection(normal N, float roughnessu, float roughnessv, vector T, float offset) BUILTIN;

6
source/blender/gpu/shaders/gpu_shader_material.glsl
View File

@@ -2553,12 +2553,12 @@ void node_bsdf_toon(vec4 color, float size, float tsmooth, vec3 N, out vec4 resu
node_bsdf_diffuse(color, 0.0, N, result);
}
/*void node_bsdf_disney(vec4 baseColor, float metallic, float subsurface, float specular, float roughness,
void node_bsdf_disney(vec4 baseColor, vec4 subsurfaceColor, float metallic, float subsurface, float specular, float roughness,
float specularTint, float anisotropic, float sheen, float sheenTint, float clearcoat,
float clearcoatGloss, vec3 N, vec3 T, vec3 anisotropicRotation, out vec4 result)
float clearcoatGloss, float ior, float transparency, float anisotropicRotationvec3 N, vec3 CN, vec3 T, out vec4 result)
{
node_bsdf_diffuse(baseColor, roughness, N, result);
}*/
}
void node_bsdf_translucent(vec4 color, vec3 N, out vec4 result)
{