cesium
Version:
CesiumJS is a JavaScript library for creating 3D globes and 2D maps in a web browser without a plugin.
939 lines (824 loc) • 46 kB
JavaScript
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;