cesium/Source/Scene/DerivedCommand.js

CesiumJS is a JavaScript library for creating 3D globes and 2D maps in a web browser without a plugin.

import defined from '../Core/defined.js';
import DrawCommand from '../Renderer/DrawCommand.js';
import RenderState from '../Renderer/RenderState.js';
import ShaderSource from '../Renderer/ShaderSource.js';

    /**
     * @private
     */
    function DerivedCommand() {}

    var fragDepthRegex = /\bgl_FragDepthEXT\b/;
    var discardRegex = /\bdiscard\b/;

    function getDepthOnlyShaderProgram(context, shaderProgram) {
        var shader = context.shaderCache.getDerivedShaderProgram(shaderProgram, 'depthOnly');
        if (!defined(shader)) {
            var attributeLocations = shaderProgram._attributeLocations;
            var fs = shaderProgram.fragmentShaderSource;

            var i;
            var writesDepthOrDiscards = false;
            var sources = fs.sources;
            var length = sources.length;
            for (i = 0; i < length; ++i) {
                if (fragDepthRegex.test(sources[i]) || discardRegex.test(sources[i])) {
                    writesDepthOrDiscards = true;
                    break;
                }
            }

            var usesLogDepth = false;
            var defines = fs.defines;
            length = defines.length;
            for (i = 0; i < length; ++i) {
                if (defines[i] === 'LOG_DEPTH') {
                    usesLogDepth = true;
                    break;
                }
            }

            var source;
            if (!writesDepthOrDiscards && !usesLogDepth) {
                source =
                    'void main() \n' +
                    '{ \n' +
                    '    gl_FragColor = vec4(1.0); \n' +
                    '} \n';
                fs = new ShaderSource({
                    sources : [source]
                });
            } else if (!writesDepthOrDiscards && usesLogDepth) {
                source =
                    '#ifdef GL_EXT_frag_depth \n' +
                    '#extension GL_EXT_frag_depth : enable \n' +
                    '#endif \n\n' +
                    'void main() \n' +
                    '{ \n' +
                    '    gl_FragColor = vec4(1.0); \n' +
                    '    czm_writeLogDepth(); \n' +
                    '} \n';
                fs = new ShaderSource({
                    defines : ['LOG_DEPTH'],
                    sources : [source]
                });
            }

            shader = context.shaderCache.createDerivedShaderProgram(shaderProgram, 'depthOnly', {
                vertexShaderSource : shaderProgram.vertexShaderSource,
                fragmentShaderSource : fs,
                attributeLocations : attributeLocations
            });
        }

        return shader;
    }

    function getDepthOnlyRenderState(scene, renderState) {
        var cache = scene._depthOnlyRenderStateCache;
        var depthOnlyState = cache[renderState.id];
        if (!defined(depthOnlyState)) {
            var rs = RenderState.getState(renderState);
            rs.depthMask = true;
            rs.colorMask = {
                red : false,
                green : false,
                blue : false,
                alpha : false
            };

            depthOnlyState = RenderState.fromCache(rs);
            cache[renderState.id] = depthOnlyState;
        }

        return depthOnlyState;
    }

    DerivedCommand.createDepthOnlyDerivedCommand = function(scene, command, context, result) {
        // For a depth only pass, we bind a framebuffer with only a depth attachment (no color attachments),
        // do not write color, and write depth. If the fragment shader doesn't modify the fragment depth
        // or discard, the driver can replace the fragment shader with a pass-through shader. We're unsure if this
        // actually happens so we modify the shader to use a pass-through fragment shader.

        if (!defined(result)) {
            result = {};
        }

        var shader;
        var renderState;
        if (defined(result.depthOnlyCommand)) {
            shader = result.depthOnlyCommand.shaderProgram;
            renderState = result.depthOnlyCommand.renderState;
        }

        result.depthOnlyCommand = DrawCommand.shallowClone(command, result.depthOnlyCommand);

        if (!defined(shader) || result.shaderProgramId !== command.shaderProgram.id) {
            result.depthOnlyCommand.shaderProgram = getDepthOnlyShaderProgram(context, command.shaderProgram);
            result.depthOnlyCommand.renderState = getDepthOnlyRenderState(scene, command.renderState);
            result.shaderProgramId = command.shaderProgram.id;
        } else {
            result.depthOnlyCommand.shaderProgram = shader;
            result.depthOnlyCommand.renderState = renderState;
        }

        return result;
    };

    var writeLogDepthRegex = /\s+czm_writeLogDepth\(/;
    var vertexlogDepthRegex = /\s+czm_vertexLogDepth\(/;
    var extensionRegex = /\s*#extension\s+GL_EXT_frag_depth\s*:\s*enable/;

    function getLogDepthShaderProgram(context, shaderProgram) {
        var shader = context.shaderCache.getDerivedShaderProgram(shaderProgram, 'logDepth');
        if (!defined(shader)) {
            var attributeLocations = shaderProgram._attributeLocations;
            var vs = shaderProgram.vertexShaderSource.clone();
            var fs = shaderProgram.fragmentShaderSource.clone();

            vs.defines = defined(vs.defines) ? vs.defines.slice(0) : [];
            vs.defines.push('LOG_DEPTH');
            fs.defines = defined(fs.defines) ? fs.defines.slice(0) : [];
            fs.defines.push('LOG_DEPTH');

            var i;
            var logMain;
            var writesLogDepth = false;
            var sources = vs.sources;
            var length = sources.length;
            for (i = 0; i < length; ++i) {
                if (vertexlogDepthRegex.test(sources[i])) {
                    writesLogDepth = true;
                    break;
                }
            }

            if (!writesLogDepth) {
                for (i = 0; i < length; ++i) {
                    sources[i] = ShaderSource.replaceMain(sources[i], 'czm_log_depth_main');
                }

                logMain =
                    '\n\n' +
                    'void main() \n' +
                    '{ \n' +
                    '    czm_log_depth_main(); \n' +
                    '    czm_vertexLogDepth(); \n' +
                    '} \n';
                sources.push(logMain);
            }

            var addExtension = true;
            writesLogDepth = false;
            sources = fs.sources;
            length = sources.length;
            for (i = 0; i < length; ++i) {
                if (writeLogDepthRegex.test(sources[i])) {
                    writesLogDepth = true;
                }
                if (extensionRegex.test(sources[i])) {
                    addExtension = false;
                }
            }

            var logSource = '';
            if (addExtension) {
                logSource +=
                    '#ifdef GL_EXT_frag_depth \n' +
                    '#extension GL_EXT_frag_depth : enable \n' +
                    '#endif \n\n';
            }

            if (!writesLogDepth) {
                for (i = 0; i < length; i++) {
                    sources[i] = ShaderSource.replaceMain(sources[i], 'czm_log_depth_main');
                }

                logSource +=
                    '\n' +
                    'void main() \n' +
                    '{ \n' +
                    '    czm_log_depth_main(); \n' +
                    '    czm_writeLogDepth(); \n' +
                    '} \n';
            }

            sources.push(logSource);

            shader = context.shaderCache.createDerivedShaderProgram(shaderProgram, 'logDepth', {
                vertexShaderSource : vs,
                fragmentShaderSource : fs,
                attributeLocations : attributeLocations
            });
        }

        return shader;
    }

    DerivedCommand.createLogDepthCommand = function(command, context, result) {
        if (!defined(result)) {
            result = {};
        }

        var shader;
        if (defined(result.command)) {
            shader = result.command.shaderProgram;
        }

        result.command = DrawCommand.shallowClone(command, result.command);

        if (!defined(shader) || result.shaderProgramId !== command.shaderProgram.id) {
            result.command.shaderProgram = getLogDepthShaderProgram(context, command.shaderProgram);
            result.shaderProgramId = command.shaderProgram.id;
        } else {
            result.command.shaderProgram = shader;
        }

        return result;
    };

    function getPickShaderProgram(context, shaderProgram, pickId) {
        var shader = context.shaderCache.getDerivedShaderProgram(shaderProgram, 'pick');
        if (!defined(shader)) {
            var attributeLocations = shaderProgram._attributeLocations;
            var fs = shaderProgram.fragmentShaderSource;

            var sources = fs.sources;
            var length = sources.length;

            var newMain =
                'void main() \n' +
                '{ \n' +
                '    czm_non_pick_main(); \n' +
                '    if (gl_FragColor.a == 0.0) { \n' +
                '        discard; \n' +
                '    } \n' +
                '    gl_FragColor = ' + pickId + '; \n' +
                '} \n';
            var newSources = new Array(length + 1);
            for (var i = 0; i < length; ++i) {
                newSources[i] = ShaderSource.replaceMain(sources[i], 'czm_non_pick_main');
            }
            newSources[length] = newMain;
            fs = new ShaderSource({
                sources : newSources,
                defines : fs.defines
            });
            shader = context.shaderCache.createDerivedShaderProgram(shaderProgram, 'pick', {
                vertexShaderSource : shaderProgram.vertexShaderSource,
                fragmentShaderSource : fs,
                attributeLocations : attributeLocations
            });
        }

        return shader;
    }

    function getPickRenderState(scene, renderState) {
        var cache = scene.picking.pickRenderStateCache;
        var pickState = cache[renderState.id];
        if (!defined(pickState)) {
            var rs = RenderState.getState(renderState);
            rs.blending.enabled = false;

            // Turns on depth writing for opaque and translucent passes
            // Overlapping translucent geometry on the globe surface may exhibit z-fighting
            // during the pick pass which may not match the rendered scene. Once
            // terrain is on by default and ground primitives are used instead
            // this will become less of a problem.
            rs.depthMask = true;

            pickState = RenderState.fromCache(rs);
            cache[renderState.id] = pickState;
        }

        return pickState;
    }

    DerivedCommand.createPickDerivedCommand = function(scene, command, context, result) {
        if (!defined(result)) {
            result = {};
        }

        var shader;
        var renderState;
        if (defined(result.pickCommand)) {
            shader = result.pickCommand.shaderProgram;
            renderState = result.pickCommand.renderState;
        }

        result.pickCommand = DrawCommand.shallowClone(command, result.pickCommand);

        if (!defined(shader) || result.shaderProgramId !== command.shaderProgram.id) {
            result.pickCommand.shaderProgram = getPickShaderProgram(context, command.shaderProgram, command.pickId);
            result.pickCommand.renderState = getPickRenderState(scene, command.renderState);
            result.shaderProgramId = command.shaderProgram.id;
        } else {
            result.pickCommand.shaderProgram = shader;
            result.pickCommand.renderState = renderState;
        }

        return result;
    };

    function getHdrShaderProgram(context, shaderProgram) {
        var shader = context.shaderCache.getDerivedShaderProgram(shaderProgram, 'HDR');
        if (!defined(shader)) {
            var attributeLocations = shaderProgram._attributeLocations;
            var vs = shaderProgram.vertexShaderSource.clone();
            var fs = shaderProgram.fragmentShaderSource.clone();

            vs.defines = defined(vs.defines) ? vs.defines.slice(0) : [];
            vs.defines.push('HDR');
            fs.defines = defined(fs.defines) ? fs.defines.slice(0) : [];
            fs.defines.push('HDR');

            shader = context.shaderCache.createDerivedShaderProgram(shaderProgram, 'HDR', {
                vertexShaderSource : vs,
                fragmentShaderSource : fs,
                attributeLocations : attributeLocations
            });
        }

        return shader;
    }

    DerivedCommand.createHdrCommand = function(command, context, result) {
        if (!defined(result)) {
            result = {};
        }

        var shader;
        if (defined(result.command)) {
            shader = result.command.shaderProgram;
        }

        result.command = DrawCommand.shallowClone(command, result.command);

        if (!defined(shader) || result.shaderProgramId !== command.shaderProgram.id) {
            result.command.shaderProgram = getHdrShaderProgram(context, command.shaderProgram);
            result.shaderProgramId = command.shaderProgram.id;
        } else {
            result.command.shaderProgram = shader;
        }

        return result;
    };
export default DerivedCommand;