This file is indexed.

/usr/include/osgEarth/FadeEffect is in libosgearth-dev 2.5.0+dfsg-2+b2.

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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
/* -*-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_FADE_EFFECT_H
#define OSGEARTH_FADE_EFFECT_H 1

#include <osgEarth/Common>
#include <osgEarth/Config>
#include <osgEarth/ThreadingUtils>
#include <osg/Group>
#include <osg/Uniform>

namespace osgEarth
{
    /**
     * Options for geometry fading properties.
     */
    class OSGEARTH_EXPORT FadeOptions
    {
    public:
        /** Construct new default fade options */
        FadeOptions(const Config& conf =Config());

        /** Time to fade in a new graph (seconds) */
        optional<float>& duration() { return _duration; }
        const optional<float>& duration() const { return _duration; }

        /** Range at which geometry becomes invisible (m) */
        optional<float>& maxRange() { return _maxRange; }
        const optional<float>& maxRange() const { return _maxRange; }

        /** Distance over which to fade out geometry (from max range) */
        optional<float>& attentuationDistance() { return _attenDist; }
        const optional<float>& attenuationDistance() const { return _attenDist; }

    public:
        virtual ~FadeOptions() { }
        Config getConfig() const;

    private:
        optional<float> _duration;
        optional<float> _maxRange;
        optional<float> _attenDist;
    };


    /**
     * Decorator node that will only display it's children when the camera is within a given elevation range
     */
    class OSGEARTH_EXPORT FadeEffect : public osg::Group
    {
    public:
        /**
         * Creates a uniform that set the start time for a timed fade. Typically you
         * will set this right after adding the node to the scene graph. The value
         * is a FLOAT in seconds. You can apply this uniform to the FadeEffect node
         * or elsewhere in the scene graph.
         */
        static osg::Uniform* createStartTimeUniform();

    public:
        FadeEffect();
        virtual ~FadeEffect() { }

        /** Time over which to fade in the subgraph */
        void setFadeDuration( float seconds );
        float getFadeDuration() const;

        /** Camera range at which subgraph is completely faded out */
        void setMaxRange( float range );
        float getMaxRange() const;

        /** Distance over which to fade out the subgraph */
        void setAttenuationDistance( float dist );
        float getAttenuationDistance() const;

    private:
        osg::ref_ptr<osg::Uniform> _fadeDuration;
        osg::ref_ptr<osg::Uniform> _maxRange;
        osg::ref_ptr<osg::Uniform> _attenDist;
    };


    class OSGEARTH_EXPORT FadeLOD : public osg::Group
    {
    public:
        FadeLOD();
        virtual ~FadeLOD() { }

        void setMinPixelExtent( float value ) { _minPixelExtent = value; }
        float getMinPixelExtent() const { return _minPixelExtent; }

        void setMaxPixelExtent( float value ) { _maxPixelExtent = value; }
        float getMaxPixelExtent() const { return _maxPixelExtent; }

        void setMinFadeExtent( float value ) { _minFadeExtent = value; }
        float getMinFadeExtent() const { return _minFadeExtent; }

        void setMaxFadeExtent( float value ) { _maxFadeExtent = value; }
        float getMaxFadeExtent() const { return _maxFadeExtent; }

    public: // osg::Node

        virtual void traverse(osg::NodeVisitor& nv );

    protected:
        struct PerViewData
        {
            osg::ref_ptr<osg::StateSet> _stateSet;
            osg::ref_ptr<osg::Uniform>  _opacity;
        };
        Threading::PerObjectMap<osg::NodeVisitor*, PerViewData> _perViewData;

        float _minPixelExtent;
        float _maxPixelExtent;
        float _minFadeExtent;
        float _maxFadeExtent;
    };

} // namespace osgEarth

#endif // OSGEARTH_FADE_EFFECT_H