cesium
Version:
CesiumJS is a JavaScript library for creating 3D globes and 2D maps in a web browser without a plugin.
793 lines (693 loc) • 34.7 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 processModelMaterialsCommon(gltf, options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
if (!defined(gltf)) {
return;
}
if (!hasExtension(gltf, 'KHR_materials_common')) {
return;
}
if (!hasExtension(gltf, 'KHR_techniques_webgl')) {
if (!defined(gltf.extensions)) {
gltf.extensions = {};
}
gltf.extensions.KHR_techniques_webgl = {
programs : [],
shaders : [],
techniques : []
};
gltf.extensionsUsed.push('KHR_techniques_webgl');
gltf.extensionsRequired.push('KHR_techniques_webgl');
}
var techniquesWebgl = gltf.extensions.KHR_techniques_webgl;
lightDefaults(gltf);
var lightParameters = generateLightParameters(gltf);
var primitiveByMaterial = ModelUtility.splitIncompatibleMaterials(gltf);
var techniques = {};
var generatedTechniques = false;
ForEach.material(gltf, function(material, materialIndex) {
if (defined(material.extensions) && defined(material.extensions.KHR_materials_common)) {
var khrMaterialsCommon = material.extensions.KHR_materials_common;
var primitiveInfo = primitiveByMaterial[materialIndex];
var techniqueKey = getTechniqueKey(khrMaterialsCommon, primitiveInfo);
var technique = techniques[techniqueKey];
if (!defined(technique)) {
technique = generateTechnique(gltf, techniquesWebgl, primitiveInfo, khrMaterialsCommon, lightParameters, options.addBatchIdToGeneratedShaders);
techniques[techniqueKey] = technique;
generatedTechniques = true;
}
var materialValues = {};
var values = khrMaterialsCommon.values;
var uniformName;
for (var valueName in values) {
if (values.hasOwnProperty(valueName) && (valueName !== 'transparent') && (valueName !== 'doubleSided')) {
uniformName = 'u_' + valueName.toLowerCase();
materialValues[uniformName] = values[valueName];
}
}
material.extensions.KHR_techniques_webgl = {
technique: technique,
values: materialValues
};
material.alphaMode = 'OPAQUE';
if (khrMaterialsCommon.transparent) {
material.alphaMode = 'BLEND';
}
if (khrMaterialsCommon.doubleSided) {
material.doubleSided = true;
}
}
});
if (!generatedTechniques) {
return gltf;
}
// If any primitives have semantics that aren't declared in the generated
// shaders, we want to preserve them.
ModelUtility.ensureSemanticExistence(gltf);
return gltf;
}
function generateLightParameters(gltf) {
var result = {};
var lights;
if (defined(gltf.extensions) && defined(gltf.extensions.KHR_materials_common)) {
lights = gltf.extensions.KHR_materials_common.lights;
}
if (defined(lights)) {
// Figure out which node references the light
var nodes = gltf.nodes;
for (var nodeName in nodes) {
if (nodes.hasOwnProperty(nodeName)) {
var node = nodes[nodeName];
if (defined(node.extensions) && defined(node.extensions.KHR_materials_common)) {
var nodeLightId = node.extensions.KHR_materials_common.light;
if (defined(nodeLightId) && defined(lights[nodeLightId])) {
lights[nodeLightId].node = nodeName;
}
delete node.extensions.KHR_materials_common;
}
}
}
// Add light parameters to result
var lightCount = 0;
for (var lightName in lights) {
if (lights.hasOwnProperty(lightName)) {
var light = lights[lightName];
var lightType = light.type;
if ((lightType !== 'ambient') && !defined(light.node)) {
delete lights[lightName];
continue;
}
var lightBaseName = 'light' + lightCount.toString();
light.baseName = lightBaseName;
switch (lightType) {
case 'ambient':
var ambient = light.ambient;
result[lightBaseName + 'Color'] = {
type: WebGLConstants.FLOAT_VEC3,
value: ambient.color
};
break;
case 'directional':
var directional = light.directional;
result[lightBaseName + 'Color'] = {
type: WebGLConstants.FLOAT_VEC3,
value: directional.color
};
if (defined(light.node)) {
result[lightBaseName + 'Transform'] = {
node: light.node,
semantic: 'MODELVIEW',
type: WebGLConstants.FLOAT_MAT4
};
}
break;
case 'point':
var point = light.point;
result[lightBaseName + 'Color'] = {
type: WebGLConstants.FLOAT_VEC3,
value: point.color
};
if (defined(light.node)) {
result[lightBaseName + 'Transform'] = {
node: light.node,
semantic: 'MODELVIEW',
type: WebGLConstants.FLOAT_MAT4
};
}
result[lightBaseName + 'Attenuation'] = {
type: WebGLConstants.FLOAT_VEC3,
value: [point.constantAttenuation, point.linearAttenuation, point.quadraticAttenuation]
};
break;
case 'spot':
var spot = light.spot;
result[lightBaseName + 'Color'] = {
type: WebGLConstants.FLOAT_VEC3,
value: spot.color
};
if (defined(light.node)) {
result[lightBaseName + 'Transform'] = {
node: light.node,
semantic: 'MODELVIEW',
type: WebGLConstants.FLOAT_MAT4
};
result[lightBaseName + 'InverseTransform'] = {
node: light.node,
semantic: 'MODELVIEWINVERSE',
type: WebGLConstants.FLOAT_MAT4,
useInFragment: true
};
}
result[lightBaseName + 'Attenuation'] = {
type: WebGLConstants.FLOAT_VEC3,
value: [spot.constantAttenuation, spot.linearAttenuation, spot.quadraticAttenuation]
};
result[lightBaseName + 'FallOff'] = {
type: WebGLConstants.FLOAT_VEC2,
value: [spot.fallOffAngle, spot.fallOffExponent]
};
break;
}
++lightCount;
}
}
}
return result;
}
function generateTechnique(gltf, techniquesWebgl, primitiveInfo, khrMaterialsCommon, lightParameters, addBatchIdToGeneratedShaders) {
if (!defined(khrMaterialsCommon)) {
khrMaterialsCommon = {};
}
addBatchIdToGeneratedShaders = defaultValue(addBatchIdToGeneratedShaders, false);
var techniques = techniquesWebgl.techniques;
var shaders = techniquesWebgl.shaders;
var programs = techniquesWebgl.programs;
var lightingModel = khrMaterialsCommon.technique.toUpperCase();
var lights;
if (defined(gltf.extensions) && defined(gltf.extensions.KHR_materials_common)) {
lights = gltf.extensions.KHR_materials_common.lights;
}
var parameterValues = khrMaterialsCommon.values;
var jointCount = defaultValue(khrMaterialsCommon.jointCount, 0);
var skinningInfo;
var hasSkinning = false;
var hasVertexColors = false;
if (defined(primitiveInfo)) {
skinningInfo = primitiveInfo.skinning;
hasSkinning = skinningInfo.skinned;
hasVertexColors = primitiveInfo.hasVertexColors;
}
var vertexShader = 'precision highp float;\n';
var fragmentShader = 'precision highp float;\n';
var hasNormals = (lightingModel !== 'CONSTANT');
// Add techniques
var techniqueUniforms = {
u_modelViewMatrix: {
semantic: hasExtension(gltf, 'CESIUM_RTC') ? 'CESIUM_RTC_MODELVIEW' : 'MODELVIEW',
type: WebGLConstants.FLOAT_MAT4
},
u_projectionMatrix: {
semantic: 'PROJECTION',
type: WebGLConstants.FLOAT_MAT4
}
};
if (hasNormals) {
techniqueUniforms.u_normalMatrix = {
semantic: 'MODELVIEWINVERSETRANSPOSE',
type: WebGLConstants.FLOAT_MAT3
};
}
if (hasSkinning) {
techniqueUniforms.u_jointMatrix = {
count: jointCount,
semantic: 'JOINTMATRIX',
type: WebGLConstants.FLOAT_MAT4
};
}
// Add material values
var uniformName;
var hasTexCoords = false;
for (var name in parameterValues) {
//generate shader parameters for KHR_materials_common attributes
//(including a check, because some boolean flags should not be used as shader parameters)
if (parameterValues.hasOwnProperty(name) && (name !== 'transparent') && (name !== 'doubleSided')) {
var uniformType = getKHRMaterialsCommonValueType(name, parameterValues[name]);
uniformName = 'u_' + name.toLowerCase();
if (!hasTexCoords && (uniformType === WebGLConstants.SAMPLER_2D)) {
hasTexCoords = true;
}
techniqueUniforms[uniformName] = {
type : uniformType
};
}
}
// Give the diffuse uniform a semantic to support color replacement in 3D Tiles
if (defined(techniqueUniforms.u_diffuse)) {
techniqueUniforms.u_diffuse.semantic = '_3DTILESDIFFUSE';
}
// Copy light parameters into technique parameters
if (defined(lightParameters)) {
for (var lightParamName in lightParameters) {
if (lightParameters.hasOwnProperty(lightParamName)) {
uniformName = 'u_' + lightParamName;
techniqueUniforms[uniformName] = lightParameters[lightParamName];
}
}
}
// 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)) ||
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 skinMat = ';
} else {
vertexShaderMain += ' skinMat += ';
}
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 skinMat = ';
} else {
vertexShaderMain += ' skinMat += ';
}
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';
vertexShader += 'varying vec3 v_positionEC;\n';
if (hasSkinning) {
vertexShaderMain += ' vec4 pos = u_modelViewMatrix * skinMat * vec4(a_position,1.0);\n';
} else {
vertexShaderMain += ' vec4 pos = u_modelViewMatrix * vec4(a_position,1.0);\n';
}
vertexShaderMain += ' v_positionEC = pos.xyz;\n';
vertexShaderMain += ' gl_Position = u_projectionMatrix * pos;\n';
fragmentShader += 'varying vec3 v_positionEC;\n';
// Add normal if we don't have constant lighting
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(skinMat) * a_normal;\n';
} else {
vertexShaderMain += ' v_normal = u_normalMatrix * a_normal;\n';
}
fragmentShader += 'varying vec3 v_normal;\n';
}
// Add texture coordinates if the material uses them
var v_texcoord;
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';
}
if (hasSkinning) {
var attributeType = ModelUtility.getShaderVariable(skinningInfo.type);
techniqueAttributes.a_joint = {
semantic: 'JOINT'
};
techniqueAttributes.a_weight = {
semantic: 'WEIGHT'
};
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';
}
var hasSpecular = hasNormals && ((lightingModel === 'BLINN') || (lightingModel === 'PHONG')) &&
defined(techniqueUniforms.u_specular) && defined(techniqueUniforms.u_shininess) &&
(techniqueUniforms.u_shininess > 0.0);
// Generate lighting code blocks
var hasNonAmbientLights = false;
var hasAmbientLights = false;
var fragmentLightingBlock = '';
for (var lightName in lights) {
if (lights.hasOwnProperty(lightName)) {
var light = lights[lightName];
var lightType = light.type.toLowerCase();
var lightBaseName = light.baseName;
fragmentLightingBlock += ' {\n';
var lightColorName = 'u_' + lightBaseName + 'Color';
var varyingDirectionName;
var varyingPositionName;
if (lightType === 'ambient') {
hasAmbientLights = true;
fragmentLightingBlock += ' ambientLight += ' + lightColorName + ';\n';
} else if (hasNormals) {
hasNonAmbientLights = true;
varyingDirectionName = 'v_' + lightBaseName + 'Direction';
varyingPositionName = 'v_' + lightBaseName + 'Position';
if (lightType !== 'point') {
vertexShader += 'varying vec3 ' + varyingDirectionName + ';\n';
fragmentShader += 'varying vec3 ' + varyingDirectionName + ';\n';
vertexShaderMain += ' ' + varyingDirectionName + ' = mat3(u_' + lightBaseName + 'Transform) * vec3(0.,0.,1.);\n';
if (lightType === 'directional') {
fragmentLightingBlock += ' vec3 l = normalize(' + varyingDirectionName + ');\n';
}
}
if (lightType !== 'directional') {
vertexShader += 'varying vec3 ' + varyingPositionName + ';\n';
fragmentShader += 'varying vec3 ' + varyingPositionName + ';\n';
vertexShaderMain += ' ' + varyingPositionName + ' = u_' + lightBaseName + 'Transform[3].xyz;\n';
fragmentLightingBlock += ' vec3 VP = ' + varyingPositionName + ' - v_positionEC;\n';
fragmentLightingBlock += ' vec3 l = normalize(VP);\n';
fragmentLightingBlock += ' float range = length(VP);\n';
fragmentLightingBlock += ' float attenuation = 1.0 / (u_' + lightBaseName + 'Attenuation.x + ';
fragmentLightingBlock += '(u_' + lightBaseName + 'Attenuation.y * range) + ';
fragmentLightingBlock += '(u_' + lightBaseName + 'Attenuation.z * range * range));\n';
} else {
fragmentLightingBlock += ' float attenuation = 1.0;\n';
}
if (lightType === 'spot') {
fragmentLightingBlock += ' float spotDot = dot(l, normalize(' + varyingDirectionName + '));\n';
fragmentLightingBlock += ' if (spotDot < cos(u_' + lightBaseName + 'FallOff.x * 0.5))\n';
fragmentLightingBlock += ' {\n';
fragmentLightingBlock += ' attenuation = 0.0;\n';
fragmentLightingBlock += ' }\n';
fragmentLightingBlock += ' else\n';
fragmentLightingBlock += ' {\n';
fragmentLightingBlock += ' attenuation *= max(0.0, pow(spotDot, u_' + lightBaseName + 'FallOff.y));\n';
fragmentLightingBlock += ' }\n';
}
fragmentLightingBlock += ' diffuseLight += ' + lightColorName + '* max(dot(normal,l), 0.) * attenuation;\n';
if (hasSpecular) {
if (lightingModel === 'BLINN') {
fragmentLightingBlock += ' vec3 h = normalize(l + viewDir);\n';
fragmentLightingBlock += ' float specularIntensity = max(0., pow(max(dot(normal, h), 0.), u_shininess)) * attenuation;\n';
} else { // PHONG
fragmentLightingBlock += ' vec3 reflectDir = reflect(-l, normal);\n';
fragmentLightingBlock += ' float specularIntensity = max(0., pow(max(dot(reflectDir, viewDir), 0.), u_shininess)) * attenuation;\n';
}
fragmentLightingBlock += ' specularLight += ' + lightColorName + ' * specularIntensity;\n';
}
}
fragmentLightingBlock += ' }\n';
}
}
if (!hasAmbientLights) {
// Add an ambient light if we don't have one
fragmentLightingBlock += ' ambientLight += vec3(0.2, 0.2, 0.2);\n';
}
if (!hasNonAmbientLights && (lightingModel !== 'CONSTANT')) {
fragmentShader += '#ifdef USE_CUSTOM_LIGHT_COLOR \n';
fragmentShader += 'uniform vec3 gltf_lightColor; \n';
fragmentShader += '#endif \n';
fragmentLightingBlock += '#ifndef USE_CUSTOM_LIGHT_COLOR \n';
fragmentLightingBlock += ' vec3 lightColor = czm_lightColor;\n';
fragmentLightingBlock += '#else \n';
fragmentLightingBlock += ' vec3 lightColor = gltf_lightColor;\n';
fragmentLightingBlock += '#endif \n';
fragmentLightingBlock += ' vec3 l = normalize(czm_lightDirectionEC);\n';
var minimumLighting = '0.2'; // Use strings instead of values as 0.0 -> 0 when stringified
fragmentLightingBlock += ' diffuseLight += lightColor * max(dot(normal,l), ' + minimumLighting + ');\n';
if (hasSpecular) {
if (lightingModel === 'BLINN') {
fragmentLightingBlock += ' vec3 h = normalize(l + viewDir);\n';
fragmentLightingBlock += ' float specularIntensity = max(0., pow(max(dot(normal, h), 0.), u_shininess));\n';
} else { // PHONG
fragmentLightingBlock += ' vec3 reflectDir = reflect(-l, normal);\n';
fragmentLightingBlock += ' float specularIntensity = max(0., pow(max(dot(reflectDir, viewDir), 0.), u_shininess));\n';
}
fragmentLightingBlock += ' specularLight += lightColor * specularIntensity;\n';
}
}
vertexShader += 'void main(void) {\n';
vertexShader += vertexShaderMain;
vertexShader += '}\n';
fragmentShader += 'void main(void) {\n';
var colorCreationBlock = ' vec3 color = vec3(0.0, 0.0, 0.0);\n';
if (hasNormals) {
fragmentShader += ' vec3 normal = normalize(v_normal);\n';
if (khrMaterialsCommon.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 += ' normal = -normal;\n';
fragmentShader += ' }\n';
}
}
var finalColorComputation;
if (lightingModel !== 'CONSTANT') {
if (defined(techniqueUniforms.u_diffuse)) {
if (techniqueUniforms.u_diffuse.type === WebGLConstants.SAMPLER_2D) {
fragmentShader += ' vec4 diffuse = texture2D(u_diffuse, ' + v_texcoord + ');\n';
} else {
fragmentShader += ' vec4 diffuse = u_diffuse;\n';
}
fragmentShader += ' vec3 diffuseLight = vec3(0.0, 0.0, 0.0);\n';
colorCreationBlock += ' color += diffuse.rgb * diffuseLight;\n';
}
if (hasSpecular) {
if (techniqueUniforms.u_specular.type === WebGLConstants.SAMPLER_2D) {
fragmentShader += ' vec3 specular = texture2D(u_specular, ' + v_texcoord + ').rgb;\n';
} else {
fragmentShader += ' vec3 specular = u_specular.rgb;\n';
}
fragmentShader += ' vec3 specularLight = vec3(0.0, 0.0, 0.0);\n';
colorCreationBlock += ' color += specular * specularLight;\n';
}
if (defined(techniqueUniforms.u_transparency)) {
finalColorComputation = ' gl_FragColor = vec4(color * diffuse.a * u_transparency, diffuse.a * u_transparency);\n';
} else {
finalColorComputation = ' gl_FragColor = vec4(color * diffuse.a, diffuse.a);\n';
}
} else if (defined(techniqueUniforms.u_transparency)) {
finalColorComputation = ' gl_FragColor = vec4(color * u_transparency, u_transparency);\n';
} else {
finalColorComputation = ' gl_FragColor = vec4(color, 1.0);\n';
}
if (hasVertexColors) {
colorCreationBlock += ' color *= v_vertexColor.rgb;\n';
}
if (defined(techniqueUniforms.u_emission)) {
if (techniqueUniforms.u_emission.type === WebGLConstants.SAMPLER_2D) {
fragmentShader += ' vec3 emission = texture2D(u_emission, ' + v_texcoord + ').rgb;\n';
} else {
fragmentShader += ' vec3 emission = u_emission.rgb;\n';
}
colorCreationBlock += ' color += emission;\n';
}
if (defined(techniqueUniforms.u_ambient) || (lightingModel !== 'CONSTANT')) {
if (defined(techniqueUniforms.u_ambient)) {
if (techniqueUniforms.u_ambient.type === WebGLConstants.SAMPLER_2D) {
fragmentShader += ' vec3 ambient = texture2D(u_ambient, ' + v_texcoord + ').rgb;\n';
} else {
fragmentShader += ' vec3 ambient = u_ambient.rgb;\n';
}
} else {
fragmentShader += ' vec3 ambient = diffuse.rgb;\n';
}
colorCreationBlock += ' color += ambient * ambientLight;\n';
}
fragmentShader += ' vec3 viewDir = -normalize(v_positionEC);\n';
fragmentShader += ' vec3 ambientLight = vec3(0.0, 0.0, 0.0);\n';
// Add in light computations
fragmentShader += fragmentLightingBlock;
fragmentShader += colorCreationBlock;
fragmentShader += finalColorComputation;
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 getKHRMaterialsCommonValueType(paramName, paramValue) {
var value;
// Backwards compatibility for COLLADA2GLTF v1.0-draft when it encoding
// materials using KHR_materials_common with explicit type/value members
if (defined(paramValue.value)) {
value = paramValue.value;
} else if (defined(paramValue.index)) {
value = [paramValue.index];
} else {
value = paramValue;
}
switch (paramName) {
case 'ambient':
return value.length === 1 ? WebGLConstants.SAMPLER_2D : WebGLConstants.FLOAT_VEC4;
case 'diffuse':
return value.length === 1 ? WebGLConstants.SAMPLER_2D : WebGLConstants.FLOAT_VEC4;
case 'emission':
return value.length === 1 ? WebGLConstants.SAMPLER_2D : WebGLConstants.FLOAT_VEC4;
case 'specular':
return value.length === 1 ? WebGLConstants.SAMPLER_2D : WebGLConstants.FLOAT_VEC4;
case 'shininess':
return WebGLConstants.FLOAT;
case 'transparency':
return WebGLConstants.FLOAT;
// these two are usually not used directly within shaders,
// they are just added here for completeness
case 'transparent':
return WebGLConstants.BOOL;
case 'doubleSided':
return WebGLConstants.BOOL;
}
}
function getTechniqueKey(khrMaterialsCommon, primitiveInfo) {
var techniqueKey = '';
techniqueKey += 'technique:' + khrMaterialsCommon.technique + ';';
var values = khrMaterialsCommon.values;
var keys = Object.keys(values).sort();
var keysCount = keys.length;
for (var i = 0; i < keysCount; ++i) {
var name = keys[i];
if (values.hasOwnProperty(name)) {
techniqueKey += name + ':' + getKHRMaterialsCommonValueType(name, values[name]);
techniqueKey += ';';
}
}
var jointCount = defaultValue(khrMaterialsCommon.jointCount, 0);
techniqueKey += jointCount.toString() + ';';
if (defined(primitiveInfo)) {
var skinningInfo = primitiveInfo.skinning;
if (jointCount > 0) {
techniqueKey += skinningInfo.type + ';';
}
techniqueKey += primitiveInfo.hasVertexColors;
}
return techniqueKey;
}
function lightDefaults(gltf) {
var khrMaterialsCommon = gltf.extensions.KHR_materials_common;
if (!defined(khrMaterialsCommon) || !defined(khrMaterialsCommon.lights)) {
return;
}
var lights = khrMaterialsCommon.lights;
var lightsLength = lights.length;
for (var lightId = 0; lightId < lightsLength; lightId++) {
var light = lights[lightId];
if (light.type === 'ambient') {
if (!defined(light.ambient)) {
light.ambient = {};
}
var ambientLight = light.ambient;
if (!defined(ambientLight.color)) {
ambientLight.color = [1.0, 1.0, 1.0];
}
} else if (light.type === 'directional') {
if (!defined(light.directional)) {
light.directional = {};
}
var directionalLight = light.directional;
if (!defined(directionalLight.color)) {
directionalLight.color = [1.0, 1.0, 1.0];
}
} else if (light.type === 'point') {
if (!defined(light.point)) {
light.point = {};
}
var pointLight = light.point;
if (!defined(pointLight.color)) {
pointLight.color = [1.0, 1.0, 1.0];
}
pointLight.constantAttenuation = defaultValue(pointLight.constantAttenuation, 1.0);
pointLight.linearAttenuation = defaultValue(pointLight.linearAttenuation, 0.0);
pointLight.quadraticAttenuation = defaultValue(pointLight.quadraticAttenuation, 0.0);
} else if (light.type === 'spot') {
if (!defined(light.spot)) {
light.spot = {};
}
var spotLight = light.spot;
if (!defined(spotLight.color)) {
spotLight.color = [1.0, 1.0, 1.0];
}
spotLight.constantAttenuation = defaultValue(spotLight.constantAttenuation, 1.0);
spotLight.fallOffAngle = defaultValue(spotLight.fallOffAngle, 3.14159265);
spotLight.fallOffExponent = defaultValue(spotLight.fallOffExponent, 0.0);
spotLight.linearAttenuation = defaultValue(spotLight.linearAttenuation, 0.0);
spotLight.quadraticAttenuation = defaultValue(spotLight.quadraticAttenuation, 0.0);
}
}
}
export default processModelMaterialsCommon;