This file is indexed.

/usr/include/simgear/scene/tgdb/SGBuildingBin.hxx is in libsimgear-dev 3.0.0-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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
/* -*-c++-*-
 *
 * Copyright (C) 2011 Stuart Buchanan
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU 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
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 * MA 02110-1301, USA.
 *
 */

#ifndef SG_BUILDING_BIN_HXX
#define SG_BUILDING_BIN_HXX

#include <math.h>

#include <vector>
#include <string>

#include <osg/Geode>
#include <osg/Geometry>
#include <osg/Math>
#include <osg/MatrixTransform>
#include <osg/Matrix>
#include <osg/ShadeModel>
#include <osg/Material>
#include <osg/CullFace>


#include <simgear/scene/util/OsgMath.hxx>
#include <simgear/scene/material/mat.hxx>

#include <simgear/scene/util/QuadTreeBuilder.hxx>
#include <simgear/scene/util/RenderConstants.hxx>
#include <simgear/scene/util/StateAttributeFactory.hxx>
#include <simgear/structure/OSGUtils.hxx>

#define SG_BUILDING_QUAD_TREE_DEPTH 4
#define SG_BUILDING_FADE_OUT_LEVELS 4

using namespace osg;

namespace simgear
{
class SGBuildingBin {
public:

  // Number of buildings to auto-generate. Individual
  // building instances are taken from this set.
  static const unsigned int BUILDING_SET_SIZE = 200;

  static const unsigned int QUADS_PER_BUILDING = 12;
  static const unsigned int VERTICES_PER_BUILDING = 4 * QUADS_PER_BUILDING;
  static const unsigned int VERTICES_PER_BUILDING_SET = BUILDING_SET_SIZE * VERTICES_PER_BUILDING;

  enum BuildingType {
    SMALL = 0,
    MEDIUM,
    LARGE };

private:

  struct Building {
    Building(BuildingType t, float w, float d, float h, int f, bool pitch) :
      type(t),
      width(w),
      depth(d),
      height(h),
      floors(f),
      pitched(pitch),
      radius(std::max(d, 0.5f*w))
    { }

    BuildingType type;
    float width;
    float depth;
    float height;
    int floors;
    bool pitched;
    float radius;

    float getFootprint() {
      return radius;
    }
  };

  // The set of buildings that are instantiated
  typedef std::vector<Building> BuildingList;
  BuildingList smallBuildings;
  BuildingList mediumBuildings;
  BuildingList largeBuildings;

  std::string* material_name;
  std::string* texture;
  std::string* lightMap;

  // Fraction of buildings of this type
  float smallBuildingFraction;
  float mediumBuildingFraction;

  // The maximum radius of each building type
  float smallBuildingMaxRadius;
  float mediumBuildingMaxRadius;
  float largeBuildingMaxRadius;

  // The maximum depth of each building type
  float smallBuildingMaxDepth;
  float mediumBuildingMaxDepth;
  float largeBuildingMaxDepth;

  // Visibility range for buildings
  float buildingRange;

  // Shared geometries of the building set
  ref_ptr<Geometry> smallSharedGeometry;
  ref_ptr<Geometry> mediumSharedGeometry;
  ref_ptr<Geometry> largeSharedGeometry;

  struct BuildingInstance {
    BuildingInstance(SGVec3f p, float r, const BuildingList* bl, ref_ptr<Geometry> sg) :
      position(p),
      rotation(r),
      buildingList(bl),
      sharedGeometry(sg)
    { }

    BuildingInstance(SGVec3f p, BuildingInstance b) :
      position(p),
      rotation(b.rotation),
      buildingList(b.buildingList),
      sharedGeometry(b.sharedGeometry)
    { }

    SGVec3f position;
    float rotation;

    // References to allow the QuadTreeBuilder to work
    const BuildingList* buildingList;
    ref_ptr<Geometry> sharedGeometry;

    SGVec3f getPosition() { return position; }
    float getRotation() { return rotation; }

    float getDistSqr(SGVec3f p) {
      return distSqr(p, position);
    }

    const osg::Vec4f getColorValue() {
      return osg::Vec4f(toOsg(position), rotation);
    }
  };

  // Information for an instance of a building - position and orientation
  typedef std::vector<BuildingInstance> BuildingInstanceList;
  BuildingInstanceList smallBuildingLocations;
  BuildingInstanceList mediumBuildingLocations;
  BuildingInstanceList largeBuildingLocations;

public:

  SGBuildingBin(const SGMaterial *mat);

  ~SGBuildingBin() {
    smallBuildings.clear();
    mediumBuildings.clear();
    largeBuildings.clear();
    smallBuildingLocations.clear();
    mediumBuildingLocations.clear();
    largeBuildingLocations.clear();
  }

  void insert(SGVec3f p, float r, BuildingType type);
  int getNumBuildings();

  bool checkMinDist (SGVec3f p, float radius);

  std::string* getMaterialName() { return material_name; }

