import defaultValue from '../Core/defaultValue.js';
|
import defined from '../Core/defined.js';
|
import WebGLConstants from '../Core/WebGLConstants.js';
|
import webGLConstantToGlslType from '../Core/webGLConstantToGlslType.js';
|
import addToArray from '../ThirdParty/GltfPipeline/addToArray.js';
|
import ForEach from '../ThirdParty/GltfPipeline/ForEach.js';
|
import hasExtension from '../ThirdParty/GltfPipeline/hasExtension.js';
|
import numberOfComponentsForType from '../ThirdParty/GltfPipeline/numberOfComponentsForType.js';
|
import ModelUtility from './ModelUtility.js';
|
|
/**
|
* @private
|
*/
|
function processPbrMaterials(gltf, options) {
|
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
|
|
// No need to create new techniques if they already exist,
|
// the shader should handle these values
|
if (hasExtension(gltf, 'KHR_techniques_webgl')) {
|
return gltf;
|
}
|
|
// All materials in glTF are PBR by default,
|
// so we should apply PBR unless no materials are found.
|
if (!defined(gltf.materials) || gltf.materials.length === 0) {
|
return gltf;
|
}
|
|
if (!defined(gltf.extensions)) {
|
gltf.extensions = {};
|
}
|
|
if (!defined(gltf.extensionsUsed)) {
|
gltf.extensionsUsed = [];
|
}
|
|
if (!defined(gltf.extensionsRequired)) {
|
gltf.extensionsRequired = [];
|
}
|
|
gltf.extensions.KHR_techniques_webgl = {
|
programs: [],
|
shaders: [],
|
techniques: []
|
};
|
|
gltf.extensionsUsed.push('KHR_techniques_webgl');
|
gltf.extensionsRequired.push('KHR_techniques_webgl');
|
|
var primitiveByMaterial = ModelUtility.splitIncompatibleMaterials(gltf);
|
|
ForEach.material(gltf, function(material, materialIndex) {
|
var generatedMaterialValues = {};
|
var technique = generateTechnique(gltf, material, materialIndex, generatedMaterialValues, primitiveByMaterial, options);
|
|
if (!defined(material.extensions)) {
|
material.extensions = {};
|
}
|
|
material.extensions.KHR_techniques_webgl = {
|
values : generatedMaterialValues,
|
technique : technique
|
};
|
});
|
|
// If any primitives have semantics that aren't declared in the generated
|
// shaders, we want to preserve them.
|
ModelUtility.ensureSemanticExistence(gltf);
|
|
return gltf;
|
}
|
|
function isSpecularGlossinessMaterial(material) {
|
return defined(material.extensions) &&
|
defined(material.extensions.KHR_materials_pbrSpecularGlossiness);
|
}
|
|
function addTextureCoordinates(gltf, textureName, generatedMaterialValues, defaultTexCoord, result) {
|
var texCoord;
|
if (defined(generatedMaterialValues[textureName + 'Offset'])) {
|
texCoord = textureName + 'Coord';
|
result.fragmentShaderMain += ' vec2 ' + texCoord + ' = computeTexCoord(' + defaultTexCoord + ', ' + textureName + 'Offset, ' + textureName + 'Rotation, ' + textureName + 'Scale);\n';
|
} else {
|
texCoord = defaultTexCoord;
|
}
|
return texCoord;
|
}
|
|
var DEFAULT_TEXTURE_OFFSET = [0.0, 0.0];
|
var DEFAULT_TEXTURE_ROTATION = [0.0];
|
var DEFAULT_TEXTURE_SCALE = [1.0, 1.0];
|
|
function handleKHRTextureTransform(parameterName, value, generatedMaterialValues) {
|
if (parameterName.indexOf('Texture') === -1 || !defined(value.extensions) || !defined(value.extensions.KHR_texture_transform)) {
|
return;
|
}
|
|
var uniformName = 'u_' + parameterName;
|
var extension = value.extensions.KHR_texture_transform;
|
generatedMaterialValues[uniformName + 'Offset'] = defaultValue(extension.offset, DEFAULT_TEXTURE_OFFSET);
|
generatedMaterialValues[uniformName + 'Rotation'] = defaultValue(extension.rotation, DEFAULT_TEXTURE_ROTATION);
|
generatedMaterialValues[uniformName + 'Scale'] = defaultValue(extension.scale, DEFAULT_TEXTURE_SCALE);
|
|
if (defined(value.texCoord) && defined(extension.texCoord)) {
|
generatedMaterialValues[uniformName].texCoord = extension.texCoord;
|
}
|
}
|
|
function generateTechnique(gltf, material, materialIndex, generatedMaterialValues, primitiveByMaterial, options) {
|
var addBatchIdToGeneratedShaders = defaultValue(options.addBatchIdToGeneratedShaders, false);
|
|
var techniquesWebgl = gltf.extensions.KHR_techniques_webgl;
|
var techniques = techniquesWebgl.techniques;
|
var shaders = techniquesWebgl.shaders;
|
var programs = techniquesWebgl.programs;
|
|
var useSpecGloss = isSpecularGlossinessMaterial(material);
|
|
var uniformName;
|
var parameterName;
|
var value;
|
var pbrMetallicRoughness = material.pbrMetallicRoughness;
|
if (defined(pbrMetallicRoughness) && !useSpecGloss) {
|
for (parameterName in pbrMetallicRoughness) {
|
if (pbrMetallicRoughness.hasOwnProperty(parameterName)) {
|
value = pbrMetallicRoughness[parameterName];
|
uniformName = 'u_' + parameterName;
|
generatedMaterialValues[uniformName] = value;
|
handleKHRTextureTransform(parameterName, value, generatedMaterialValues);
|
}
|
}
|
}
|
|
if (useSpecGloss) {
|
var pbrSpecularGlossiness = material.extensions.KHR_materials_pbrSpecularGlossiness;
|
for (parameterName in pbrSpecularGlossiness) {
|
if (pbrSpecularGlossiness.hasOwnProperty(parameterName)) {
|
value = pbrSpecularGlossiness[parameterName];
|
uniformName = 'u_' + parameterName;
|
generatedMaterialValues[uniformName] = value;
|
handleKHRTextureTransform(parameterName, value, generatedMaterialValues);
|
}
|
}
|
}
|
|
for (var additional in material) {
|
if (material.hasOwnProperty(additional) && ((additional.indexOf('Texture') >= 0) || additional.indexOf('Factor') >= 0)) {
|
value = material[additional];
|
uniformName = 'u_' + additional;
|
generatedMaterialValues[uniformName] = value;
|
handleKHRTextureTransform(additional, value, generatedMaterialValues);
|
}
|
}
|
|
var vertexShader = 'precision highp float;\n';
|
var fragmentShader = 'precision highp float;\n';
|
|
var skin;
|
if (defined(gltf.skins)) {
|
skin = gltf.skins[0];
|
}
|
var joints = (defined(skin)) ? skin.joints : [];
|
var jointCount = joints.length;
|
|
var primitiveInfo = primitiveByMaterial[materialIndex];
|
|
var skinningInfo;
|
var hasSkinning = false;
|
var hasVertexColors = false;
|
var hasMorphTargets = false;
|
var hasNormals = false;
|
var hasTangents = false;
|
var hasTexCoords = false;
|
var isUnlit = false;
|
|
if (defined(primitiveInfo)) {
|
skinningInfo = primitiveInfo.skinning;
|
hasSkinning = skinningInfo.skinned && (joints.length > 0);
|
hasVertexColors = primitiveInfo.hasVertexColors;
|
hasMorphTargets = primitiveInfo.hasMorphTargets;
|
hasNormals = primitiveInfo.hasNormals;
|
hasTangents = primitiveInfo.hasTangents;
|
hasTexCoords = primitiveInfo.hasTexCoords;
|
}
|
|
var morphTargets;
|
if (hasMorphTargets) {
|
ForEach.mesh(gltf, function(mesh) {
|
ForEach.meshPrimitive(mesh, function(primitive) {
|
if (primitive.material === materialIndex) {
|
var targets = primitive.targets;
|
if (defined(targets)) {
|
morphTargets = targets;
|
}
|
}
|
});
|
});
|
}
|
|
// Add techniques
|
var techniqueUniforms = {
|
// Add matrices
|
u_modelViewMatrix : {
|
semantic : hasExtension(gltf, 'CESIUM_RTC') ? 'CESIUM_RTC_MODELVIEW' : 'MODELVIEW',
|
type : WebGLConstants.FLOAT_MAT4
|
},
|
u_projectionMatrix : {
|
semantic : 'PROJECTION',
|
type : WebGLConstants.FLOAT_MAT4
|
}
|
};
|
|
if (defined(material.extensions) && defined(material.extensions.KHR_materials_unlit)) {
|
isUnlit = true;
|
hasNormals = false;
|
hasTangents = false;
|
}
|
|
if (hasNormals) {
|
techniqueUniforms.u_normalMatrix = {
|
semantic : 'MODELVIEWINVERSETRANSPOSE',
|
type : WebGLConstants.FLOAT_MAT3
|
};
|
}
|
|
if (hasSkinning) {
|
techniqueUniforms.u_jointMatrix = {
|
count : jointCount,
|
semantic : 'JOINTMATRIX',
|
type : WebGLConstants.FLOAT_MAT4
|
};
|
}
|
|
if (hasMorphTargets) {
|
techniqueUniforms.u_morphWeights = {
|
count : morphTargets.length,
|
semantic : 'MORPHWEIGHTS',
|
type : WebGLConstants.FLOAT
|
};
|
}
|
|
var alphaMode = material.alphaMode;
|
if (defined(alphaMode) && alphaMode === 'MASK') {
|
techniqueUniforms.u_alphaCutoff = {
|
semantic: 'ALPHACUTOFF',
|
type: WebGLConstants.FLOAT
|
};
|
}
|
|
// Add material values
|
for (uniformName in generatedMaterialValues) {
|
if (generatedMaterialValues.hasOwnProperty(uniformName)) {
|
techniqueUniforms[uniformName] = {
|
type : getPBRValueType(uniformName)
|
};
|
}
|
}
|
|
var baseColorUniform = defaultValue(techniqueUniforms.u_baseColorTexture, techniqueUniforms.u_baseColorFactor);
|
if (defined(baseColorUniform)) {
|
baseColorUniform.semantic = '_3DTILESDIFFUSE';
|
}
|
|
// Add uniforms to shaders
|
for (uniformName in techniqueUniforms) {
|
if (techniqueUniforms.hasOwnProperty(uniformName)) {
|
var uniform = techniqueUniforms[uniformName];
|
var arraySize = defined(uniform.count) ? '[' + uniform.count + ']' : '';
|
if (((uniform.type !== WebGLConstants.FLOAT_MAT3) && (uniform.type !== WebGLConstants.FLOAT_MAT4) && (uniformName !== 'u_morphWeights')) ||
|
uniform.useInFragment) {
|
fragmentShader += 'uniform ' + webGLConstantToGlslType(uniform.type) + ' ' + uniformName + arraySize + ';\n';
|
delete uniform.useInFragment;
|
} else {
|
vertexShader += 'uniform ' + webGLConstantToGlslType(uniform.type) + ' ' + uniformName + arraySize + ';\n';
|
}
|
}
|
}
|
|
// Add attributes with semantics
|
var vertexShaderMain = '';
|
if (hasSkinning) {
|
var i, j;
|
var numberOfComponents = numberOfComponentsForType(skinningInfo.type);
|
var matrix = false;
|
if (skinningInfo.type.indexOf('MAT') === 0) {
|
matrix = true;
|
numberOfComponents = Math.sqrt(numberOfComponents);
|
}
|
if (!matrix) {
|
for (i = 0; i < numberOfComponents; i++) {
|
if (i === 0) {
|
vertexShaderMain += ' mat4 skinMatrix = ';
|
} else {
|
vertexShaderMain += ' skinMatrix += ';
|
}
|
vertexShaderMain += 'a_weight[' + i + '] * u_jointMatrix[int(a_joint[' + i + '])];\n';
|
}
|
} else {
|
for (i = 0; i < numberOfComponents; i++) {
|
for (j = 0; j < numberOfComponents; j++) {
|
if (i === 0 && j === 0) {
|
vertexShaderMain += ' mat4 skinMatrix = ';
|
} else {
|
vertexShaderMain += ' skinMatrix += ';
|
}
|
vertexShaderMain += 'a_weight[' + i + '][' + j + '] * u_jointMatrix[int(a_joint[' + i + '][' + j + '])];\n';
|
}
|
}
|
}
|
}
|
|
// Add position always
|
var techniqueAttributes = {
|
a_position : {
|
semantic : 'POSITION'
|
}
|
};
|
vertexShader += 'attribute vec3 a_position;\n';
|
if (hasNormals) {
|
vertexShader += 'varying vec3 v_positionEC;\n';
|
}
|
|
// Morph Target Weighting
|
vertexShaderMain += ' vec3 weightedPosition = a_position;\n';
|
if (hasNormals) {
|
vertexShaderMain += ' vec3 weightedNormal = a_normal;\n';
|
}
|
if (hasTangents) {
|
vertexShaderMain += ' vec4 weightedTangent = a_tangent;\n';
|
}
|
if (hasMorphTargets) {
|
for (var k = 0; k < morphTargets.length; k++) {
|
var targetAttributes = morphTargets[k];
|
for (var targetAttribute in targetAttributes) {
|
if (targetAttributes.hasOwnProperty(targetAttribute) && targetAttribute !== 'extras') {
|
var attributeName = 'a_' + targetAttribute + '_' + k;
|
techniqueAttributes[attributeName] = {
|
semantic : targetAttribute + '_' + k
|
};
|
vertexShader += 'attribute vec3 ' + attributeName + ';\n';
|
if (targetAttribute === 'POSITION') {
|
vertexShaderMain += ' weightedPosition += u_morphWeights[' + k + '] * ' + attributeName + ';\n';
|
} else if (targetAttribute === 'NORMAL') {
|
vertexShaderMain += ' weightedNormal += u_morphWeights[' + k + '] * ' + attributeName + ';\n';
|
} else if (hasTangents && targetAttribute === 'TANGENT') {
|
vertexShaderMain += ' weightedTangent.xyz += u_morphWeights[' + k + '] * ' + attributeName + ';\n';
|
}
|
}
|
}
|
}
|
}
|
|
// Final position computation
|
if (hasSkinning) {
|
vertexShaderMain += ' vec4 position = skinMatrix * vec4(weightedPosition, 1.0);\n';
|
} else {
|
vertexShaderMain += ' vec4 position = vec4(weightedPosition, 1.0);\n';
|
}
|
vertexShaderMain += ' position = u_modelViewMatrix * position;\n';
|
if (hasNormals) {
|
vertexShaderMain += ' v_positionEC = position.xyz;\n';
|
}
|
vertexShaderMain += ' gl_Position = u_projectionMatrix * position;\n';
|
|
// Final normal computation
|
if (hasNormals) {
|
techniqueAttributes.a_normal = {
|
semantic : 'NORMAL'
|
};
|
vertexShader += 'attribute vec3 a_normal;\n';
|
vertexShader += 'varying vec3 v_normal;\n';
|
if (hasSkinning) {
|
vertexShaderMain += ' v_normal = u_normalMatrix * mat3(skinMatrix) * weightedNormal;\n';
|
} else {
|
vertexShaderMain += ' v_normal = u_normalMatrix * weightedNormal;\n';
|
}
|
|
fragmentShader += 'varying vec3 v_normal;\n';
|
fragmentShader += 'varying vec3 v_positionEC;\n';
|
}
|
|
// Read tangents if available
|
if (hasTangents) {
|
techniqueAttributes.a_tangent = {
|
semantic : 'TANGENT'
|
};
|
vertexShader += 'attribute vec4 a_tangent;\n';
|
vertexShader += 'varying vec4 v_tangent;\n';
|
vertexShaderMain += ' v_tangent.xyz = u_normalMatrix * weightedTangent.xyz;\n';
|
vertexShaderMain += ' v_tangent.w = weightedTangent.w;\n';
|
|
fragmentShader += 'varying vec4 v_tangent;\n';
|
}
|
|
var fragmentShaderMain = '';
|
|
// Add texture coordinates if the material uses them
|
var v_texCoord;
|
var normalTexCoord;
|
var baseColorTexCoord;
|
var specularGlossinessTexCoord;
|
var diffuseTexCoord;
|
var metallicRoughnessTexCoord;
|
var occlusionTexCoord;
|
var emissiveTexCoord;
|
|
if (hasTexCoords) {
|
techniqueAttributes.a_texcoord_0 = {
|
semantic : 'TEXCOORD_0'
|
};
|
|
v_texCoord = 'v_texcoord_0';
|
vertexShader += 'attribute vec2 a_texcoord_0;\n';
|
vertexShader += 'varying vec2 ' + v_texCoord + ';\n';
|
vertexShaderMain += ' ' + v_texCoord + ' = a_texcoord_0;\n';
|
|
fragmentShader += 'varying vec2 ' + v_texCoord + ';\n';
|
|
var result = {
|
fragmentShaderMain : fragmentShaderMain
|
};
|
normalTexCoord = addTextureCoordinates(gltf, 'u_normalTexture', generatedMaterialValues, v_texCoord, result);
|
baseColorTexCoord = addTextureCoordinates(gltf, 'u_baseColorTexture', generatedMaterialValues, v_texCoord, result);
|
specularGlossinessTexCoord = addTextureCoordinates(gltf, 'u_specularGlossinessTexture', generatedMaterialValues, v_texCoord, result);
|
diffuseTexCoord = addTextureCoordinates(gltf, 'u_diffuseTexture', generatedMaterialValues, v_texCoord, result);
|
metallicRoughnessTexCoord = addTextureCoordinates(gltf, 'u_metallicRoughnessTexture', generatedMaterialValues, v_texCoord, result);
|
occlusionTexCoord = addTextureCoordinates(gltf, 'u_occlusionTexture', generatedMaterialValues, v_texCoord, result);
|
emissiveTexCoord = addTextureCoordinates(gltf, 'u_emmissiveTexture', generatedMaterialValues, v_texCoord, result);
|
|
fragmentShaderMain = result.fragmentShaderMain;
|
}
|
|
// Add skinning information if available
|
if (hasSkinning) {
|
var attributeType = ModelUtility.getShaderVariable(skinningInfo.type);
|
techniqueAttributes.a_joint = {
|
semantic : 'JOINTS_0'
|
};
|
techniqueAttributes.a_weight ={
|
semantic : 'WEIGHTS_0'
|
};
|
|
vertexShader += 'attribute ' + attributeType + ' a_joint;\n';
|
vertexShader += 'attribute ' + attributeType + ' a_weight;\n';
|
}
|
|
if (hasVertexColors) {
|
techniqueAttributes.a_vertexColor = {
|
semantic: 'COLOR_0'
|
};
|
vertexShader += 'attribute vec4 a_vertexColor;\n';
|
vertexShader += 'varying vec4 v_vertexColor;\n';
|
vertexShaderMain += ' v_vertexColor = a_vertexColor;\n';
|
fragmentShader += 'varying vec4 v_vertexColor;\n';
|
}
|
|
if (addBatchIdToGeneratedShaders) {
|
techniqueAttributes.a_batchId = {
|
semantic: '_BATCHID'
|
};
|
vertexShader += 'attribute float a_batchId;\n';
|
}
|
|
vertexShader += 'void main(void) \n{\n';
|
vertexShader += vertexShaderMain;
|
vertexShader += '}\n';
|
|
// Fragment shader lighting
|
if (hasNormals) {
|
fragmentShader += 'const float M_PI = 3.141592653589793;\n';
|
|
fragmentShader +=
|
'vec3 lambertianDiffuse(vec3 diffuseColor) \n' +
|
'{\n' +
|
' return diffuseColor / M_PI;\n' +
|
'}\n\n';
|
|
fragmentShader +=
|
'vec3 fresnelSchlick2(vec3 f0, vec3 f90, float VdotH) \n' +
|
'{\n' +
|
' return f0 + (f90 - f0) * pow(clamp(1.0 - VdotH, 0.0, 1.0), 5.0);\n' +
|
'}\n\n';
|
|
fragmentShader +=
|
'vec3 fresnelSchlick(float metalness, float VdotH) \n' +
|
'{\n' +
|
' return metalness + (vec3(1.0) - metalness) * pow(1.0 - VdotH, 5.0);\n' +
|
'}\n\n';
|
|
fragmentShader +=
|
'float smithVisibilityG1(float NdotV, float roughness) \n' +
|
'{\n' +
|
' float k = (roughness + 1.0) * (roughness + 1.0) / 8.0;\n' +
|
' return NdotV / (NdotV * (1.0 - k) + k);\n' +
|
'}\n\n';
|
|
fragmentShader +=
|
'float smithVisibilityGGX(float roughness, float NdotL, float NdotV) \n' +
|
'{\n' +
|
' return smithVisibilityG1(NdotL, roughness) * smithVisibilityG1(NdotV, roughness);\n' +
|
'}\n\n';
|
|
fragmentShader +=
|
'float GGX(float roughness, float NdotH) \n' +
|
'{\n' +
|
' float roughnessSquared = roughness * roughness;\n' +
|
' float f = (NdotH * roughnessSquared - NdotH) * NdotH + 1.0;\n' +
|
' return roughnessSquared / (M_PI * f * f);\n' +
|
'}\n\n';
|
}
|
|
fragmentShader +=
|
'vec3 SRGBtoLINEAR3(vec3 srgbIn) \n' +
|
'{\n' +
|
' return pow(srgbIn, vec3(2.2));\n' +
|
'}\n\n';
|
|
fragmentShader +=
|
'vec4 SRGBtoLINEAR4(vec4 srgbIn) \n' +
|
'{\n' +
|
' vec3 linearOut = pow(srgbIn.rgb, vec3(2.2));\n' +
|
' return vec4(linearOut, srgbIn.a);\n' +
|
'}\n\n';
|
|
fragmentShader +=
|
'vec3 applyTonemapping(vec3 linearIn) \n' +
|
'{\n' +
|
'#ifndef HDR \n' +
|
' return czm_acesTonemapping(linearIn);\n' +
|
'#else \n' +
|
' return linearIn;\n' +
|
'#endif \n' +
|
'}\n\n';
|
|
fragmentShader +=
|
'vec3 LINEARtoSRGB(vec3 linearIn) \n' +
|
'{\n' +
|
'#ifndef HDR \n' +
|
' return pow(linearIn, vec3(1.0/2.2));\n' +
|
'#else \n' +
|
' return linearIn;\n' +
|
'#endif \n' +
|
'}\n\n';
|
|
fragmentShader +=
|
'vec2 computeTexCoord(vec2 texCoords, vec2 offset, float rotation, vec2 scale) \n' +
|
'{\n' +
|
' rotation = -rotation; \n' +
|
' mat3 transform = mat3(\n' +
|
' cos(rotation) * scale.x, sin(rotation) * scale.x, 0.0, \n' +
|
' -sin(rotation) * scale.y, cos(rotation) * scale.y, 0.0, \n' +
|
' offset.x, offset.y, 1.0); \n' +
|
' vec2 transformedTexCoords = (transform * vec3(fract(texCoords), 1.0)).xy; \n' +
|
' return transformedTexCoords; \n' +
|
'}\n\n';
|
|
fragmentShader += '#ifdef USE_IBL_LIGHTING \n';
|
fragmentShader += 'uniform vec2 gltf_iblFactor; \n';
|
fragmentShader += '#endif \n';
|
fragmentShader += '#ifdef USE_CUSTOM_LIGHT_COLOR \n';
|
fragmentShader += 'uniform vec3 gltf_lightColor; \n';
|
fragmentShader += '#endif \n';
|
|
fragmentShader += 'void main(void) \n{\n';
|
fragmentShader += fragmentShaderMain;
|
|
// Add normal mapping to fragment shader
|
if (hasNormals) {
|
fragmentShader += ' vec3 ng = normalize(v_normal);\n';
|
fragmentShader += ' vec3 positionWC = vec3(czm_inverseView * vec4(v_positionEC, 1.0));\n';
|
if (defined(generatedMaterialValues.u_normalTexture)) {
|
if (hasTangents) {
|
// Read tangents from varying
|
fragmentShader += ' vec3 t = normalize(v_tangent.xyz);\n';
|
fragmentShader += ' vec3 b = normalize(cross(ng, t) * v_tangent.w);\n';
|
fragmentShader += ' mat3 tbn = mat3(t, b, ng);\n';
|
fragmentShader += ' vec3 n = texture2D(u_normalTexture, ' + normalTexCoord + ').rgb;\n';
|
fragmentShader += ' n = normalize(tbn * (2.0 * n - 1.0));\n';
|
} else {
|
// Add standard derivatives extension
|
fragmentShader = '#ifdef GL_OES_standard_derivatives\n' +
|
'#extension GL_OES_standard_derivatives : enable\n' +
|
'#endif\n' +
|
fragmentShader;
|
// Compute tangents
|
fragmentShader += '#ifdef GL_OES_standard_derivatives\n';
|
fragmentShader += ' vec3 pos_dx = dFdx(v_positionEC);\n';
|
fragmentShader += ' vec3 pos_dy = dFdy(v_positionEC);\n';
|
fragmentShader += ' vec3 tex_dx = dFdx(vec3(' + normalTexCoord + ',0.0));\n';
|
fragmentShader += ' vec3 tex_dy = dFdy(vec3(' + normalTexCoord + ',0.0));\n';
|
fragmentShader += ' vec3 t = (tex_dy.t * pos_dx - tex_dx.t * pos_dy) / (tex_dx.s * tex_dy.t - tex_dy.s * tex_dx.t);\n';
|
fragmentShader += ' t = normalize(t - ng * dot(ng, t));\n';
|
fragmentShader += ' vec3 b = normalize(cross(ng, t));\n';
|
fragmentShader += ' mat3 tbn = mat3(t, b, ng);\n';
|
fragmentShader += ' vec3 n = texture2D(u_normalTexture, ' + normalTexCoord + ').rgb;\n';
|
fragmentShader += ' n = normalize(tbn * (2.0 * n - 1.0));\n';
|
fragmentShader += '#else\n';
|
fragmentShader += ' vec3 n = ng;\n';
|
fragmentShader += '#endif\n';
|
}
|
} else {
|
fragmentShader += ' vec3 n = ng;\n';
|
}
|
if (material.doubleSided) {
|
// !gl_FrontFacing doesn't work as expected on Mac/Intel so use the more verbose form instead. See https://github.com/CesiumGS/cesium/pull/8494.
|
fragmentShader += ' if (gl_FrontFacing == false)\n';
|
fragmentShader += ' {\n';
|
fragmentShader += ' n = -n;\n';
|
fragmentShader += ' }\n';
|
}
|
}
|
|
// Add base color to fragment shader
|
if (defined(generatedMaterialValues.u_baseColorTexture)) {
|
fragmentShader += ' vec4 baseColorWithAlpha = SRGBtoLINEAR4(texture2D(u_baseColorTexture, ' + baseColorTexCoord + '));\n';
|
if (defined(generatedMaterialValues.u_baseColorFactor)) {
|
fragmentShader += ' baseColorWithAlpha *= u_baseColorFactor;\n';
|
}
|
} else if (defined(generatedMaterialValues.u_baseColorFactor)) {
|
fragmentShader += ' vec4 baseColorWithAlpha = u_baseColorFactor;\n';
|
} else {
|
fragmentShader += ' vec4 baseColorWithAlpha = vec4(1.0);\n';
|
}
|
|
if (hasVertexColors) {
|
fragmentShader += ' baseColorWithAlpha *= v_vertexColor;\n';
|
}
|
|
fragmentShader += ' vec3 baseColor = baseColorWithAlpha.rgb;\n';
|
|
if (hasNormals) {
|
if (useSpecGloss) {
|
if (defined(generatedMaterialValues.u_specularGlossinessTexture)) {
|
fragmentShader += ' vec4 specularGlossiness = SRGBtoLINEAR4(texture2D(u_specularGlossinessTexture, ' + specularGlossinessTexCoord + '));\n';
|
fragmentShader += ' vec3 specular = specularGlossiness.rgb;\n';
|
fragmentShader += ' float glossiness = specularGlossiness.a;\n';
|
if (defined(generatedMaterialValues.u_specularFactor)) {
|
fragmentShader += ' specular *= u_specularFactor;\n';
|
}
|
if (defined(generatedMaterialValues.u_glossinessFactor)) {
|
fragmentShader += ' glossiness *= u_glossinessFactor;\n';
|
}
|
} else {
|
if (defined(generatedMaterialValues.u_specularFactor)) {
|
fragmentShader += ' vec3 specular = clamp(u_specularFactor, vec3(0.0), vec3(1.0));\n';
|
} else {
|
fragmentShader += ' vec3 specular = vec3(1.0);\n';
|
}
|
if (defined(generatedMaterialValues.u_glossinessFactor)) {
|
fragmentShader += ' float glossiness = clamp(u_glossinessFactor, 0.0, 1.0);\n';
|
} else {
|
fragmentShader += ' float glossiness = 1.0;\n';
|
}
|
}
|
if (defined(generatedMaterialValues.u_diffuseTexture)) {
|
fragmentShader += ' vec4 diffuse = SRGBtoLINEAR4(texture2D(u_diffuseTexture, ' + diffuseTexCoord + '));\n';
|
if (defined(generatedMaterialValues.u_diffuseFactor)) {
|
fragmentShader += ' diffuse *= u_diffuseFactor;\n';
|
}
|
} else if (defined(generatedMaterialValues.u_diffuseFactor)) {
|
fragmentShader += ' vec4 diffuse = clamp(u_diffuseFactor, vec4(0.0), vec4(1.0));\n';
|
} else {
|
fragmentShader += ' vec4 diffuse = vec4(1.0);\n';
|
}
|
} else if (defined(generatedMaterialValues.u_metallicRoughnessTexture)) {
|
fragmentShader += ' vec3 metallicRoughness = texture2D(u_metallicRoughnessTexture, ' + metallicRoughnessTexCoord + ').rgb;\n';
|
fragmentShader += ' float metalness = clamp(metallicRoughness.b, 0.0, 1.0);\n';
|
fragmentShader += ' float roughness = clamp(metallicRoughness.g, 0.04, 1.0);\n';
|
if (defined(generatedMaterialValues.u_metallicFactor)) {
|
fragmentShader += ' metalness *= u_metallicFactor;\n';
|
}
|
if (defined(generatedMaterialValues.u_roughnessFactor)) {
|
fragmentShader += ' roughness *= u_roughnessFactor;\n';
|
}
|
} else {
|
if (defined(generatedMaterialValues.u_metallicFactor)) {
|
fragmentShader += ' float metalness = clamp(u_metallicFactor, 0.0, 1.0);\n';
|
} else {
|
fragmentShader += ' float metalness = 1.0;\n';
|
}
|
if (defined(generatedMaterialValues.u_roughnessFactor)) {
|
fragmentShader += ' float roughness = clamp(u_roughnessFactor, 0.04, 1.0);\n';
|
} else {
|
fragmentShader += ' float roughness = 1.0;\n';
|
}
|
}
|
|
fragmentShader += ' vec3 v = -normalize(v_positionEC);\n';
|
|
// Generate fragment shader's lighting block
|
fragmentShader += '#ifndef USE_CUSTOM_LIGHT_COLOR \n';
|
fragmentShader += ' vec3 lightColorHdr = czm_lightColorHdr;\n';
|
fragmentShader += '#else \n';
|
fragmentShader += ' vec3 lightColorHdr = gltf_lightColor;\n';
|
fragmentShader += '#endif \n';
|
fragmentShader += ' vec3 l = normalize(czm_lightDirectionEC);\n';
|
fragmentShader += ' vec3 h = normalize(v + l);\n';
|
fragmentShader += ' float NdotL = clamp(dot(n, l), 0.001, 1.0);\n';
|
fragmentShader += ' float NdotV = abs(dot(n, v)) + 0.001;\n';
|
fragmentShader += ' float NdotH = clamp(dot(n, h), 0.0, 1.0);\n';
|
fragmentShader += ' float LdotH = clamp(dot(l, h), 0.0, 1.0);\n';
|
fragmentShader += ' float VdotH = clamp(dot(v, h), 0.0, 1.0);\n';
|
fragmentShader += ' vec3 f0 = vec3(0.04);\n';
|
// Whether the material uses metallic-roughness or specular-glossiness changes how the BRDF inputs are computed.
|
// It does not change the implementation of the BRDF itself.
|
if (useSpecGloss) {
|
fragmentShader += ' float roughness = 1.0 - glossiness;\n';
|
fragmentShader += ' vec3 diffuseColor = diffuse.rgb * (1.0 - max(max(specular.r, specular.g), specular.b));\n';
|
fragmentShader += ' vec3 specularColor = specular;\n';
|
} else {
|
fragmentShader += ' vec3 diffuseColor = baseColor * (1.0 - metalness) * (1.0 - f0);\n';
|
fragmentShader += ' vec3 specularColor = mix(f0, baseColor, metalness);\n';
|
}
|
|
fragmentShader += ' float alpha = roughness * roughness;\n';
|
fragmentShader += ' float reflectance = max(max(specularColor.r, specularColor.g), specularColor.b);\n';
|
fragmentShader += ' vec3 r90 = vec3(clamp(reflectance * 25.0, 0.0, 1.0));\n';
|
fragmentShader += ' vec3 r0 = specularColor.rgb;\n';
|
|
fragmentShader += ' vec3 F = fresnelSchlick2(r0, r90, VdotH);\n';
|
fragmentShader += ' float G = smithVisibilityGGX(alpha, NdotL, NdotV);\n';
|
fragmentShader += ' float D = GGX(alpha, NdotH);\n';
|
|
fragmentShader += ' vec3 diffuseContribution = (1.0 - F) * lambertianDiffuse(diffuseColor);\n';
|
fragmentShader += ' vec3 specularContribution = F * G * D / (4.0 * NdotL * NdotV);\n';
|
fragmentShader += ' vec3 color = NdotL * lightColorHdr * (diffuseContribution + specularContribution);\n';
|
|
// Use the procedural IBL if there are no environment maps
|
fragmentShader += '#if defined(USE_IBL_LIGHTING) && !defined(DIFFUSE_IBL) && !defined(SPECULAR_IBL) \n';
|
|
fragmentShader += ' vec3 r = normalize(czm_inverseViewRotation * normalize(reflect(v, n)));\n';
|
// Figure out if the reflection vector hits the ellipsoid
|
fragmentShader += ' float vertexRadius = length(positionWC);\n';
|
fragmentShader += ' float horizonDotNadir = 1.0 - min(1.0, czm_ellipsoidRadii.x / vertexRadius);\n';
|
fragmentShader += ' float reflectionDotNadir = dot(r, normalize(positionWC));\n';
|
// Flipping the X vector is a cheap way to get the inverse of czm_temeToPseudoFixed, since that's a rotation about Z.
|
fragmentShader += ' r.x = -r.x;\n';
|
fragmentShader += ' r = -normalize(czm_temeToPseudoFixed * r);\n';
|
fragmentShader += ' r.x = -r.x;\n';
|
|
fragmentShader += ' float inverseRoughness = 1.04 - roughness;\n';
|
fragmentShader += ' inverseRoughness *= inverseRoughness;\n';
|
fragmentShader += ' vec3 sceneSkyBox = textureCube(czm_environmentMap, r).rgb * inverseRoughness;\n';
|
|
fragmentShader += ' float atmosphereHeight = 0.05;\n';
|
fragmentShader += ' float blendRegionSize = 0.1 * ((1.0 - inverseRoughness) * 8.0 + 1.1 - horizonDotNadir);\n';
|
fragmentShader += ' float blendRegionOffset = roughness * -1.0;\n';
|
fragmentShader += ' float farAboveHorizon = clamp(horizonDotNadir - blendRegionSize * 0.5 + blendRegionOffset, 1.0e-10 - blendRegionSize, 0.99999);\n';
|
fragmentShader += ' float aroundHorizon = clamp(horizonDotNadir + blendRegionSize * 0.5, 1.0e-10 - blendRegionSize, 0.99999);\n';
|
fragmentShader += ' float farBelowHorizon = clamp(horizonDotNadir + blendRegionSize * 1.5, 1.0e-10 - blendRegionSize, 0.99999);\n';
|
fragmentShader += ' float smoothstepHeight = smoothstep(0.0, atmosphereHeight, horizonDotNadir);\n';
|
|
fragmentShader += ' vec3 belowHorizonColor = mix(vec3(0.1, 0.15, 0.25), vec3(0.4, 0.7, 0.9), smoothstepHeight);\n';
|
fragmentShader += ' vec3 nadirColor = belowHorizonColor * 0.5;\n';
|
fragmentShader += ' vec3 aboveHorizonColor = mix(vec3(0.9, 1.0, 1.2), belowHorizonColor, roughness * 0.5);\n';
|
fragmentShader += ' vec3 blueSkyColor = mix(vec3(0.18, 0.26, 0.48), aboveHorizonColor, reflectionDotNadir * inverseRoughness * 0.5 + 0.75);\n';
|
fragmentShader += ' vec3 zenithColor = mix(blueSkyColor, sceneSkyBox, smoothstepHeight);\n';
|
|
fragmentShader += ' vec3 blueSkyDiffuseColor = vec3(0.7, 0.85, 0.9);\n';
|
fragmentShader += ' float diffuseIrradianceFromEarth = (1.0 - horizonDotNadir) * (reflectionDotNadir * 0.25 + 0.75) * smoothstepHeight;\n';
|
fragmentShader += ' float diffuseIrradianceFromSky = (1.0 - smoothstepHeight) * (1.0 - (reflectionDotNadir * 0.25 + 0.25));\n';
|
fragmentShader += ' vec3 diffuseIrradiance = blueSkyDiffuseColor * clamp(diffuseIrradianceFromEarth + diffuseIrradianceFromSky, 0.0, 1.0);\n';
|
|
fragmentShader += ' float notDistantRough = (1.0 - horizonDotNadir * roughness * 0.8);\n';
|
fragmentShader += ' vec3 specularIrradiance = mix(zenithColor, aboveHorizonColor, smoothstep(farAboveHorizon, aroundHorizon, reflectionDotNadir) * notDistantRough);\n';
|
fragmentShader += ' specularIrradiance = mix(specularIrradiance, belowHorizonColor, smoothstep(aroundHorizon, farBelowHorizon, reflectionDotNadir) * inverseRoughness);\n';
|
fragmentShader += ' specularIrradiance = mix(specularIrradiance, nadirColor, smoothstep(farBelowHorizon, 1.0, reflectionDotNadir) * inverseRoughness);\n';
|
|
// Luminance model from page 40 of http://silviojemma.com/public/papers/lighting/spherical-harmonic-lighting.pdf
|
fragmentShader += '#ifdef USE_SUN_LUMINANCE \n';
|
// Angle between sun and zenith
|
fragmentShader += ' float LdotZenith = clamp(dot(normalize(czm_inverseViewRotation * l), normalize(positionWC * -1.0)), 0.001, 1.0);\n';
|
fragmentShader += ' float S = acos(LdotZenith);\n';
|
// Angle between zenith and current pixel
|
fragmentShader += ' float NdotZenith = clamp(dot(normalize(czm_inverseViewRotation * n), normalize(positionWC * -1.0)), 0.001, 1.0);\n';
|
// Angle between sun and current pixel
|
fragmentShader += ' float gamma = acos(NdotL);\n';
|
fragmentShader += ' float numerator = ((0.91 + 10.0 * exp(-3.0 * gamma) + 0.45 * pow(NdotL, 2.0)) * (1.0 - exp(-0.32 / NdotZenith)));\n';
|
fragmentShader += ' float denominator = (0.91 + 10.0 * exp(-3.0 * S) + 0.45 * pow(LdotZenith,2.0)) * (1.0 - exp(-0.32));\n';
|
fragmentShader += ' float luminance = gltf_luminanceAtZenith * (numerator / denominator);\n';
|
fragmentShader += '#endif \n';
|
|
fragmentShader += ' vec2 brdfLut = texture2D(czm_brdfLut, vec2(NdotV, roughness)).rg;\n';
|
fragmentShader += ' vec3 IBLColor = (diffuseIrradiance * diffuseColor * gltf_iblFactor.x) + (specularIrradiance * SRGBtoLINEAR3(specularColor * brdfLut.x + brdfLut.y) * gltf_iblFactor.y);\n';
|
|
fragmentShader += ' float maximumComponent = max(max(lightColorHdr.x, lightColorHdr.y), lightColorHdr.z);\n';
|
fragmentShader += ' vec3 lightColor = lightColorHdr / max(maximumComponent, 1.0);\n';
|
fragmentShader += ' IBLColor *= lightColor;\n';
|
|
fragmentShader += '#ifdef USE_SUN_LUMINANCE \n';
|
fragmentShader += ' color += IBLColor * luminance;\n';
|
fragmentShader += '#else \n';
|
fragmentShader += ' color += IBLColor; \n';
|
fragmentShader += '#endif \n';
|
|
// Environment maps were provided, use them for IBL
|
fragmentShader += '#elif defined(DIFFUSE_IBL) || defined(SPECULAR_IBL) \n';
|
|
fragmentShader += ' mat3 fixedToENU = mat3(gltf_clippingPlanesMatrix[0][0], gltf_clippingPlanesMatrix[1][0], gltf_clippingPlanesMatrix[2][0], \n';
|
fragmentShader += ' gltf_clippingPlanesMatrix[0][1], gltf_clippingPlanesMatrix[1][1], gltf_clippingPlanesMatrix[2][1], \n';
|
fragmentShader += ' gltf_clippingPlanesMatrix[0][2], gltf_clippingPlanesMatrix[1][2], gltf_clippingPlanesMatrix[2][2]); \n';
|
fragmentShader += ' const mat3 yUpToZUp = mat3(-1.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, 1.0, 0.0); \n';
|
fragmentShader += ' vec3 cubeDir = normalize(yUpToZUp * fixedToENU * normalize(reflect(-v, n))); \n';
|
|
fragmentShader += '#ifdef DIFFUSE_IBL \n';
|
fragmentShader += '#ifdef CUSTOM_SPHERICAL_HARMONICS \n';
|
fragmentShader += ' vec3 diffuseIrradiance = czm_sphericalHarmonics(cubeDir, gltf_sphericalHarmonicCoefficients); \n';
|
fragmentShader += '#else \n';
|
fragmentShader += ' vec3 diffuseIrradiance = czm_sphericalHarmonics(cubeDir, czm_sphericalHarmonicCoefficients); \n';
|
fragmentShader += '#endif \n';
|
fragmentShader += '#else \n';
|
fragmentShader += ' vec3 diffuseIrradiance = vec3(0.0); \n';
|
fragmentShader += '#endif \n';
|
|
fragmentShader += '#ifdef SPECULAR_IBL \n';
|
fragmentShader += ' vec2 brdfLut = texture2D(czm_brdfLut, vec2(NdotV, roughness)).rg;\n';
|
fragmentShader += '#ifdef CUSTOM_SPECULAR_IBL \n';
|
fragmentShader += ' vec3 specularIBL = czm_sampleOctahedralProjection(gltf_specularMap, gltf_specularMapSize, cubeDir, roughness * gltf_maxSpecularLOD, gltf_maxSpecularLOD);\n';
|
fragmentShader += '#else \n';
|
fragmentShader += ' vec3 specularIBL = czm_sampleOctahedralProjection(czm_specularEnvironmentMaps, czm_specularEnvironmentMapSize, cubeDir, roughness * czm_specularEnvironmentMapsMaximumLOD, czm_specularEnvironmentMapsMaximumLOD);\n';
|
fragmentShader += '#endif \n';
|
fragmentShader += ' specularIBL *= F * brdfLut.x + brdfLut.y;\n';
|
fragmentShader += '#else \n';
|
fragmentShader += ' vec3 specularIBL = vec3(0.0); \n';
|
fragmentShader += '#endif \n';
|
|
fragmentShader += ' color += diffuseIrradiance * diffuseColor + specularColor * specularIBL;\n';
|
|
fragmentShader += '#endif \n';
|
} else {
|
fragmentShader += ' vec3 color = baseColor;\n';
|
}
|
|
// Ignore occlusion and emissive when unlit
|
if (!isUnlit) {
|
if (defined(generatedMaterialValues.u_occlusionTexture)) {
|
fragmentShader += ' color *= texture2D(u_occlusionTexture, ' + occlusionTexCoord + ').r;\n';
|
}
|
if (defined(generatedMaterialValues.u_emissiveTexture)) {
|
fragmentShader += ' vec3 emissive = SRGBtoLINEAR3(texture2D(u_emissiveTexture, ' + emissiveTexCoord + ').rgb);\n';
|
if (defined(generatedMaterialValues.u_emissiveFactor)) {
|
fragmentShader += ' emissive *= u_emissiveFactor;\n';
|
}
|
fragmentShader += ' color += emissive;\n';
|
} else if (defined(generatedMaterialValues.u_emissiveFactor)) {
|
fragmentShader += ' color += u_emissiveFactor;\n';
|
}
|
}
|
|
if (!isUnlit) {
|
fragmentShader += ' color = applyTonemapping(color);\n';
|
}
|
|
fragmentShader += ' color = LINEARtoSRGB(color);\n';
|
|
if (defined(alphaMode)) {
|
if (alphaMode === 'MASK') {
|
fragmentShader += ' if (baseColorWithAlpha.a < u_alphaCutoff) {\n';
|
fragmentShader += ' discard;\n';
|
fragmentShader += ' }\n';
|
fragmentShader += ' gl_FragColor = vec4(color, 1.0);\n';
|
} else if (alphaMode === 'BLEND') {
|
fragmentShader += ' gl_FragColor = vec4(color, baseColorWithAlpha.a);\n';
|
} else {
|
fragmentShader += ' gl_FragColor = vec4(color, 1.0);\n';
|
}
|
} else {
|
fragmentShader += ' gl_FragColor = vec4(color, 1.0);\n';
|
}
|
|
fragmentShader += '}\n';
|
|
// Add shaders
|
var vertexShaderId = addToArray(shaders, {
|
type : WebGLConstants.VERTEX_SHADER,
|
extras : {
|
_pipeline : {
|
source : vertexShader,
|
extension : '.glsl'
|
}
|
}
|
});
|
|
var fragmentShaderId = addToArray(shaders, {
|
type : WebGLConstants.FRAGMENT_SHADER,
|
extras : {
|
_pipeline : {
|
source : fragmentShader,
|
extension : '.glsl'
|
}
|
}
|
});
|
|
// Add program
|
var programId = addToArray(programs, {
|
fragmentShader : fragmentShaderId,
|
vertexShader : vertexShaderId
|
});
|
|
var techniqueId = addToArray(techniques, {
|
attributes : techniqueAttributes,
|
program : programId,
|
uniforms : techniqueUniforms
|
});
|
|
return techniqueId;
|
}
|
|
function getPBRValueType(paramName) {
|
if (paramName.indexOf('Offset') !== -1) {
|
return WebGLConstants.FLOAT_VEC2;
|
} else if (paramName.indexOf('Rotation') !== -1) {
|
return WebGLConstants.FLOAT;
|
} else if (paramName.indexOf('Scale') !== -1) {
|
return WebGLConstants.FLOAT_VEC2;
|
} else if (paramName.indexOf('Texture') !== -1) {
|
return WebGLConstants.SAMPLER_2D;
|
}
|
|
switch (paramName) {
|
case 'u_baseColorFactor':
|
return WebGLConstants.FLOAT_VEC4;
|
case 'u_metallicFactor':
|
return WebGLConstants.FLOAT;
|
case 'u_roughnessFactor':
|
return WebGLConstants.FLOAT;
|
case 'u_emissiveFactor':
|
return WebGLConstants.FLOAT_VEC3;
|
// Specular Glossiness Types
|
case 'u_diffuseFactor':
|
return WebGLConstants.FLOAT_VEC4;
|
case 'u_specularFactor':
|
return WebGLConstants.FLOAT_VEC3;
|
case 'u_glossinessFactor':
|
return WebGLConstants.FLOAT;
|
}
|
}
|
export default processPbrMaterials;
|
