3 * Copyright (C) 2008 Stuart Buchanan
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.
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.
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,
27 #include <boost/tuple/tuple_comparison.hpp>
30 #include <osg/Geometry>
32 #include <osg/MatrixTransform>
35 #include <osgDB/ReadFile>
36 #include <osgDB/FileUtils>
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>
49 #include "ShaderGeometry.hxx"
50 #include "TreeBin.hxx"
52 #define SG_TREE_QUAD_TREE_DEPTH 3
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.
65 // The tree quad is rendered twice, with different rotations, to
66 // create the crossed tree geometry.
68 struct TreesBoundingBoxCallback : public Drawable::ComputeBoundingBoxCallback
70 TreesBoundingBoxCallback() {}
71 TreesBoundingBoxCallback(const TreesBoundingBoxCallback&, const CopyOp&) {}
72 META_Object(simgear, TreesBoundingBoxCallback);
73 virtual BoundingBox computeBound(const Drawable&) const;
77 TreesBoundingBoxCallback::computeBound(const Drawable& drawable) const
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());
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();
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) {
110 Geometry* makeSharedTreeGeometry(int numQuads)
112 // generate a repeatable random seed
114 mt_init(&seed, unsigned(123));
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;
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));
138 Geometry* result = new Geometry;
139 result->setVertexArray(v);
140 result->setTexCoordArray(0, t);
141 result->setComputeBoundingBoxCallback(new TreesBoundingBoxCallback);
142 result->setUseDisplayList(false);
146 ref_ptr<Geometry> sharedTreeGeometry;
148 Geometry* createTreeGeometry(float width, float height, int varieties)
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);
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));
174 EffectGeode* createTreeGeode(float width, float height, int varieties)
176 EffectGeode* result = new EffectGeode;
177 result->addDrawable(createTreeGeometry(width, height, varieties));
181 void addTreeToLeafGeode(Geode* geode, const SGVec3f& p)
184 unsigned int numDrawables = geode->getNumDrawables();
186 = static_cast<Geometry*>(geode->getDrawable(numDrawables - 1));
187 Vec3Array* posArray = static_cast<Vec3Array*>(geom->getColorArray());
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);
197 posArray->insert(posArray->end(), 4, pos);
198 size_t numVerts = posArray->size();
199 for (int i = 0; i < 2; ++i) {
201 = static_cast<DrawArrays*>(geom->getPrimitiveSet(i));
202 primSet->setCount(numVerts);
206 typedef std::map<std::string, osg::ref_ptr<Effect> > EffectMap;
208 static EffectMap treeEffectMap;
210 // Helper classes for creating the quad tree
215 MakeTreesLeaf(float range, int varieties, float width, float height,
217 _range(range), _varieties(varieties),
218 _width(width), _height(height), _effect(effect) {}
220 MakeTreesLeaf(const MakeTreesLeaf& rhs) :
222 _varieties(rhs._varieties), _width(rhs._width), _height(rhs._height),
226 LOD* operator() () const
228 LOD* result = new LOD;
229 EffectGeode* geode = createTreeGeode(_width, _height, _varieties);
230 geode->setEffect(_effect.get());
231 result->addChild(geode, 0, _range);
238 ref_ptr<Effect> _effect;
241 struct AddTreesLeafObject
243 void operator() (LOD* lod, const TreeBin::Tree& tree) const
245 Geode* geode = static_cast<Geode*>(lod->getChild(0));
246 addTreeToLeafGeode(geode, tree.position);
252 Vec3 operator() (const TreeBin::Tree& tree) const
254 return toOsg(tree.position);
258 typedef QuadTreeBuilder<LOD*, TreeBin::Tree, MakeTreesLeaf, AddTreesLeafObject,
259 GetTreeCoord> ShaderGeometryQuadtree;
262 struct TreeTransformer
264 TreeTransformer(Matrix& mat_) : mat(mat_) {}
265 TreeBin::Tree operator()(const TreeBin::Tree& tree) const
267 Vec3 pos = toOsg(tree.position);
268 return TreeBin::Tree(toSG(pos * mat));
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.
277 osg::Group* createForest(TreeBin& forest, const osg::Matrix& transform)
279 Matrix transInv = Matrix::inverse(transform);
281 // Set up some shared structures.
282 ref_ptr<Group> group;
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");
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));
296 effect = iter->second.get();
298 // Now, create a quadtree for the forest.
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
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();
316 MatrixTransform* mt = new MatrixTransform(transform);
317 for (size_t i = 0; i < group->getNumChildren(); ++i)
318 mt->addChild(group->getChild(i));