  BuildingType getBuildingType(float roll);

  float getBuildingMaxRadius(BuildingType);
  float getBuildingMaxDepth(BuildingType);

  // Helper classes for creating the quad tree
  struct MakeBuildingLeaf
  {
      MakeBuildingLeaf(float range, Effect* effect, bool fade) :
          _range(range), _effect(effect), _fade_out(fade) {}

      MakeBuildingLeaf(const MakeBuildingLeaf& rhs) :
          _range(rhs._range), _effect(rhs._effect), _fade_out(rhs._fade_out)
      {}

      LOD* operator() () const
      {
          LOD* result = new LOD;

          if (_fade_out) {
              // Create a series of LOD nodes so buidling cover decreases
              // gradually with distance from _range to 2*_range
              for (float i = 0.0; i < SG_BUILDING_FADE_OUT_LEVELS; i++)
              {
                  EffectGeode* geode = new EffectGeode;
                  geode->setEffect(_effect.get());
                  result->addChild(geode, 0, _range * (1.0 + i / (SG_BUILDING_FADE_OUT_LEVELS - 1.0)));
              }
          } else {
              // No fade-out, so all are visible for 2X range
              EffectGeode* geode = new EffectGeode;
              geode->setEffect(_effect.get());
              result->addChild(geode, 0, 2.0 * _range);
          }
          return result;
      }

      float _range;
      ref_ptr<Effect> _effect;
      bool _fade_out;
  };

  struct AddBuildingLeafObject
  {
      Geometry* createNewBuildingGeometryInstance(const BuildingInstance& building) const
      {
        Geometry* geom = simgear::clone(building.sharedGeometry.get(), CopyOp::SHALLOW_COPY);
        geom->setColorArray(new Vec4Array);
        geom->setColorBinding(Geometry::BIND_PER_VERTEX);
        geom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::QUADS));
        return geom;
      }

      void operator() (LOD* lod, const BuildingInstance& building) const
      {
          Geode* geode = static_cast<Geode*>(lod->getChild(int(building.position.x() * 10.0f) % lod->getNumChildren()));
          unsigned int numDrawables = geode->getNumDrawables();

          // Get the last geometry of to be added and check if there is space for
          // another building instance within it.  This is done by checking
          // if the number of Color values matches the number of vertices.
          // The color array is used to store the position of a particular
          // instance.
          Geometry* geom;

          if (numDrawables == 0) {
            // Create a new copy of the shared geometry to instantiate
            geom = createNewBuildingGeometryInstance(building);
            geode->addDrawable(geom);
          } else {
            geom = static_cast<Geometry*>(geode->getDrawable(numDrawables - 1));
          }

          // Check if this building is too close to any other others.
          DrawArrays* primSet  = static_cast<DrawArrays*>(geom->getPrimitiveSet(0));
          Vec4Array* posArray = static_cast<Vec4Array*>(geom->getColorArray());

          // Now check if this geometry is full.
          if (posArray->size() >= static_cast<Vec3Array*>(geom->getVertexArray())->size()) {
            // This particular geometry is full, so we generate another
            // by taking a shallow copy of the shared Geomety.
            geom = createNewBuildingGeometryInstance(building);
            geode->addDrawable(geom);
            posArray = static_cast<Vec4Array*>(geom->getColorArray());
            SG_LOG(SG_TERRAIN, SG_DEBUG, "Added new geometry to building geod: " << geode->getNumDrawables());
          }

          // We now have a geometry with space for this new building.
          // Set the position and rotation
          osg::Vec4f c = osg::Vec4f(toOsg(building.position), building.rotation);
          posArray->insert(posArray->end(), VERTICES_PER_BUILDING, c);
          size_t numVerts = posArray->size();
          primSet = static_cast<DrawArrays*>(geom->getPrimitiveSet(0));
          primSet->setCount(numVerts);
      }
  };

  struct GetBuildingCoord
  {
      Vec3 operator() (const BuildingInstance& building) const
      {
          return toOsg(building.position);
      }
  };

  typedef QuadTreeBuilder<LOD*, BuildingInstance, MakeBuildingLeaf, AddBuildingLeafObject,
                          GetBuildingCoord> BuildingGeometryQuadtree;

  struct BuildingInstanceTransformer
  {
      BuildingInstanceTransformer(Matrix& mat_) : mat(mat_) {}
      BuildingInstance operator()(const BuildingInstance& buildingInstance) const
      {
          Vec3 pos = toOsg(buildingInstance.position) * mat;
          return BuildingInstance(toSG(pos), buildingInstance);
      }
      Matrix mat;
  };

  ref_ptr<Group> createBuildingsGroup(Matrix transInv, const SGReaderWriterOptions* options);

};

// List of buildings
typedef std::list<SGBuildingBin*> SGBuildingBinList;


osg::Group* createRandomBuildings(SGBuildingBinList& buildinglist, const osg::Matrix& transform,
                         const SGReaderWriterOptions* options);
}
#endif