PBR Material Layering - Shader API

import lib-pbr.glsl

import lib-emissive.glsl

import lib-sampler.glsl

import lib-utils.glsl



## define NB_MATERIALS 4

## define NB_MASKS     (NB_MATERIALS - 1)



//: metadata {

//:   "custom-ui": "material-layering/custom-ui.qml"

//: }



//: materials [

//:   {

//:      "id": "Material1",

//:      "label": "Material 1",

//:      "default": "",

//:      "size": 1024,

//:      "default_color": [0.5, 0.5, 0.5]

//:   },

//:   {

//:      "id": "Material2",

//:      "label": "Material 2",

//:      "default": "",

//:      "size": 1024,

//:      "default_color": [0.5, 0.5, 0.5]

//:   },

//:   {

//:      "id": "Material3",

//:      "label": "Material 3",

//:      "default": "",

//:      "size": 1024,

//:      "default_color": [0.5, 0.5, 0.5]

//:   },

//:   {

//:      "id": "Material4",

//:      "label": "Material 4",

//:      "default": "",

//:      "size": 1024,

//:      "default_color": [0.5, 0.5, 0.5]

//:   }

//: ]





//: stacks [

//:   {

//:     "id": "Mask",

//:     "channels":

//:  [

//:   {"id": "blendingmask"}

//:  ]

//:   },

//:   {

//:     "id": "Mask2",

//:     "channels":

//:  [

//:   {"id": "blendingmask"}

//:  ]

//:   },

//:   {

//:     "id": "Mask3",

//:     "channels":

//:  [

//:   {"id": "blendingmask"}

//:  ]

//:   }

//: ]







//: param custom { "default": false, "label": "Debug Mode" }

uniform bool DebugMode;



//: param custom {

//:   "default": 0,

//:   "label": "Debug channel",

//:   "widget": "combobox",

//:   "values": {

//:     "BaseColor": 0,

//:     "Roughness": 1,

//:     "Metallic": 2,

//:     "Normal (Material)": 3,

//:     "Normal (Masks)": 4,

//:     "Normal (Combined)": 5,

//:     "Mask 1": 6,

//:     "Mask 2": 7,

//:     "Mask 3": 8

//:   }

//: }

uniform int DebugChannel;





//: param custom { "default": false, "label": "Normal from Masks" }

uniform bool UseNormalFromMask;

//: param auto texture_normal;

uniform sampler2D mesh_normal_texture;



//: param custom { "default": 5, "label": "Material 1 coords", "min": 0.01, "max": 128.0, "group" : "Material 1" }

uniform float u_coords1;



//: param custom { "default": 5, "label": "Material 2 coords", "min": 0.01, "max": 128.0, "group" : "Material 2" }

uniform float u_coords2;



//: param custom { "default": 5, "label": "Material 3 coords", "min": 0.01, "max": 128.0, "group" : "Material 3" }

uniform float u_coords3;



//: param custom { "default": 5, "label": "Material 4 coords", "min": 0.01, "max": 128.0, "group" : "Material 4" }

uniform float u_coords4;





//: param custom { "default": 1, "label": "Normal Intensity 1", "min": 0.0, "max": 1.0, "group" : "Material 1" }

uniform float normal_intensity1;



//: param custom { "default": 1, "label": "Normal Intensity 2", "min": 0.0, "max": 1.0, "group" : "Material 2" }

uniform float normal_intensity2;



//: param custom { "default": 1, "label": "Normal Intensity 3", "min": 0.0, "max": 1.0, "group" : "Material 3" }

uniform float normal_intensity3;



//: param custom { "default": 1, "label": "Normal Intensity 4", "min": 0.0, "max": 1.0, "group" : "Material 4" }

uniform float normal_intensity4;





//: param custom { "default": 0, "label": "Normal from Mask Intensity 2", "min": -10.0, "max": 10.0, "group" : "Material 2" }

uniform float mask_normal_intensity1;



//: param custom { "default": 0, "label": "Normal from Mask Intensity 3", "min": -10.0, "max": 10.0, "group" : "Material 3" }

uniform float mask_normal_intensity2;



//: param custom { "default": 0, "label": "Normal from Mask Intensity 4", "min": -10.0, "max": 10.0, "group" : "Material 4" }

uniform float mask_normal_intensity3;





//: param custom { "default": 0.1, "label": "Normal from Mask 1 Offset", "min": 0.0, "max": 1, "group" : "Material 2" }

uniform float mask_normal_offset1;



//: param custom { "default": 0.1, "label": "Normal from Mask 2 Offset", "min": 0.0, "max": 1, "group" : "Material 3" }

uniform float mask_normal_offset2;



//: param custom { "default": 0.1, "label": "Normal from Mask 3 Offset", "min": 0.0, "max": 1, "group" : "Material 4" }

uniform float mask_normal_offset3;





