libosgearth-dev 2.7.0+dfsg-2+b3 / usr / include / osgEarth / StateSetCache

This file is indexed.

/usr/include/osgEarth/StateSetCache is in libosgearth-dev 2.7.0+dfsg-2+b3.

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
139
140
141
142
143
144
145
146
147
148
149
150
151
/* -*-c++-*- */
/* osgEarth - Dynamic map generation toolkit for OpenSceneGraph
* Copyright 2015 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.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*
* 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_STATE_SET_CACHE_H
#define OSGEARTH_STATE_SET_CACHE_H 1

#include <osgEarth/Common>
#include <osgEarth/ThreadingUtils>
#include <osg/StateSet>
#include <set>

namespace osgEarth
{
    /**
     * Cache for optimizing state set sharing.
     */
    class OSGEARTH_EXPORT StateSetCache : public osg::Referenced
    {
    public:
        /**
         * Constructs a new cache.
         */
        StateSetCache();

        /**
         * Caps the size of the cache.
         */
        void setMaxSize(unsigned maxSize);

        /**
         * Check whether a StateSet is eligible for sharing.
         */
        bool eligible( osg::StateSet* stateSet ) const;

        /**
         * Check whether a StateAttribute is eligible for sharing.
         */
        bool eligible( osg::StateAttribute* attr ) const;

        /** 
         * Scans a graph and combines equivalents state attributes into
         * single shared attribute. Skips any attribute (or stateset)
         * with dynamic data variance
         */
        void consolidateStateAttributes(osg::Node* node);

        /**
         * Scans a graph and combines equivalent statesets into a single
         * shared stateset. Skips any stateset with dynamic data variance.
         */
        void consolidateStateSets(osg::Node* node);

        /**
         * Calls consolidateStateAttributes followed by consolidateStateSets.
         */
        void optimize(osg::Node* node);

        /**
         * Looks in the cache for a stateset matching the input. If found,
         * returns the cached one in output. If not found, stores the input 
         * in the cache and returns the same one in output.
         *
         * Must use ref_ptrs for thread safely
         */
        bool share( 
            osg::ref_ptr<osg::StateSet>& input, 
            osg::ref_ptr<osg::StateSet>& output,
            bool                         checkEligible =true );

        /**
         * Looks in the attribute cache for an attribute matching the input.
         * If found, returns the cached one in output. If not found, stores
         * the input in the cache and returns the same one in output.
         *
         * Must use ref_ptrs for thread safely
         */
        bool share(
            osg::ref_ptr<osg::StateAttribute>& input,
            osg::ref_ptr<osg::StateAttribute>& output,
            bool                               checkEligible =true );

        /**
         * Number of statesets in the cache.
         */
        unsigned size() const { return _stateSetCache.size(); }

        /**
         * Clears out the cache.
         */
        void clear();

        void dumpStats();

    protected: 

        virtual ~StateSetCache();

        struct CompareStateSets {
            bool operator()(
                const osg::ref_ptr<osg::StateSet>& lhs,
                const osg::ref_ptr<osg::StateSet>& rhs) const {
                    return lhs->compare(*(rhs.get()), true) < 0;
            }
        };
        typedef std::set< osg::ref_ptr<osg::StateSet>, CompareStateSets> StateSetSet;
        StateSetSet _stateSetCache;

        struct CompareStateAttributes {
            bool operator()(
                const osg::ref_ptr<osg::StateAttribute>& lhs,
                const osg::ref_ptr<osg::StateAttribute>& rhs) const {
                    return lhs->compare(*rhs.get()) < 0;
            }
        };
        typedef std::set< osg::ref_ptr<osg::StateAttribute>, CompareStateAttributes> StateAttributeSet;
        StateAttributeSet _stateAttributeCache;

        mutable Threading::Mutex _mutex;

        void prune();
        void pruneIfNecessary();
        unsigned _maxSize;
        unsigned _pruneCount;

        //stats
        unsigned _attrShareAttempts;
        unsigned _attrsIneligible;
        unsigned _attrShareHits;
        unsigned _attrShareMisses;
    };
}

#endif // OSGEARTH_STATE_SET_CACHE_H

APT Browse - Built by Thomas Orozco.