simgear/scene/tgdb/TreeBin.cxx

   1 /* -*-c++-*-
   2  *
   3  * Copyright (C) 2008 Stuart Buchanan
   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 #include <algorithm>
  23 #include <vector>
  24 #include <string>
  25 #include <map>
  26
  27 #include <boost/tuple/tuple_comparison.hpp>
  28
  29 #include <osg/Geode>
  30 #include <osg/Geometry>
  31 #include <osg/Math>
  32 #include <osg/MatrixTransform>
  33 #include <osg/Matrix>
  34
  35 #include <osgDB/ReadFile>
  36 #include <osgDB/FileUtils>
  37
  38 #include <simgear/debug/logstream.hxx>
  39 #include <simgear/math/sg_random.h>
  40 #include <simgear/misc/sg_path.hxx>
  41 #include <simgear/scene/material/Effect.hxx>
  42 #include <simgear/scene/material/EffectGeode.hxx>
  43 #include <simgear/props/props.hxx>
  44 #include <simgear/scene/util/QuadTreeBuilder.hxx>
  45 #include <simgear/scene/util/RenderConstants.hxx>
  46 #include <simgear/scene/util/StateAttributeFactory.hxx>
  47 #include <simgear/structure/OSGUtils.hxx>
  48
  49 #include "ShaderGeometry.hxx"
  50 #include "TreeBin.hxx"
  51
  52 #define SG_TREE_QUAD_TREE_DEPTH 3
  53
  54 using namespace osg;
  55
  56 namespace simgear
  57 {
  58
  59 // Tree instance scheme:
  60 // vertex - local position of quad vertex.
  61 // normal - x y scaling, z number of varieties
  62 // fog coord - rotation
  63 // color - xyz of tree quad origin, replicated 4 times.
  64 //
  65 // The tree quad is rendered twice, with different rotations, to
  66 // create the crossed tree geometry.
  67
  68 struct TreesBoundingBoxCallback : public Drawable::ComputeBoundingBoxCallback
  69 {
  70     TreesBoundingBoxCallback() {}
  71     TreesBoundingBoxCallback(const TreesBoundingBoxCallback&, const CopyOp&) {}
  72     META_Object(simgear, TreesBoundingBoxCallback);
  73     virtual BoundingBox computeBound(const Drawable&) const;
  74 };
  75
  76 BoundingBox
  77 TreesBoundingBoxCallback::computeBound(const Drawable& drawable) const
  78 {
  79     BoundingBox bb;
  80     const Geometry* geom = static_cast<const Geometry*>(&drawable);
  81     const Vec3Array* v = static_cast<const Vec3Array*>(geom->getVertexArray());
  82     const Vec3Array* pos = static_cast<const Vec3Array*>(geom->getColorArray());
  83     const Vec3Array* params
  84         = static_cast<const Vec3Array*>(geom->getNormalArray());
  85     const FloatArray* rot
  86         = static_cast<const FloatArray*>(geom->getFogCoordArray());
  87     float w = (*params)[0].x();
  88     float h = (*params)[0].y();
  89     Geometry::PrimitiveSetList primSets = geom->getPrimitiveSetList();
  90     FloatArray::const_iterator rotitr = rot->begin();
  91     for (Geometry::PrimitiveSetList::const_iterator psitr = primSets.begin(),
  92              psend = primSets.end();
  93          psitr != psend;
  94          ++psitr, ++rotitr) {
  95         Matrixd trnsfrm = (Matrixd::scale(w, w, h)
  96                            * Matrixd::rotate(*rotitr, Vec3(0.0f, 0.0f, 1.0f)));
  97         DrawArrays* da = static_cast<DrawArrays*>(psitr->get());
  98         GLint psFirst = da->getFirst();
  99         GLint psEndVert = psFirst + da->getCount();
 100         for (GLint i = psFirst;i < psEndVert; ++i) {
 101             Vec3 pt = (*v)[i];
 102             pt = pt * trnsfrm;
 103             pt += (*pos)[i];
 104             bb.expandBy(pt);
 105         }
 106     }
 107     return bb;
 108 }
 109
 110 Geometry* makeSharedTreeGeometry(int numQuads)
 111 {
 112     // generate a repeatable random seed
 113     mt seed;
 114     mt_init(&seed, unsigned(123));
 115     // set up the coords
 116     osg::Vec3Array* v = new osg::Vec3Array;
 117     osg::Vec2Array* t = new osg::Vec2Array;
 118     v->reserve(numQuads * 4);
 119     t->reserve(numQuads * 4);
 120     for (int i = 0; i < numQuads; ++i) {
 121         // Apply a random scaling factor and texture index.
 122         float h = (mt_rand(&seed) + mt_rand(&seed)) / 2.0f + 0.5f;
 123         float cw = h * .5;
 124         v->push_back(Vec3(0.0f, -cw, 0.0f));
 125         v->push_back(Vec3(0.0f, cw, 0.0f));
 126         v->push_back(Vec3(0.0f, cw, h));
 127         v->push_back(Vec3(0.0f,-cw, h));
 128         // The texture coordinate range is not the entire coordinate
 129         // space, as the texture has a number of different trees on
 130         // it. Here we assign random coordinates and let the shader
 131         // choose the variety.
 132         float variety = mt_rand(&seed);
 133         t->push_back(Vec2(variety, 0.0f));
 134         t->push_back(Vec2(variety + 1.0f, 0.0f));
 135         t->push_back(Vec2(variety + 1.0f, 1.0f));
 136         t->push_back(Vec2(variety, 1.0f));
 137     }
 138     Geometry* result = new Geometry;
 139     result->setVertexArray(v);
 140     result->setTexCoordArray(0, t);
 141     result->setComputeBoundingBoxCallback(new TreesBoundingBoxCallback);
 142     result->setUseDisplayList(false);
 143     return result;
 144 }
 145
 146 ref_ptr<Geometry> sharedTreeGeometry;
 147
 148 Geometry* createTreeGeometry(float width, float height, int varieties)
 149 {
 150     if (!sharedTreeGeometry)
 151         sharedTreeGeometry = makeSharedTreeGeometry(1600);
 152     Geometry* quadGeom = simgear::clone(sharedTreeGeometry.get(),
 153                                         CopyOp::SHALLOW_COPY);
 154     Vec3Array* params = new Vec3Array;
 155     params->push_back(Vec3(width, height, (float)varieties));
 156     quadGeom->setNormalArray(params);
 157     quadGeom->setNormalBinding(Geometry::BIND_OVERALL);
 158     // Positions
 159     quadGeom->setColorArray(new Vec3Array);
 160     quadGeom->setColorBinding(Geometry::BIND_PER_VERTEX);
 161     FloatArray* rotation = new FloatArray(2);
 162     (*rotation)[0] = 0.0;
 163     (*rotation)[1] = PI_2;
 164     quadGeom->setFogCoordArray(rotation);
 165     quadGeom->setFogCoordBinding(Geometry::BIND_PER_PRIMITIVE_SET);
 166     // The primitive sets render the same geometry, but the second
 167     // will rotated 90 degrees by the vertex shader, which uses the
 168     // fog coordinate as a rotation.
 169     for (int i = 0; i < 2; ++i)
 170         quadGeom->addPrimitiveSet(new DrawArrays(PrimitiveSet::QUADS));
 171     return quadGeom;
 172 }
 173
 174 EffectGeode* createTreeGeode(float width, float height, int varieties)
 175 {
 176     EffectGeode* result = new EffectGeode;
 177     result->addDrawable(createTreeGeometry(width, height, varieties));
 178     return result;
 179 }
 180
 181 void addTreeToLeafGeode(Geode* geode, const SGVec3f& p)
 182 {
 183     Vec3 pos = toOsg(p);
 184     unsigned int numDrawables = geode->getNumDrawables();
 185     Geometry* geom
 186         = static_cast<Geometry*>(geode->getDrawable(numDrawables - 1));
 187     Vec3Array* posArray = static_cast<Vec3Array*>(geom->getColorArray());
 188     if (posArray->size()
 189         >= static_cast<Vec3Array*>(geom->getVertexArray())->size()) {
 190         Vec3Array* paramsArray
 191             = static_cast<Vec3Array*>(geom->getNormalArray());
 192         Vec3 params = (*paramsArray)[0];
 193         geom = createTreeGeometry(params.x(), params.y(), params.z());
 194         posArray = static_cast<Vec3Array*>(geom->getColorArray());
 195         geode->addDrawable(geom);
 196     }
 197     posArray->insert(posArray->end(), 4, pos);
 198     size_t numVerts = posArray->size();
 199     for (int i = 0; i < 2; ++i) {
 200         DrawArrays* primSet
 201             = static_cast<DrawArrays*>(geom->getPrimitiveSet(i));
 202         primSet->setCount(numVerts);
 203     }
 204 }
 205
 206 typedef std::map<std::string, osg::ref_ptr<Effect> > EffectMap;
 207
 208 static EffectMap treeEffectMap;
 209
 210 // Helper classes for creating the quad tree
 211 namespace
 212 {
 213 struct MakeTreesLeaf
 214 {
 215     MakeTreesLeaf(float range, int varieties, float width, float height,
 216         Effect* effect) :
 217         _range(range),  _varieties(varieties),
 218         _width(width), _height(height), _effect(effect) {}
 219
 220     MakeTreesLeaf(const MakeTreesLeaf& rhs) :
 221         _range(rhs._range),
 222         _varieties(rhs._varieties), _width(rhs._width), _height(rhs._height),
 223         _effect(rhs._effect)
 224     {}
 225
 226     LOD* operator() () const
 227     {
 228         LOD* result = new LOD;
 229         EffectGeode* geode = createTreeGeode(_width, _height, _varieties);
 230         geode->setEffect(_effect.get());
 231         result->addChild(geode, 0, _range);
 232         return result;
 233     }
 234     float _range;
 235     int _varieties;
 236     float _width;
 237     float _height;
 238     ref_ptr<Effect> _effect;
 239 };
 240
 241 struct AddTreesLeafObject
 242 {
 243     void operator() (LOD* lod, const TreeBin::Tree& tree) const
 244     {
 245         Geode* geode = static_cast<Geode*>(lod->getChild(0));
 246         addTreeToLeafGeode(geode, tree.position);
 247     }
 248 };
 249
 250 struct GetTreeCoord
 251 {
 252     Vec3 operator() (const TreeBin::Tree& tree) const
 253     {
 254         return toOsg(tree.position);
 255     }
 256 };
 257
 258 typedef QuadTreeBuilder<LOD*, TreeBin::Tree, MakeTreesLeaf, AddTreesLeafObject,
 259                         GetTreeCoord> ShaderGeometryQuadtree;
 260 }
 261
 262 struct TreeTransformer
 263 {
 264     TreeTransformer(Matrix& mat_) : mat(mat_) {}
 265     TreeBin::Tree operator()(const TreeBin::Tree& tree) const
 266     {
 267         Vec3 pos = toOsg(tree.position);
 268         return TreeBin::Tree(toSG(pos * mat));
 269     }
 270     Matrix mat;
 271 };
 272
 273 // This actually returns a MatrixTransform node. If we rotate the whole
 274 // forest into the local Z-up coordinate system we can reuse the
 275 // primitive tree geometry for all the forests of the same type.
 276
 277 osg::Group* createForest(TreeBin& forest, const osg::Matrix& transform)
 278 {
 279     Matrix transInv = Matrix::inverse(transform);
 280     static Matrix ident;
 281     // Set up some shared structures.
 282     ref_ptr<Group> group;
 283
 284     Effect* effect = 0;
 285     EffectMap::iterator iter = treeEffectMap.find(forest.texture);
 286     if (iter == treeEffectMap.end()) {
 287         SGPropertyNode_ptr effectProp = new SGPropertyNode;
 288         makeChild(effectProp, "inherits-from")->setStringValue("Effects/tree");
 289         SGPropertyNode* params = makeChild(effectProp, "parameters");
 290         // emphasize n = 0
 291         params->getChild("texture", 0, true)->getChild("image", 0, true)
 292             ->setStringValue(forest.texture);
 293         effect = makeEffect(effectProp, true);
 294         treeEffectMap.insert(EffectMap::value_type(forest.texture, effect));
 295     } else {
 296         effect = iter->second.get();
 297     }
 298     // Now, create a quadtree for the forest.
 299     {
 300         ShaderGeometryQuadtree
 301             quadtree(GetTreeCoord(), AddTreesLeafObject(),
 302                      SG_TREE_QUAD_TREE_DEPTH,
 303                      MakeTreesLeaf(forest.range, forest.texture_varieties,
 304                                    forest.width, forest.height, effect));
 305         // Transform tree positions from the "geocentric" positions we
 306         // get from the scenery polys into the local Z-up coordinate
 307         // system.
 308         std::vector<TreeBin::Tree> rotatedTrees;
 309         rotatedTrees.reserve(forest._trees.size());
 310         std::transform(forest._trees.begin(), forest._trees.end(),
 311                        std::back_inserter(rotatedTrees),
 312                        TreeTransformer(transInv));
 313         quadtree.buildQuadTree(rotatedTrees.begin(), rotatedTrees.end());
 314         group = quadtree.getRoot();
 315     }
 316     MatrixTransform* mt = new MatrixTransform(transform);
 317     for (size_t i = 0; i < group->getNumChildren(); ++i)
 318         mt->addChild(group->getChild(i));
 319     return mt;
 320 }
 321
 322 }