//: param auto Material1.channel_basecolor

uniform sampler2D color1;



//: param auto Material1.channel_roughness

uniform sampler2D rough1;



//: param auto Material1.channel_metallic

uniform sampler2D metal1;



//: param auto Material1.channel_normal

uniform sampler2D normal1;





//: param auto Material2.channel_basecolor

uniform sampler2D color2;



//: param auto Material2.channel_roughness

uniform sampler2D rough2;



//: param auto Material2.channel_metallic

uniform sampler2D metal2;



//: param auto Material2.channel_normal

uniform sampler2D normal2;





//: param auto Material3.channel_basecolor

uniform sampler2D color3;



//: param auto Material3.channel_roughness

uniform sampler2D rough3;



//: param auto Material3.channel_metallic

uniform sampler2D metal3;



//: param auto Material3.channel_normal

uniform sampler2D normal3;





//: param auto Material4.channel_basecolor

uniform sampler2D color4;



//: param auto Material4.channel_roughness

uniform sampler2D rough4;



//: param auto Material4.channel_metallic

uniform sampler2D metal4;



//: param auto Material4.channel_normal

uniform sampler2D normal4;





//: param auto Mask.channel_blendingmask

uniform SamplerSparse mask;



//: param auto Mask2.channel_blendingmask

uniform SamplerSparse mask2;



//: param auto Mask3.channel_blendingmask

uniform SamplerSparse mask3;



/////////////////////////////////////////

////////// BLENDING FUNCTIONS ///////////

/////////////////////////////////////////



float mixGrayscale(

 float channelSampled[NB_MATERIALS],

 float Masks[NB_MASKS])

{

 float result = channelSampled[0];

 for (int i = 0; i < NB_MASKS; i++)

  result = mix(result, channelSampled[i + 1], Masks[i]);



 return result;

}



vec3 mixColor(

 vec3 channelSampled[NB_MATERIALS],

 float Masks[NB_MASKS])

{

 vec3 result = channelSampled[0];

 for (int i = 0; i < NB_MASKS; i++)

  result = mix(result, channelSampled[i + 1], Masks[i]);



 return result;

}



vec3 mixNormal(

 vec3 channelSampled[NB_MATERIALS],

 float Masks[NB_MASKS],

 float NormalIntensity[NB_MATERIALS])

{

 vec3 result = NormalIntensity[0] * channelSampled[0];

 for (int i = 0; i < NB_MASKS; i++)

  result = mix(result, NormalIntensity[i + 1] * channelSampled[i + 1], Masks[i]);



 return result;

}



vec3 NormalFromMask(SamplerSparse Mask, float Offset, float Intensity, SparseCoord UVs, float refMask)

{

 vec4 results[2];

 vec2 offsets[2] = vec2[2](

  vec2(Offset * 0.001, 0.0),

  vec2(0.0, Offset * 0.001)

 );

 textureSparseOffsets(Mask, UVs, offsets, results);



 float Channel1 = results[0].r - refMask;

 float Channel2 = results[1].r - refMask;



 return vec3(-Intensity * Channel1, -Intensity * Channel2, 1.0);

}



vec3 NormalFromMasks(

 vec3 normalFromMaskSampled[NB_MASKS],

 float Masks[NB_MASKS])

{

 vec3 result = normalFromMaskSampled[0];

 for (int i = 1; i < NB_MASKS; i++)

  result = mix(result, normalFromMaskSampled[i], Masks[i]);



 return result;

}





void shade(V2F inputs)

