simgear/scene/tgdb/SGTexturedTriangleBin.hxx

   1 /* -*-c++-*-
   2  *
   3  * Copyright (C) 2006-2007 Mathias Froehlich
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of the
   8  * License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  18  * MA 02110-1301, USA.
  19  *
  20  */
  21
  22 #ifndef SG_TEXTURED_TRIANGLE_BIN_HXX
  23 #define SG_TEXTURED_TRIANGLE_BIN_HXX
  24
  25 #include <osg/Array>
  26 #include <osg/Geometry>
  27 #include <osg/PrimitiveSet>
  28
  29 #include <simgear/math/sg_random.h>
  30 #include <simgear/math/SGMath.hxx>
  31 #include "SGTriangleBin.hxx"
  32
  33
  34
  35 struct SGVertNormTex {
  36   SGVertNormTex()
  37   { }
  38   SGVertNormTex(const SGVec3f& v, const SGVec3f& n, const SGVec2f& t) :
  39     vertex(v), normal(n), texCoord(t)
  40   { }
  41   struct less
  42   {
  43     inline bool operator() (const SGVertNormTex& l,
  44                             const SGVertNormTex& r) const
  45     {
  46       if (l.vertex < r.vertex) return true;
  47       else if (r.vertex < l.vertex) return false;
  48       else if (l.normal < r.normal) return true;
  49       else if (r.normal < l.normal) return false;
  50       else return l.texCoord < r.texCoord;
  51     }
  52   };
  53
  54   SGVec3f vertex;
  55   SGVec3f normal;
  56   SGVec2f texCoord;
  57 };
  58
  59 // Use a DrawElementsUShort if there are few enough vertices,
  60 // otherwise fallback to DrawElementsUInt. Hide the differences
  61 // between the two from the rest of the code.
  62 //
  63 // We don't bother with DrawElementsUByte because that is generally
  64 // not an advantage on modern hardware.
  65 class DrawElementsFacade {
  66 public:
  67     DrawElementsFacade(unsigned numVerts) :
  68         _ushortElements(0), _uintElements(0)
  69     {
  70         if (numVerts > 65535)
  71             _uintElements
  72                 = new osg::DrawElementsUInt(osg::PrimitiveSet::TRIANGLES);
  73         else
  74             _ushortElements
  75                 = new osg::DrawElementsUShort(osg::PrimitiveSet::TRIANGLES);
  76     }
  77
  78     void push_back(unsigned val)
  79     {
  80         if (_uintElements)
  81             _uintElements->push_back(val);
  82         else
  83             _ushortElements->push_back(val);
  84     }
  85
  86     osg::DrawElements* getDrawElements()
  87     {
  88         if (_uintElements)
  89             return _uintElements;
  90         return _ushortElements;
  91     }
  92 protected:
  93     osg::DrawElementsUShort* _ushortElements;
  94     osg::DrawElementsUInt* _uintElements;
  95 };
  96
  97 class SGTexturedTriangleBin : public SGTriangleBin<SGVertNormTex> {
  98 public:
  99   SGTexturedTriangleBin()
 100   {
 101     mt_init(&seed, 123);
 102   }
 103
 104   // Computes and adds random surface points to the points list.
 105   // The random points are computed with a density of (coverage points)/1
 106   // The points are offsetted away from the triangles in
 107   // offset * positive normal direction.
 108   void addRandomSurfacePoints(float coverage, float offset,
 109                               std::vector<SGVec3f>& points)
 110   {
 111     unsigned num = getNumTriangles();
 112     for (unsigned i = 0; i < num; ++i) {
 113       triangle_ref triangleRef = getTriangleRef(i);
 114       SGVec3f v0 = getVertex(triangleRef[0]).vertex;
 115       SGVec3f v1 = getVertex(triangleRef[1]).vertex;
 116       SGVec3f v2 = getVertex(triangleRef[2]).vertex;
 117       SGVec3f normal = cross(v1 - v0, v2 - v0);
 118
 119       // Compute the area
 120       float area = 0.5f*length(normal);
 121       if (area <= SGLimitsf::min())
 122         continue;
 123
 124       // For partial units of area, use a zombie door method to
 125       // create the proper random chance of a light being created
 126       // for this triangle
 127       float unit = area + mt_rand(&seed)*coverage;
 128
 129       SGVec3f offsetVector = offset*normalize(normal);
 130       // generate a light point for each unit of area
 131       while ( coverage < unit ) {
 132         float a = mt_rand(&seed);
 133         float b = mt_rand(&seed);
 134         if ( a + b > 1 ) {
 135           a = 1 - a;
 136           b = 1 - b;
 137         }
 138         float c = 1 - a - b;
 139         SGVec3f randomPoint = offsetVector + a*v0 + b*v1 + c*v2;
 140         points.push_back(randomPoint);
 141         unit -= coverage;
 142       }
 143     }
 144   }
 145
 146    void addRandomPoints(float coverage,
 147                         std::vector<SGVec3f>& points)
 148   {
 149     unsigned num = getNumTriangles();
 150     for (unsigned i = 0; i < num; ++i) {
 151       triangle_ref triangleRef = getTriangleRef(i);
 152       SGVec3f v0 = getVertex(triangleRef[0]).vertex;
 153       SGVec3f v1 = getVertex(triangleRef[1]).vertex;
 154       SGVec3f v2 = getVertex(triangleRef[2]).vertex;
 155       SGVec3f normal = cross(v1 - v0, v2 - v0);
 156
 157       // Compute the area
 158       float area = 0.5f*length(normal);
 159       if (area <= SGLimitsf::min())
 160         continue;
 161
 162       // for partial units of area, use a zombie door method to
 163       // create the proper random chance of an object being created
 164       // for this triangle.
 165       double num = area / coverage + mt_rand(&seed);
 166
 167       // place an object each unit of area
 168       while ( num > 1.0 ) {
 169         float a = mt_rand(&seed);
 170         float b = mt_rand(&seed);
 171         if ( a + b > 1 ) {
 172           a = 1 - a;
 173           b = 1 - b;
 174         }
 175         float c = 1 - a - b;
 176         SGVec3f randomPoint = a*v0 + b*v1 + c*v2;
 177         points.push_back(randomPoint);
 178         num -= 1.0;
 179       }
 180     }
 181   }
 182
 183   osg::Geometry* buildGeometry(const TriangleVector& triangles) const
 184   {
 185     // Do not build anything if there is nothing in here ...
 186     if (empty() || triangles.empty())
 187       return 0;
 188
 189     // FIXME: do not include all values here ...
 190     osg::Vec3Array* vertices = new osg::Vec3Array;
 191     osg::Vec3Array* normals = new osg::Vec3Array;
 192     osg::Vec2Array* texCoords = new osg::Vec2Array;
 193
 194     osg::Vec4Array* colors = new osg::Vec4Array;
 195     colors->push_back(osg::Vec4(1, 1, 1, 1));
 196
 197     osg::Geometry* geometry = new osg::Geometry;
 198     geometry->setVertexArray(vertices);
 199     geometry->setNormalArray(normals);
 200     geometry->setNormalBinding(osg::Geometry::BIND_PER_VERTEX);
 201     geometry->setColorArray(colors);
 202     geometry->setColorBinding(osg::Geometry::BIND_OVERALL);
 203     geometry->setTexCoordArray(0, texCoords);
 204
 205     const unsigned invalid = ~unsigned(0);
 206     std::vector<unsigned> indexMap(getNumVertices(), invalid);
 207
 208     DrawElementsFacade deFacade(vertices->size());
 209     for (index_type i = 0; i < triangles.size(); ++i) {
 210       triangle_ref triangle = triangles[i];
 211       if (indexMap[triangle[0]] == invalid) {
 212         indexMap[triangle[0]] = vertices->size();
 213         vertices->push_back(getVertex(triangle[0]).vertex.osg());
 214         normals->push_back(getVertex(triangle[0]).normal.osg());
 215         texCoords->push_back(getVertex(triangle[0]).texCoord.osg());
 216       }
 217       deFacade.push_back(indexMap[triangle[0]]);
 218
 219       if (indexMap[triangle[1]] == invalid) {
 220         indexMap[triangle[1]] = vertices->size();
 221         vertices->push_back(getVertex(triangle[1]).vertex.osg());
 222         normals->push_back(getVertex(triangle[1]).normal.osg());
 223         texCoords->push_back(getVertex(triangle[1]).texCoord.osg());
 224       }
 225       deFacade.push_back(indexMap[triangle[1]]);
 226
 227       if (indexMap[triangle[2]] == invalid) {
 228         indexMap[triangle[2]] = vertices->size();
 229         vertices->push_back(getVertex(triangle[2]).vertex.osg());
 230         normals->push_back(getVertex(triangle[2]).normal.osg());
 231         texCoords->push_back(getVertex(triangle[2]).texCoord.osg());
 232       }
 233       deFacade.push_back(indexMap[triangle[2]]);
 234     }
 235     geometry->addPrimitiveSet(deFacade.getDrawElements());
 236
 237     return geometry;
 238   }
 239
 240   osg::Geometry* buildGeometry() const
 241   { return buildGeometry(getTriangles()); }
 242
 243 private:
 244   // Random seed for the triangle.
 245   mt seed;
 246 };
 247
 248 #endif