cesium
Version:
CesiumJS is a JavaScript library for creating 3D globes and 2D maps in a web browser without a plugin.
343 lines (298 loc) • 14.4 kB
JavaScript
import defined from '../Core/defined.js';
import destroyObject from '../Core/destroyObject.js';
import TerrainQuantization from '../Core/TerrainQuantization.js';
import ShaderProgram from '../Renderer/ShaderProgram.js';
import getClippingFunction from './getClippingFunction.js';
import SceneMode from './SceneMode.js';
function GlobeSurfaceShader(numberOfDayTextures, flags, material, shaderProgram, clippingShaderState) {
this.numberOfDayTextures = numberOfDayTextures;
this.flags = flags;
this.material = material;
this.shaderProgram = shaderProgram;
this.clippingShaderState = clippingShaderState;
}
/**
* Manages the shaders used to shade the surface of a {@link Globe}.
*
* @alias GlobeSurfaceShaderSet
* @private
*/
function GlobeSurfaceShaderSet() {
this.baseVertexShaderSource = undefined;
this.baseFragmentShaderSource = undefined;
this._shadersByTexturesFlags = [];
this.material = undefined;
}
function getPositionMode(sceneMode) {
var getPosition3DMode = 'vec4 getPosition(vec3 position, float height, vec2 textureCoordinates) { return getPosition3DMode(position, height, textureCoordinates); }';
var getPositionColumbusViewAnd2DMode = 'vec4 getPosition(vec3 position, float height, vec2 textureCoordinates) { return getPositionColumbusViewMode(position, height, textureCoordinates); }';
var getPositionMorphingMode = 'vec4 getPosition(vec3 position, float height, vec2 textureCoordinates) { return getPositionMorphingMode(position, height, textureCoordinates); }';
var positionMode;
switch (sceneMode) {
case SceneMode.SCENE3D:
positionMode = getPosition3DMode;
break;
case SceneMode.SCENE2D:
case SceneMode.COLUMBUS_VIEW:
positionMode = getPositionColumbusViewAnd2DMode;
break;
case SceneMode.MORPHING:
positionMode = getPositionMorphingMode;
break;
}
return positionMode;
}
function get2DYPositionFraction(useWebMercatorProjection) {
var get2DYPositionFractionGeographicProjection = 'float get2DYPositionFraction(vec2 textureCoordinates) { return get2DGeographicYPositionFraction(textureCoordinates); }';
var get2DYPositionFractionMercatorProjection = 'float get2DYPositionFraction(vec2 textureCoordinates) { return get2DMercatorYPositionFraction(textureCoordinates); }';
return useWebMercatorProjection ? get2DYPositionFractionMercatorProjection : get2DYPositionFractionGeographicProjection;
}
GlobeSurfaceShaderSet.prototype.getShaderProgram = function(options) {
var frameState = options.frameState;
var surfaceTile = options.surfaceTile;
var numberOfDayTextures = options.numberOfDayTextures;
var applyBrightness = options.applyBrightness;
var applyContrast = options.applyContrast;
var applyHue = options.applyHue;
var applySaturation = options.applySaturation;
var applyGamma = options.applyGamma;
var applyAlpha = options.applyAlpha;
var applySplit = options.applySplit;
var showReflectiveOcean = options.showReflectiveOcean;
var showOceanWaves = options.showOceanWaves;
var enableLighting = options.enableLighting;
var dynamicAtmosphereLighting = options.dynamicAtmosphereLighting;
var dynamicAtmosphereLightingFromSun = options.dynamicAtmosphereLightingFromSun;
var showGroundAtmosphere = options.showGroundAtmosphere;
var perFragmentGroundAtmosphere = options.perFragmentGroundAtmosphere;
var hasVertexNormals = options.hasVertexNormals;
var useWebMercatorProjection = options.useWebMercatorProjection;
var enableFog = options.enableFog;
var enableClippingPlanes = options.enableClippingPlanes;
var clippingPlanes = options.clippingPlanes;
var clippedByBoundaries = options.clippedByBoundaries;
var hasImageryLayerCutout = options.hasImageryLayerCutout;
var colorCorrect = options.colorCorrect;
var highlightFillTile = options.highlightFillTile;
var colorToAlpha = options.colorToAlpha;
var quantization = 0;
var quantizationDefine = '';
var mesh = surfaceTile.renderedMesh;
var terrainEncoding = mesh.encoding;
var quantizationMode = terrainEncoding.quantization;
if (quantizationMode === TerrainQuantization.BITS12) {
quantization = 1;
quantizationDefine = 'QUANTIZATION_BITS12';
}
var cartographicLimitRectangleFlag = 0;
var cartographicLimitRectangleDefine = '';
if (clippedByBoundaries) {
cartographicLimitRectangleFlag = 1;
cartographicLimitRectangleDefine = 'TILE_LIMIT_RECTANGLE';
}
var imageryCutoutFlag = 0;
var imageryCutoutDefine = '';
if (hasImageryLayerCutout) {
imageryCutoutFlag = 1;
imageryCutoutDefine = 'APPLY_IMAGERY_CUTOUT';
}
var sceneMode = frameState.mode;
var flags = sceneMode |
(applyBrightness << 2) |
(applyContrast << 3) |
(applyHue << 4) |
(applySaturation << 5) |
(applyGamma << 6) |
(applyAlpha << 7) |
(showReflectiveOcean << 8) |
(showOceanWaves << 9) |
(enableLighting << 10) |
(dynamicAtmosphereLighting << 11) |
(dynamicAtmosphereLightingFromSun << 12) |
(showGroundAtmosphere << 13) |
(perFragmentGroundAtmosphere << 14) |
(hasVertexNormals << 15) |
(useWebMercatorProjection << 16) |
(enableFog << 17) |
(quantization << 18) |
(applySplit << 19) |
(enableClippingPlanes << 20) |
(cartographicLimitRectangleFlag << 21) |
(imageryCutoutFlag << 22) |
(colorCorrect << 23) |
(highlightFillTile << 24) |
(colorToAlpha << 25);
var currentClippingShaderState = 0;
if (defined(clippingPlanes) && clippingPlanes.length > 0) {
currentClippingShaderState = enableClippingPlanes ? clippingPlanes.clippingPlanesState : 0;
}
var surfaceShader = surfaceTile.surfaceShader;
if (defined(surfaceShader) &&
surfaceShader.numberOfDayTextures === numberOfDayTextures &&
surfaceShader.flags === flags &&
surfaceShader.material === this.material &&
surfaceShader.clippingShaderState === currentClippingShaderState) {
return surfaceShader.shaderProgram;
}
// New tile, or tile changed number of textures, flags, or clipping planes
var shadersByFlags = this._shadersByTexturesFlags[numberOfDayTextures];
if (!defined(shadersByFlags)) {
shadersByFlags = this._shadersByTexturesFlags[numberOfDayTextures] = [];
}
surfaceShader = shadersByFlags[flags];
if (!defined(surfaceShader) || surfaceShader.material !== this.material || surfaceShader.clippingShaderState !== currentClippingShaderState) {
// Cache miss - we've never seen this combination of numberOfDayTextures and flags before.
var vs = this.baseVertexShaderSource.clone();
var fs = this.baseFragmentShaderSource.clone();
if (currentClippingShaderState !== 0) {
fs.sources.unshift(getClippingFunction(clippingPlanes, frameState.context)); // Need to go before GlobeFS
}
vs.defines.push(quantizationDefine);
fs.defines.push('TEXTURE_UNITS ' + numberOfDayTextures, cartographicLimitRectangleDefine, imageryCutoutDefine);
if (applyBrightness) {
fs.defines.push('APPLY_BRIGHTNESS');
}
if (applyContrast) {
fs.defines.push('APPLY_CONTRAST');
}
if (applyHue) {
fs.defines.push('APPLY_HUE');
}
if (applySaturation) {
fs.defines.push('APPLY_SATURATION');
}
if (applyGamma) {
fs.defines.push('APPLY_GAMMA');
}
if (applyAlpha) {
fs.defines.push('APPLY_ALPHA');
}
if (showReflectiveOcean) {
fs.defines.push('SHOW_REFLECTIVE_OCEAN');
vs.defines.push('SHOW_REFLECTIVE_OCEAN');
}
if (showOceanWaves) {
fs.defines.push('SHOW_OCEAN_WAVES');
}
if (colorToAlpha) {
fs.defines.push('APPLY_COLOR_TO_ALPHA');
}
if (enableLighting) {
if (hasVertexNormals) {
vs.defines.push('ENABLE_VERTEX_LIGHTING');
fs.defines.push('ENABLE_VERTEX_LIGHTING');
} else {
vs.defines.push('ENABLE_DAYNIGHT_SHADING');
fs.defines.push('ENABLE_DAYNIGHT_SHADING');
}
}
if (dynamicAtmosphereLighting) {
fs.defines.push('DYNAMIC_ATMOSPHERE_LIGHTING');
if (dynamicAtmosphereLightingFromSun) {
fs.defines.push('DYNAMIC_ATMOSPHERE_LIGHTING_FROM_SUN');
}
}
if (showGroundAtmosphere) {
vs.defines.push('GROUND_ATMOSPHERE');
fs.defines.push('GROUND_ATMOSPHERE');
if (perFragmentGroundAtmosphere) {
fs.defines.push('PER_FRAGMENT_GROUND_ATMOSPHERE');
}
}
vs.defines.push('INCLUDE_WEB_MERCATOR_Y');
fs.defines.push('INCLUDE_WEB_MERCATOR_Y');
if (enableFog) {
vs.defines.push('FOG');
fs.defines.push('FOG');
}
if (applySplit) {
fs.defines.push('APPLY_SPLIT');
}
if (enableClippingPlanes) {
fs.defines.push('ENABLE_CLIPPING_PLANES');
}
if (colorCorrect) {
fs.defines.push('COLOR_CORRECT');
}
if (highlightFillTile) {
fs.defines.push('HIGHLIGHT_FILL_TILE');
}
var computeDayColor = '\
vec4 computeDayColor(vec4 initialColor, vec3 textureCoordinates)\n\
{\n\
vec4 color = initialColor;\n';
if (hasImageryLayerCutout) {
computeDayColor += '\
vec4 cutoutAndColorResult;\n\
bool texelUnclipped;\n';
}
for (var i = 0; i < numberOfDayTextures; ++i) {
if (hasImageryLayerCutout) {
computeDayColor += '\
cutoutAndColorResult = u_dayTextureCutoutRectangles[' + i + '];\n\
texelUnclipped = v_textureCoordinates.x < cutoutAndColorResult.x || cutoutAndColorResult.z < v_textureCoordinates.x || v_textureCoordinates.y < cutoutAndColorResult.y || cutoutAndColorResult.w < v_textureCoordinates.y;\n\
cutoutAndColorResult = sampleAndBlend(\n';
} else {
computeDayColor += '\
color = sampleAndBlend(\n';
}
computeDayColor += '\
color,\n\
u_dayTextures[' + i + '],\n\
u_dayTextureUseWebMercatorT[' + i + '] ? textureCoordinates.xz : textureCoordinates.xy,\n\
u_dayTextureTexCoordsRectangle[' + i + '],\n\
u_dayTextureTranslationAndScale[' + i + '],\n\
' + (applyAlpha ? 'u_dayTextureAlpha[' + i + ']' : '1.0') + ',\n\
' + (applyBrightness ? 'u_dayTextureBrightness[' + i + ']' : '0.0') + ',\n\
' + (applyContrast ? 'u_dayTextureContrast[' + i + ']' : '0.0') + ',\n\
' + (applyHue ? 'u_dayTextureHue[' + i + ']' : '0.0') + ',\n\
' + (applySaturation ? 'u_dayTextureSaturation[' + i + ']' : '0.0') + ',\n\
' + (applyGamma ? 'u_dayTextureOneOverGamma[' + i + ']' : '0.0') + ',\n\
' + (applySplit ? 'u_dayTextureSplit[' + i + ']' : '0.0') + ',\n\
' + (colorToAlpha ? 'u_colorsToAlpha[' + i + ']' : 'vec4(0.0)') + '\n\
);\n';
if (hasImageryLayerCutout) {
computeDayColor += '\
color = czm_branchFreeTernary(texelUnclipped, cutoutAndColorResult, color);\n';
}
}
computeDayColor += '\
return color;\n\
}';
fs.sources.push(computeDayColor);
vs.sources.push(getPositionMode(sceneMode));
vs.sources.push(get2DYPositionFraction(useWebMercatorProjection));
var shader = ShaderProgram.fromCache({
context : frameState.context,
vertexShaderSource : vs,
fragmentShaderSource : fs,
attributeLocations : terrainEncoding.getAttributeLocations()
});
surfaceShader = shadersByFlags[flags] = new GlobeSurfaceShader(numberOfDayTextures, flags, this.material, shader, currentClippingShaderState);
}
surfaceTile.surfaceShader = surfaceShader;
return surfaceShader.shaderProgram;
};
GlobeSurfaceShaderSet.prototype.destroy = function() {
var flags;
var shader;
var shadersByTexturesFlags = this._shadersByTexturesFlags;
for (var textureCount in shadersByTexturesFlags) {
if (shadersByTexturesFlags.hasOwnProperty(textureCount)) {
var shadersByFlags = shadersByTexturesFlags[textureCount];
if (!defined(shadersByFlags)) {
continue;
}
for (flags in shadersByFlags) {
if (shadersByFlags.hasOwnProperty(flags)) {
shader = shadersByFlags[flags];
if (defined(shader)) {
shader.shaderProgram.destroy();
}
}
}
}
}
return destroyObject(this);
};
export default GlobeSurfaceShaderSet;