{

 //Global textures

 // Get detail (ambient occlusion) and global (shadow) occlusion factors

 float occlusion = getAO(inputs.sparse_coord) * getShadowFactor();

 vec3 mesh_normal = normalUnpack(textureSparse(base_normal_texture, inputs.sparse_coord), base_normal_y_coeff);

 //Materials Masks

 float UVscale[NB_MATERIALS] = float[NB_MATERIALS](

  u_coords1, u_coords2, u_coords3, u_coords4);



 float NormalIntensity[NB_MATERIALS] = float[NB_MATERIALS](

  normal_intensity1, normal_intensity2, normal_intensity3, normal_intensity4);



 float MaskNormalOffset[NB_MASKS] = float[NB_MASKS](

  mask_normal_offset1, mask_normal_offset2, mask_normal_offset3);



 float MaskNormalIntensity[NB_MASKS] = float[NB_MASKS](

  mask_normal_intensity1, mask_normal_intensity2, mask_normal_intensity3);



 float Masks[NB_MASKS] = float[NB_MASKS](

  textureSparse(mask , inputs.sparse_coord).r,

  textureSparse(mask2, inputs.sparse_coord).r,

  textureSparse(mask3, inputs.sparse_coord).r);



 float roughSampled[NB_MATERIALS] = float[NB_MATERIALS](

  getRoughness(rough1, inputs.tex_coord*UVscale[0]),

  getRoughness(rough2, inputs.tex_coord*UVscale[1]),

  getRoughness(rough3, inputs.tex_coord*UVscale[2]),

  getRoughness(rough4, inputs.tex_coord*UVscale[3])

 );



 float metallicSampled[NB_MATERIALS] = float[NB_MATERIALS](

  getMetallic(metal1, inputs.tex_coord*UVscale[0]),

  getMetallic(metal2, inputs.tex_coord*UVscale[1]),

  getMetallic(metal3, inputs.tex_coord*UVscale[2]),

  getMetallic(metal4, inputs.tex_coord*UVscale[3])

 );



 vec3 basecolorSampled[NB_MATERIALS] = vec3[NB_MATERIALS](

  getBaseColor(color1, inputs.tex_coord*UVscale[0]),

  getBaseColor(color2, inputs.tex_coord*UVscale[1]),

  getBaseColor(color3, inputs.tex_coord*UVscale[2]),

  getBaseColor(color4, inputs.tex_coord*UVscale[3])

 );



 vec3 normalSampled[NB_MATERIALS] = vec3[NB_MATERIALS](

  normalUnpack(texture(normal1, inputs.tex_coord*UVscale[0])),

  normalUnpack(texture(normal2, inputs.tex_coord*UVscale[1])),

  normalUnpack(texture(normal3, inputs.tex_coord*UVscale[2])),

  normalUnpack(texture(normal4, inputs.tex_coord*UVscale[3]))

 );

 //Mixing

 float roughness = mixGrayscale(roughSampled, Masks);

 float metallic = mixGrayscale(metallicSampled, Masks);

 vec3 basecolor = mixColor(basecolorSampled, Masks);

 vec3 diffColor = generateDiffuseColor(basecolor, metallic);

 vec3 specColor = generateSpecularColor(basecolor, metallic);

 float specOcclusion = specularOcclusionCorrection(occlusion, metallic, roughness);



 //Normal channel

 vec3 normal = mixNormal(normalSampled, Masks, NormalIntensity);

 normal = normalize( vec3(normal.xy + mesh_normal.xy, mesh_normal.z) ); //UDN combine method



 vec3 finalNormal = normal;

 vec3 normalMask = vec3(0.0, 0.0, 1.0);



 if( UseNormalFromMask )

 {

  vec3 normalFromMaskSampled[NB_MASKS] = vec3[NB_MASKS](

   NormalFromMask(mask , MaskNormalOffset[0], MaskNormalIntensity[0], inputs.sparse_coord, Masks[0]),

   NormalFromMask(mask2, MaskNormalOffset[1], MaskNormalIntensity[1], inputs.sparse_coord, Masks[1]),

   NormalFromMask(mask3, MaskNormalOffset[2], MaskNormalIntensity[2], inputs.sparse_coord, Masks[2])

  );



  normalMask = NormalFromMasks(normalFromMaskSampled, Masks);

  finalNormal = normalize( vec3(finalNormal.xy + normalMask.xy, finalNormal.z) ); //UDN combine method

 }

 //Final

 //Debug mode display result of combined channels or Masks

 if( !DebugMode ) {

  vec3 finalNormalWorldSpace = normalize(

   finalNormal.x * inputs.tangent +

   finalNormal.y * inputs.bitangent +

   finalNormal.z * inputs.normal);

  // Feed parameters for a physically based BRDF integration.

  LocalVectors vectors = computeLocalFrame(inputs, finalNormalWorldSpace, 0.0);

  emissiveColorOutput(pbrComputeEmissive(emissive_tex, inputs.sparse_coord));

  diffuseShadingOutput(occlusion * pbrComputeDiffuse(vectors.normal, diffColor));

  specularShadingOutput(specOcclusion * pbrComputeSpecular(vectors, specColor, roughness));

 } else {

  vec3 result;



  //BaseColor combined

  if( DebugChannel == 0 ) {

   result = basecolor;

  }



  //Roughness combined

  else if( DebugChannel == 1 ) {

   result = vec3(roughness);

  }



  //Metallic combined

  else if( DebugChannel == 2 ) {

   result = vec3(metallic);

  }



  //Normal combined

  else if( DebugChannel == 3) {

   normal = 0.5 * normal + vec3(0.5);

   result = sRGB2linear(normal);

  }



  //Combined masks as Normal

  else if( DebugChannel == 4 ) {

   normalMask = 0.5 * normalMask + vec3(0.5);

   result = sRGB2linear(normalMask);

  }



  //Final Normal

  else if( DebugChannel == 5 ) {

   finalNormal = 0.5 * finalNormal + vec3(0.5);

   result = sRGB2linear(finalNormal);

  }



  //Mask(s)

  else {

   result = vec3(sRGB2linear(Masks[DebugChannel - 6]));

  }



  diffuseShadingOutput(result);

 }

}