libosgearth-dev 2.9.0+dfsg-1 / usr / include / osgEarth / TerrainResources

This file is indexed.

/usr/include/osgEarth/TerrainResources is in libosgearth-dev 2.9.0+dfsg-1.

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 2016 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_TEXTURE_COMPOSITOR_H
#define OSGEARTH_TEXTURE_COMPOSITOR_H 1

#include <osgEarth/Common>
#include <osgEarth/ThreadingUtils>
#include <osg/observer_ptr>

namespace osgEarth
{
    class Layer;
    class TextureImageUnitReservation;

    /**
     * Utility class that manages GPU resources for a terrain engine
     */
    class OSGEARTH_EXPORT TerrainResources : public osg::Referenced
    {
    public:
        /**
         * Constructs a new resource tracker object.
         */
        TerrainResources();

        /** dtor */
        virtual ~TerrainResources() { }

        /**
         * Requests a texture image unit that is not in use, and marks is as reserved.
         * You must release the reserved texture image unit by calling releaseTextureImageUnit().
         * @param out_unit  Reserved unit is written to this variable.
         * @param requestor Optional requestor string (for information purposes only)
         */
        bool reserveTextureImageUnit(
            int&        out_unit,
            const char* requestor =0L );

        /**
         * Requests a texture image unit that is not in use, and marks is as reserved
         * for the specified Layer. The unit will still be available for reservation
         * by other layers (but not globally).
         * You must release the reserved texture image unit by calling releaseTextureImageUnit().
         * @param out_unit  Reserved unit is written to this variable.
         * @param requestor Optional requestor string (for information purposes only)
         */
        bool reserveTextureImageUnit(
            int& out_unit,
            const Layer* layer,
            const char* requestor =0L);
        
        /**
         * Requests a texture image unit that is not in use, and marks is as reserved.
         * The reserveration is released when the "reservation" object goes out of
         * scope and destructs.
         * @param reservation Reserved unit is written to this variable.
         * @param requestor   Optional requestor string (for information purposes only)
         */
        bool reserveTextureImageUnit(
            TextureImageUnitReservation& reservation,
            const char* requestor =0L);
        
        /**
         * Requests a texture image unit that is not in use, and marks is as reserved
         * for the specific Layer. The unit will still be available for other layers
         * (but not globally).
         * The reserveration is released when the "reservation" object goes out of
         * scope and destructs.
         * @param reservation Reserved unit is written to this variable.
         * @param requestor   Optional requestor string (for information purposes only)
         */
        bool reserveTextureImageUnitForLayer(
            TextureImageUnitReservation& reservation,
            const Layer* layer,
            const char* requestor =0L);

        /**
         * Releases a reserved texture image unit previously returned by reserveTextureImageUnit.
         */
        void releaseTextureImageUnit(int unit);

        /**
         * Releases a reserved texture image unit previously reserved by calling
         * reserveTextureImageUnit(int, Layer). 
         */
        void releaseTextureImageUnit(int unit, const Layer* layer);

        /**
         * Marks a specific texture image as reserved. Only call this if your application
         * is known to use a particular texture image unit and you don't want osgEarth
         * touching it.
         *
         * Returns true upon success, and false if the unit has already been reserved.
         */
        bool setTextureImageUnitOffLimits(int unit);

    private:
        Threading::Mutex _reservedUnitsMutex;

        typedef std::set<int> ReservedUnits;
        ReservedUnits _globallyReservedUnits;

        typedef std::map<const Layer*, ReservedUnits> PerLayerReservedUnits;
        PerLayerReservedUnits _perLayerReservedUnits;
    };

    class OSGEARTH_EXPORT TextureImageUnitReservation
    {
    public:
        TextureImageUnitReservation();
        virtual ~TextureImageUnitReservation();
        int unit() const { return _unit; }
        bool valid() const { return _unit >= 0; }
    private:
        int _unit;
        osg::observer_ptr<TerrainResources> _res;
        const Layer* _layer; // only need the raw ptr.
        friend class TerrainResources;
    };
}

#endif // OSGEARTH_TEXTURE_COMPOSITOR_H

APT Browse - Built by Thomas Orozco.