This file is indexed.

/usr/include/osgEarth/ShaderFactory is in libosgearth-dev 2.5.0+dfsg-8build1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
/* -*-c++-*- */
/* osgEarth - Dynamic map generation toolkit for OpenSceneGraph
* Copyright 2008-2013 Pelican Mapping
* http://osgearth.org
*
* osgEarth is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program.  If not, see <http://www.gnu.org/licenses/>
*/
#ifndef OSGEARTH_SHADER_FACTORY_H
#define OSGEARTH_SHADER_FACTORY_H 1

#include <osgEarth/Common>
#include <osgEarth/VirtualProgram>

namespace osgEarth
{
    /**
     * A factory object that generates shader program "scaffolding" for VirtualProgram
     * attributes. Ths factory generates main() functions for each stage in the shader
     * pipline. You don't use it directly; instead you just create VirtualProgram
     * attributes, and those VPs will automatically invoke this factory object to
     * generate their main() functions.
     *
     * The default ShaderFactory is stored in the osgEarth registry. You can replace it,
     * but this is advanced usage and rarely necessary. If you think you need to alter
     * the built-in mains, consider whether you can accomplish your goal by using a
     * VirtualProgram instead!
     *
     * The only exception, currently, is if you are looking to replace the built-in
     * lighting shaders. However we intend to decouple this functionality in the 
     * future and remove the installLightingShaders() method from the ShaderFactory.
     */
    class OSGEARTH_EXPORT ShaderFactory : public osg::Referenced
    {
    public:
        /**
         * Creates a vertex shader main() function for use with VirtualPrograms.
         * Do not call this function directly; VirtualProgram will call it to
         * install its main() vertex function.
         */
        virtual osg::Shader* createVertexShaderMain(
            const ShaderComp::FunctionLocationMap& functions) const;
        
        /**
         * Creates a fragment shader main() function for use with VirtualPrograms.
         * Do not call this function directly; VirtualProgram will call it to
         * install its main() fragment function.
         */
        virtual osg::Shader* createFragmentShaderMain(
            const ShaderComp::FunctionLocationMap& functions) const;

        /**
         * Gets the uniform/shader name of the sampler corresponding the the provider
         * texture image unit
         *
         * @deprecated Only supported by older texture compositors, which will likely
         *             go away in a future version
         */
        virtual std::string getSamplerName( unsigned texImageUnit ) const;

        /**
         * Install lighting shaders in a VirtualProgram.
         *
         * Note: this will likely go away in a future version. At this point it makes
         * more sense to decouple the default lighting shaders from the main shader
         * factory and simply use a VirtualProgram rather than replacing the ShaderFactory.
         */
        virtual void installLightingShaders(VirtualProgram* vp) const;

        /**
         * Builds a shader function that executes an image filter chain.
         * @param functionName Name to give to the resulting shader function
         * @param chain        Color filter chain to execute
         */
        virtual osg::Shader* createColorFilterChainFragmentShader(
            const std::string&      functionName,
            const ColorFilterChain& chain ) const;

        /**
         * Gets a uniform corresponding to the given mode and value. These uniforms are 
         * named in the form "oe_mode_MODE" (e.g., "oe_mode_GL_LIGHTING").
         */
        virtual osg::Uniform* createUniformForGLMode(
            osg::StateAttribute::GLMode      mode,
            osg::StateAttribute::GLModeValue value ) const;

        /** dtor */
        virtual ~ShaderFactory() { }
    };


} // namespace osgEarth

#endif // OSGEARTH_SHADER_FACTORY_H