root/OpenSceneGraph/trunk/examples/osgforest/osgforest.cpp @ 5923

Revision 5923, 32.4 kB (checked in by robert, 8 years ago)

Ported osgcopy, osgcubemap, osgdelaunay, osgdepthpartion, osgdistortion, osgfadetext, osgforest and osgfxbrowser to osgViewer

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1#include <osg/AlphaFunc>
2#include <osg/Billboard>
3#include <osg/BlendFunc>
4#include <osg/Depth>
5#include <osg/Geode>
6#include <osg/Geometry>
7#include <osg/Material>
8#include <osg/Math>
9#include <osg/MatrixTransform>
10#include <osg/PolygonOffset>
11#include <osg/Projection>
12#include <osg/ShapeDrawable>
13#include <osg/StateSet>
14#include <osg/Switch>
15#include <osg/Texture2D>
16#include <osg/TexEnv>
17
18#include <osgDB/ReadFile>
19#include <osgDB/FileUtils>
20
21#include <osgUtil/IntersectVisitor>
22#include <osgUtil/SmoothingVisitor>
23
24#include <osgText/Text>
25
26#include <osgViewer/Viewer>
27
28#include <iostream>
29
30// for the grid data..
31#include "../osghangglide/terrain_coords.h"
32
33// class to create the forest and manage the movement between various techniques.
34class ForestTechniqueManager : public osg::Referenced
35{
36public:
37
38    ForestTechniqueManager() {}
39
40    class Tree : public osg::Referenced
41    {
42    public:
43
44        Tree():
45            _color(255,255,255,255),
46            _width(1.0f),
47            _height(1.0f),
48            _type(0) {}
49
50        Tree(const osg::Vec3& position, const osg::Vec4ub& color, float width, float height, unsigned int type):
51            _position(position),
52            _color(color),
53            _width(width),
54            _height(height),
55            _type(type) {}
56
57        osg::Vec3       _position;
58        osg::Vec4ub     _color;
59        float           _width;
60        float           _height;
61        unsigned int    _type;
62    };
63   
64    typedef std::vector< osg::ref_ptr<Tree> > TreeList;
65   
66    class Cell : public osg::Referenced
67    {
68    public:
69        typedef std::vector< osg::ref_ptr<Cell> > CellList;
70
71        Cell():_parent(0) {}
72        Cell(osg::BoundingBox& bb):_parent(0), _bb(bb) {}
73       
74        void addCell(Cell* cell) { cell->_parent=this; _cells.push_back(cell); }
75
76        void addTree(Tree* tree) { _trees.push_back(tree); }
77       
78        void addTrees(const TreeList& trees) { _trees.insert(_trees.end(),trees.begin(),trees.end()); }
79       
80        void computeBound();
81       
82        bool contains(const osg::Vec3& position) const { return _bb.contains(position); }
83       
84        bool divide(unsigned int maxNumTreesPerCell=10);
85       
86        bool devide(bool xAxis, bool yAxis, bool zAxis);
87       
88        void bin();
89
90
91        Cell*               _parent;
92        osg::BoundingBox    _bb;
93        CellList            _cells;
94        TreeList            _trees;
95       
96    };
97
98    float random(float min,float max) { return min + (max-min)*(float)rand()/(float)RAND_MAX; }
99    int random(int min,int max) { return min + (int)((float)(max-min)*(float)rand()/(float)RAND_MAX); }
100
101    osg::Geode* createTerrain(const osg::Vec3& origin, const osg::Vec3& size);
102
103    void createTreeList(osg::Node* terrain,const osg::Vec3& origin, const osg::Vec3& size,unsigned int numTreesToCreate,TreeList& trees);
104
105    osg::Geometry* createSprite( float w, float h, osg::Vec4ub color );
106
107    osg::Geometry* createOrthogonalQuads( const osg::Vec3& pos, float w, float h, osg::Vec4ub color );
108    osg::Geometry* createOrthogonalQuadsNoColor( const osg::Vec3& pos, float w, float h );
109
110    osg::Node* createBillboardGraph(Cell* cell,osg::StateSet* stateset);
111
112    osg::Node* createXGraph(Cell* cell,osg::StateSet* stateset);
113
114    osg::Node* createTransformGraph(Cell* cell,osg::StateSet* stateset);
115
116    osg::Node* createShaderGraph(Cell* cell,osg::StateSet* stateset);
117   
118    osg::Node* createHUDWithText(const std::string& text);
119
120    osg::Node* createScene(unsigned int numTreesToCreates);
121   
122    void advanceToNextTechnique(int delta=1)
123    {
124        if (_techniqueSwitch.valid())
125        {
126            _currentTechnique += delta;
127            if (_currentTechnique<0)
128                _currentTechnique = _techniqueSwitch->getNumChildren()-1;
129            if (_currentTechnique>=(int)_techniqueSwitch->getNumChildren())
130                _currentTechnique = 0;
131            _techniqueSwitch->setSingleChildOn(_currentTechnique);
132        }
133    }
134   
135    osg::ref_ptr<osg::Switch>   _techniqueSwitch;
136    int                         _currentTechnique;
137   
138
139};
140
141// event handler to capture keyboard events and use them to advance the technique used for rendering
142class TechniqueEventHandler : public osgGA::GUIEventHandler
143{
144public:
145
146    TechniqueEventHandler(ForestTechniqueManager* ttm=0) { _ForestTechniqueManager = ttm; }
147   
148    META_Object(osgforestApp,TechniqueEventHandler);
149
150    virtual bool handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter&, osg::Object*, osg::NodeVisitor*);
151   
152    virtual void getUsage(osg::ApplicationUsage& usage) const;
153
154protected:
155
156    ~TechniqueEventHandler() {}
157   
158    TechniqueEventHandler(const TechniqueEventHandler&,const osg::CopyOp&) {}
159   
160    osg::ref_ptr<ForestTechniqueManager> _ForestTechniqueManager;
161
162       
163};
164
165bool TechniqueEventHandler::handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter&, osg::Object*, osg::NodeVisitor*)
166{
167    switch(ea.getEventType())
168    {
169        case(osgGA::GUIEventAdapter::KEYDOWN):
170        {
171            if (ea.getKey()=='n' ||
172                ea.getKey()==osgGA::GUIEventAdapter::KEY_Right ||
173                ea.getKey()==osgGA::GUIEventAdapter::KEY_KP_Right)
174            {
175                _ForestTechniqueManager->advanceToNextTechnique(1);
176                return true;
177            }
178            else if (ea.getKey()=='p' ||
179                     ea.getKey()==osgGA::GUIEventAdapter::KEY_Left ||
180                     ea.getKey()==osgGA::GUIEventAdapter::KEY_KP_Left)
181            {
182                _ForestTechniqueManager->advanceToNextTechnique(-1);
183                return true;
184            }
185            return false;
186        }
187
188        default:
189            return false;
190    }
191}
192
193void TechniqueEventHandler::getUsage(osg::ApplicationUsage& usage) const
194{
195    usage.addKeyboardMouseBinding("n or Left Arrow","Advance to next technique");
196    usage.addKeyboardMouseBinding("p or Right Array","Move to previous technique");
197}
198
199
200void ForestTechniqueManager::Cell::computeBound()
201{
202    _bb.init();
203    for(CellList::iterator citr=_cells.begin();
204        citr!=_cells.end();
205        ++citr)
206    {
207        (*citr)->computeBound();
208        _bb.expandBy((*citr)->_bb);
209    }
210
211    for(TreeList::iterator titr=_trees.begin();
212        titr!=_trees.end();
213        ++titr)
214    {
215        _bb.expandBy((*titr)->_position);
216    }
217}
218
219bool ForestTechniqueManager::Cell::divide(unsigned int maxNumTreesPerCell)
220{
221
222    if (_trees.size()<=maxNumTreesPerCell) return false;
223
224    computeBound();
225
226    float radius = _bb.radius();
227    float divide_distance = radius*0.7f;
228    if (devide((_bb.xMax()-_bb.xMin())>divide_distance,(_bb.yMax()-_bb.yMin())>divide_distance,(_bb.zMax()-_bb.zMin())>divide_distance))
229    {
230        // recusively divide the new cells till maxNumTreesPerCell is met.
231        for(CellList::iterator citr=_cells.begin();
232            citr!=_cells.end();
233            ++citr)
234        {
235            (*citr)->divide(maxNumTreesPerCell);
236        }
237        return true;
238   }
239   else
240   {
241        return false;
242   }
243}
244
245bool ForestTechniqueManager::Cell::devide(bool xAxis, bool yAxis, bool zAxis)
246{
247    if (!(xAxis || yAxis || zAxis)) return false;
248
249    if (_cells.empty())
250        _cells.push_back(new Cell(_bb));
251
252    if (xAxis)
253    {
254        unsigned int numCellsToDivide=_cells.size();
255        for(unsigned int i=0;i<numCellsToDivide;++i)
256        {
257            Cell* orig_cell = _cells[i].get();
258            Cell* new_cell = new Cell(orig_cell->_bb);
259
260            float xCenter = (orig_cell->_bb.xMin()+orig_cell->_bb.xMax())*0.5f;
261            orig_cell->_bb.xMax() = xCenter;
262            new_cell->_bb.xMin() = xCenter;
263
264            _cells.push_back(new_cell);
265        }
266    }
267
268    if (yAxis)
269    {
270        unsigned int numCellsToDivide=_cells.size();
271        for(unsigned int i=0;i<numCellsToDivide;++i)
272        {
273            Cell* orig_cell = _cells[i].get();
274            Cell* new_cell = new Cell(orig_cell->_bb);
275
276            float yCenter = (orig_cell->_bb.yMin()+orig_cell->_bb.yMax())*0.5f;
277            orig_cell->_bb.yMax() = yCenter;
278            new_cell->_bb.yMin() = yCenter;
279
280            _cells.push_back(new_cell);
281        }
282    }
283
284    if (zAxis)
285    {
286        unsigned int numCellsToDivide=_cells.size();
287        for(unsigned int i=0;i<numCellsToDivide;++i)
288        {
289            Cell* orig_cell = _cells[i].get();
290            Cell* new_cell = new Cell(orig_cell->_bb);
291
292            float zCenter = (orig_cell->_bb.zMin()+orig_cell->_bb.zMax())*0.5f;
293            orig_cell->_bb.zMax() = zCenter;
294            new_cell->_bb.zMin() = zCenter;
295
296            _cells.push_back(new_cell);
297        }
298    }
299
300    bin();
301
302    return true;
303
304}
305
306void ForestTechniqueManager::Cell::bin()
307{   
308    // put trees in apprpriate cells.
309    TreeList treesNotAssigned;
310    for(TreeList::iterator titr=_trees.begin();
311        titr!=_trees.end();
312        ++titr)
313    {
314        Tree* tree = titr->get();
315        bool assigned = false;
316        for(CellList::iterator citr=_cells.begin();
317            citr!=_cells.end() && !assigned;
318            ++citr)
319        {
320            if ((*citr)->contains(tree->_position))
321            {
322                (*citr)->addTree(tree);
323                assigned = true;
324            }
325        }
326        if (!assigned) treesNotAssigned.push_back(tree);
327    }
328
329    // put the unassigned trees back into the original local tree list.
330    _trees.swap(treesNotAssigned);
331
332
333    // prune empty cells.
334    CellList cellsNotEmpty;
335    for(CellList::iterator citr=_cells.begin();
336        citr!=_cells.end();
337        ++citr)
338    {
339        if (!((*citr)->_trees.empty()))
340        {
341            cellsNotEmpty.push_back(*citr);
342        }
343    }
344    _cells.swap(cellsNotEmpty);
345
346
347}
348
349osg::Geode* ForestTechniqueManager::createTerrain(const osg::Vec3& origin, const osg::Vec3& size)
350{
351    osg::Geode* geode = new osg::Geode();
352
353    // ---------------------------------------
354    // Set up a StateSet to texture the objects
355    // ---------------------------------------
356    osg::StateSet* stateset = new osg::StateSet();
357
358    osg::Image* image = osgDB::readImageFile("Images/lz.rgb");
359    if (image)
360    {
361        osg::Texture2D* texture = new osg::Texture2D;
362        texture->setImage(image);
363        stateset->setTextureAttributeAndModes(0,texture,osg::StateAttribute::ON);
364    }
365   
366    geode->setStateSet( stateset );
367   
368    unsigned int numColumns = 38;
369    unsigned int numRows = 39;
370    unsigned int r;
371    unsigned int c;
372
373    // compute z range of z values of grid data so we can scale it.
374    float min_z = FLT_MAX;
375    float max_z = -FLT_MAX;
376    for(r=0;r<numRows;++r)
377    {
378        for(c=0;c<numColumns;++c)
379        {
380            min_z = osg::minimum(min_z,vertex[r+c*numRows][2]);
381            max_z = osg::maximum(max_z,vertex[r+c*numRows][2]);
382        }
383    }
384   
385    float scale_z = size.z()/(max_z-min_z);
386
387
388    bool createGrid = false;
389    if (createGrid)
390    {
391
392        osg::HeightField* grid = new osg::HeightField;
393        grid->allocate(numColumns,numRows);
394        grid->setOrigin(origin);
395        grid->setXInterval(size.x()/(float)(numColumns-1));
396        grid->setYInterval(size.y()/(float)(numRows-1));
397
398        for(r=0;r<numRows;++r)
399        {
400            for(c=0;c<numColumns;++c)
401            {
402                grid->setHeight(c,r,(vertex[r+c*numRows][2]-min_z)*scale_z);
403            }
404        }
405       
406        geode->addDrawable(new osg::ShapeDrawable(grid));
407    }
408    else
409    {
410        osg::Geometry* geometry = new osg::Geometry;
411       
412        osg::Vec3Array& v = *(new osg::Vec3Array(numColumns*numRows));
413        osg::Vec2Array& t = *(new osg::Vec2Array(numColumns*numRows));
414        osg::Vec4ubArray& color = *(new osg::Vec4ubArray(1));
415       
416        color[0].set(255,255,255,255);
417
418        float rowCoordDelta = size.y()/(float)(numRows-1);
419        float columnCoordDelta = size.x()/(float)(numColumns-1);
420       
421        float rowTexDelta = 1.0f/(float)(numRows-1);
422        float columnTexDelta = 1.0f/(float)(numColumns-1);
423
424        osg::Vec3 pos = origin;
425        osg::Vec2 tex(0.0f,0.0f);
426        int vi=0;
427        for(r=0;r<numRows;++r)
428        {
429            pos.x() = origin.x();
430            tex.x() = 0.0f;
431            for(c=0;c<numColumns;++c)
432            {
433                v[vi].set(pos.x(),pos.y(),pos.z()+(vertex[r+c*numRows][2]-min_z)*scale_z);
434                t[vi].set(tex.x(),tex.y());
435                pos.x()+=columnCoordDelta;
436                tex.x()+=columnTexDelta;
437                ++vi;
438            }
439            pos.y() += rowCoordDelta;
440            tex.y() += rowTexDelta;
441        }
442       
443        geometry->setVertexArray(&v);
444        geometry->setColorArray(&color);
445        geometry->setColorBinding(osg::Geometry::BIND_OVERALL);
446        geometry->setTexCoordArray(0,&t);
447       
448        for(r=0;r<numRows-1;++r)
449        {
450            osg::DrawElementsUShort& drawElements = *(new osg::DrawElementsUShort(GL_QUAD_STRIP,2*numColumns));
451            geometry->addPrimitiveSet(&drawElements);
452            int ei=0;
453            for(c=0;c<numColumns;++c)
454            {
455                drawElements[ei++] = (r+1)*numColumns+c;
456                drawElements[ei++] = (r)*numColumns+c;
457            }
458        }
459       
460        geode->addDrawable(geometry);
461       
462        osgUtil::SmoothingVisitor sv;
463        sv.smooth(*geometry);
464    }
465   
466    return geode;
467}
468
469void ForestTechniqueManager::createTreeList(osg::Node* terrain,const osg::Vec3& origin, const osg::Vec3& size,unsigned int numTreesToCreate,TreeList& trees)
470{
471
472    float max_TreeHeight = sqrtf(size.length2()/(float)numTreesToCreate);
473    float max_TreeWidth = max_TreeHeight*0.5f;
474   
475    float min_TreeHeight = max_TreeHeight*0.3f;
476    float min_TreeWidth = min_TreeHeight*0.5f;
477
478    trees.reserve(trees.size()+numTreesToCreate);
479
480
481    for(unsigned int i=0;i<numTreesToCreate;++i)
482    {
483        Tree* tree = new Tree;
484        tree->_position.set(random(origin.x(),origin.x()+size.x()),random(origin.y(),origin.y()+size.y()),origin.z());
485        tree->_color.set(random(128,255),random(128,255),random(128,255),255);
486        tree->_width = random(min_TreeWidth,max_TreeWidth);
487        tree->_height = random(min_TreeHeight,max_TreeHeight);
488        tree->_type = 0;
489       
490        if (terrain)
491        {
492            osgUtil::IntersectVisitor iv;
493            osg::ref_ptr<osg::LineSegment> segDown = new osg::LineSegment;
494
495            segDown->set(tree->_position,tree->_position+osg::Vec3(0.0f,0.0f,size.z()));
496            iv.addLineSegment(segDown.get());
497           
498            terrain->accept(iv);
499
500            if (iv.hits())
501            {
502                osgUtil::IntersectVisitor::HitList& hitList = iv.getHitList(segDown.get());
503                if (!hitList.empty())
504                {
505                    osg::Vec3 ip = hitList.front().getWorldIntersectPoint();
506                    osg::Vec3 np = hitList.front().getWorldIntersectNormal();
507                    tree->_position = ip;
508                }
509            }
510        }
511       
512        trees.push_back(tree);
513    }
514}
515
516osg::Geometry* ForestTechniqueManager::createSprite( float w, float h, osg::Vec4ub color )
517{
518    // set up the coords
519    osg::Vec3Array& v = *(new osg::Vec3Array(4));
520    osg::Vec2Array& t = *(new osg::Vec2Array(4));
521    osg::Vec4ubArray& c = *(new osg::Vec4ubArray(1));
522
523    v[0].set(-w*0.5f,0.0f,0.0f);
524    v[1].set( w*0.5f,0.0f,0.0f);
525    v[2].set( w*0.5f,0.0f,h);
526    v[3].set(-w*0.5f,0.0f,h);
527
528    c[0] = color;
529
530    t[0].set(0.0f,0.0f);
531    t[1].set(1.0f,0.0f);
532    t[2].set(1.0f,1.0f);
533    t[3].set(0.0f,1.0f);
534
535    osg::Geometry *geom = new osg::Geometry;
536
537    geom->setVertexArray( &v );
538
539    geom->setTexCoordArray( 0, &t );
540
541    geom->setColorArray( &c );
542    geom->setColorBinding( osg::Geometry::BIND_OVERALL );
543
544    geom->addPrimitiveSet( new osg::DrawArrays(osg::PrimitiveSet::QUADS,0,4) );
545
546    return geom;
547}
548
549osg::Geometry* ForestTechniqueManager::createOrthogonalQuads( const osg::Vec3& pos, float w, float h, osg::Vec4ub color )
550{
551    // set up the coords
552    osg::Vec3Array& v = *(new osg::Vec3Array(8));
553    osg::Vec2Array& t = *(new osg::Vec2Array(8));
554    osg::Vec4ubArray& c = *(new osg::Vec4ubArray(1));
555   
556    float rotation = random(0.0f,osg::PI/2.0f);
557    float sw = sinf(rotation)*w*0.5f;
558    float cw = cosf(rotation)*w*0.5f;
559
560    v[0].set(pos.x()-sw,pos.y()-cw,pos.z()+0.0f);
561    v[1].set(pos.x()+sw,pos.y()+cw,pos.z()+0.0f);
562    v[2].set(pos.x()+sw,pos.y()+cw,pos.z()+h);
563    v[3].set(pos.x()-sw,pos.y()-cw,pos.z()+h);
564
565    v[4].set(pos.x()-cw,pos.y()+sw,pos.z()+0.0f);
566    v[5].set(pos.x()+cw,pos.y()-sw,pos.z()+0.0f);
567    v[6].set(pos.x()+cw,pos.y()-sw,pos.z()+h);
568    v[7].set(pos.x()-cw,pos.y()+sw,pos.z()+h);
569
570    c[0] = color;
571
572    t[0].set(0.0f,0.0f);
573    t[1].set(1.0f,0.0f);
574    t[2].set(1.0f,1.0f);
575    t[3].set(0.0f,1.0f);
576
577    t[4].set(0.0f,0.0f);
578    t[5].set(1.0f,0.0f);
579    t[6].set(1.0f,1.0f);
580    t[7].set(0.0f,1.0f);
581
582    osg::Geometry *geom = new osg::Geometry;
583
584    geom->setVertexArray( &v );
585
586    geom->setTexCoordArray( 0, &t );
587
588    geom->setColorArray( &c );
589    geom->setColorBinding( osg::Geometry::BIND_OVERALL );
590
591    geom->addPrimitiveSet( new osg::DrawArrays(osg::PrimitiveSet::QUADS,0,8) );
592
593    return geom;
594}
595
596osg::Node* ForestTechniqueManager::createBillboardGraph(Cell* cell,osg::StateSet* stateset)
597{
598    bool needGroup = !(cell->_cells.empty());
599    bool needBillboard = !(cell->_trees.empty());
600   
601    osg::Billboard* billboard = 0;
602    osg::Group* group = 0;
603   
604    if (needBillboard)
605    {
606        billboard = new osg::Billboard;
607        billboard->setStateSet(stateset);
608        for(TreeList::iterator itr=cell->_trees.begin();
609            itr!=cell->_trees.end();
610            ++itr)
611        {
612            Tree& tree = **itr;
613            billboard->addDrawable(createSprite(tree._width,tree._height,tree._color),tree._position);   
614        }
615    }
616   
617    if (needGroup)
618    {
619        group = new osg::Group;
620        for(Cell::CellList::iterator itr=cell->_cells.begin();
621            itr!=cell->_cells.end();
622            ++itr)
623        {
624            group->addChild(createBillboardGraph(itr->get(),stateset));
625        }
626       
627        if (billboard) group->addChild(billboard);
628       
629    }
630    if (group) return group;
631    else return billboard;
632}
633
634osg::Node* ForestTechniqueManager::createXGraph(Cell* cell,osg::StateSet* stateset)
635{
636    bool needGroup = !(cell->_cells.empty());
637    bool needTrees = !(cell->_trees.empty());
638   
639    osg::Geode* geode = 0;
640    osg::Group* group = 0;
641   
642    if (needTrees)
643    {
644        geode = new osg::Geode;
645        geode->setStateSet(stateset);
646       
647        for(TreeList::iterator itr=cell->_trees.begin();
648            itr!=cell->_trees.end();
649            ++itr)
650        {
651            Tree& tree = **itr;
652            geode->addDrawable(createOrthogonalQuads(tree._position,tree._width,tree._height,tree._color));
653        }
654    }
655   
656    if (needGroup)
657    {
658        group = new osg::Group;
659        for(Cell::CellList::iterator itr=cell->_cells.begin();
660            itr!=cell->_cells.end();
661            ++itr)
662        {
663            group->addChild(createXGraph(itr->get(),stateset));
664        }
665       
666        if (geode) group->addChild(geode);
667       
668    }
669    if (group) return group;
670    else return geode;
671}
672
673osg::Node* ForestTechniqueManager::createTransformGraph(Cell* cell,osg::StateSet* stateset)
674{
675    bool needGroup = !(cell->_cells.empty());
676    bool needTrees = !(cell->_trees.empty());
677   
678    osg::Group* transform_group = 0;
679    osg::Group* group = 0;
680   
681    if (needTrees)
682    {
683        transform_group = new osg::Group;
684       
685        osg::Geometry* geometry = createOrthogonalQuads(osg::Vec3(0.0f,0.0f,0.0f),1.0f,1.0f,osg::Vec4ub(255,255,255,255));
686       
687        for(TreeList::iterator itr=cell->_trees.begin();
688            itr!=cell->_trees.end();
689            ++itr)
690        {
691            Tree& tree = **itr;
692            osg::MatrixTransform* transform = new osg::MatrixTransform;
693            transform->setMatrix(osg::Matrix::scale(tree._width,tree._width,tree._height)*osg::Matrix::translate(tree._position));
694   
695            osg::Geode* geode = new osg::Geode;
696            geode->setStateSet(stateset);
697            geode->addDrawable(geometry);
698            transform->addChild(geode);
699            transform_group->addChild(transform);
700        }
701    }
702   
703    if (needGroup)
704    {
705        group = new osg::Group;
706        for(Cell::CellList::iterator itr=cell->_cells.begin();
707            itr!=cell->_cells.end();
708            ++itr)
709        {
710            group->addChild(createTransformGraph(itr->get(),stateset));
711        }
712       
713        if (transform_group) group->addChild(transform_group);
714       
715    }
716    if (group) return group;
717    else return transform_group;
718}
719
720osg::Geometry* ForestTechniqueManager::createOrthogonalQuadsNoColor( const osg::Vec3& pos, float w, float h)
721{
722    // set up the coords
723    osg::Vec3Array& v = *(new osg::Vec3Array(8));
724    osg::Vec2Array& t = *(new osg::Vec2Array(8));
725   
726    float rotation = random(0.0f,osg::PI/2.0f);
727    float sw = sinf(rotation)*w*0.5f;
728    float cw = cosf(rotation)*w*0.5f;
729
730    v[0].set(pos.x()-sw,pos.y()-cw,pos.z()+0.0f);
731    v[1].set(pos.x()+sw,pos.y()+cw,pos.z()+0.0f);
732    v[2].set(pos.x()+sw,pos.y()+cw,pos.z()+h);
733    v[3].set(pos.x()-sw,pos.y()-cw,pos.z()+h);
734
735    v[4].set(pos.x()-cw,pos.y()+sw,pos.z()+0.0f);
736    v[5].set(pos.x()+cw,pos.y()-sw,pos.z()+0.0f);
737    v[6].set(pos.x()+cw,pos.y()-sw,pos.z()+h);
738    v[7].set(pos.x()-cw,pos.y()+sw,pos.z()+h);
739
740    t[0].set(0.0f,0.0f);
741    t[1].set(1.0f,0.0f);
742    t[2].set(1.0f,1.0f);
743    t[3].set(0.0f,1.0f);
744
745    t[4].set(0.0f,0.0f);
746    t[5].set(1.0f,0.0f);
747    t[6].set(1.0f,1.0f);
748    t[7].set(0.0f,1.0f);
749
750    osg::Geometry *geom = new osg::Geometry;
751
752    geom->setVertexArray( &v );
753
754    geom->setTexCoordArray( 0, &t );
755
756    geom->addPrimitiveSet( new osg::DrawArrays(osg::PrimitiveSet::QUADS,0,8) );
757
758    return geom;
759}
760
761class ShaderGeometry : public osg::Drawable
762{
763    public:
764        ShaderGeometry() { setUseDisplayList(false); }
765
766        /** Copy constructor using CopyOp to manage deep vs shallow copy.*/
767        ShaderGeometry(const ShaderGeometry& ShaderGeometry,const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY):
768            osg::Drawable(ShaderGeometry,copyop) {}
769
770        META_Object(osg,ShaderGeometry)
771
772        typedef std::vector<osg::Vec4> PositionSizeList;
773       
774        virtual void drawImplementation(osg::RenderInfo& renderInfo) const
775        {
776            for(PositionSizeList::const_iterator itr = _trees.begin();
777                itr != _trees.end();
778                ++itr)
779            {
780                glColor4fv(itr->ptr());
781                _geometry->draw(renderInfo);
782            }
783        }
784
785        virtual osg::BoundingBox computeBound() const
786        {
787            osg::BoundingBox geom_box = _geometry->getBound();
788            osg::BoundingBox bb;
789            for(PositionSizeList::const_iterator itr = _trees.begin();
790                itr != _trees.end();
791                ++itr)
792            {
793                bb.expandBy(geom_box.corner(0)*(*itr)[3] +
794                            osg::Vec3( (*itr)[0], (*itr)[1], (*itr)[2] ));
795                bb.expandBy(geom_box.corner(7)*(*itr)[3] +
796                            osg::Vec3( (*itr)[0], (*itr)[1], (*itr)[2] ));
797            }
798            return bb;
799        }
800       
801        void setGeometry(osg::Geometry* geometry)
802        {
803            _geometry = geometry;
804        }
805       
806        void addTree(ForestTechniqueManager::Tree& tree)
807        {
808            _trees.push_back(osg::Vec4(tree._position.x(), tree._position.y(), tree._position.z(), tree._height));
809        }
810       
811        osg::ref_ptr<osg::Geometry> _geometry;
812
813        PositionSizeList _trees;
814
815    protected:
816   
817        virtual ~ShaderGeometry() {}
818       
819};
820
821osg::Geometry* shared_geometry = 0;
822
823osg::Node* ForestTechniqueManager::createShaderGraph(Cell* cell,osg::StateSet* stateset)
824{
825    if (shared_geometry==0)
826    {
827        shared_geometry = createOrthogonalQuadsNoColor(osg::Vec3(0.0f,0.0f,0.0f),1.0f,1.0f);
828        //shared_geometry->setUseDisplayList(false);
829    }
830
831
832    bool needGroup = !(cell->_cells.empty());
833    bool needTrees = !(cell->_trees.empty());
834   
835    osg::Geode* geode = 0;
836    osg::Group* group = 0;
837   
838    if (needTrees)
839    {
840        geode = new osg::Geode;
841       
842        ShaderGeometry* shader_geometry = new ShaderGeometry;
843        shader_geometry->setGeometry(shared_geometry);
844       
845       
846        for(TreeList::iterator itr=cell->_trees.begin();
847            itr!=cell->_trees.end();
848            ++itr)
849        {
850            Tree& tree = **itr;
851            shader_geometry->addTree(tree);
852
853        }
854
855        geode->setStateSet(stateset);
856        geode->addDrawable(shader_geometry);
857    }
858   
859    if (needGroup)
860    {
861        group = new osg::Group;
862        for(Cell::CellList::iterator itr=cell->_cells.begin();
863            itr!=cell->_cells.end();
864            ++itr)
865        {
866            group->addChild(createShaderGraph(itr->get(),stateset));
867        }
868       
869        if (geode) group->addChild(geode);
870       
871    }
872    if (group) return group;
873    else return geode;
874}
875
876osg::Node* ForestTechniqueManager::createHUDWithText(const std::string& str)
877{
878    osg::Geode* geode = new osg::Geode();
879   
880    std::string timesFont("fonts/arial.ttf");
881
882    // turn lighting off for the text and disable depth test to ensure its always ontop.
883    osg::StateSet* stateset = geode->getOrCreateStateSet();
884    stateset->setMode(GL_LIGHTING,osg::StateAttribute::OFF);
885
886    // or disable depth test, and make sure that the hud is drawn after everything
887    // else so that it always appears ontop.
888    stateset->setMode(GL_DEPTH_TEST,osg::StateAttribute::OFF);
889    stateset->setRenderBinDetails(11,"RenderBin");
890
891    osg::Vec3 position(150.0f,800.0f,0.0f);
892    osg::Vec3 delta(0.0f,-120.0f,0.0f);
893
894    {
895        osgText::Text* text = new  osgText::Text;
896        geode->addDrawable( text );
897
898        text->setFont(timesFont);
899        text->setPosition(position);
900        text->setText(str);
901       
902        position += delta;
903    }   
904
905   
906    // create the hud.
907    osg::MatrixTransform* modelview_abs = new osg::MatrixTransform;
908    modelview_abs->setReferenceFrame(osg::Transform::ABSOLUTE_RF);
909    modelview_abs->setMatrix(osg::Matrix::identity());
910    modelview_abs->addChild(geode);
911
912    osg::Projection* projection = new osg::Projection;
913    projection->setMatrix(osg::Matrix::ortho2D(0,1280,0,1024));
914    projection->addChild(modelview_abs);
915
916    return projection;
917}
918
919osg::Node* ForestTechniqueManager::createScene(unsigned int numTreesToCreates)
920{
921    osg::Vec3 origin(0.0f,0.0f,0.0f);
922    osg::Vec3 size(1000.0f,1000.0f,200.0f);
923
924    std::cout<<"Creating terrain...";
925    osg::ref_ptr<osg::Node> terrain = createTerrain(origin,size);
926    std::cout<<"done."<<std::endl;
927   
928    std::cout<<"Creating tree locations...";std::cout.flush();
929    TreeList trees;
930    createTreeList(terrain.get(),origin,size,numTreesToCreates,trees);
931    std::cout<<"done."<<std::endl;
932   
933    std::cout<<"Creating cell subdivision...";
934    osg::ref_ptr<Cell> cell = new Cell;
935    cell->addTrees(trees);
936    cell->divide();
937     std::cout<<"done."<<std::endl;
938   
939   
940    osg::Texture2D *tex = new osg::Texture2D;
941    tex->setWrap( osg::Texture2D::WRAP_S, osg::Texture2D::CLAMP );
942    tex->setWrap( osg::Texture2D::WRAP_T, osg::Texture2D::CLAMP );
943    tex->setImage(osgDB::readImageFile("Images/tree0.rgba"));
944
945    osg::StateSet *dstate = new osg::StateSet;
946    {   
947        dstate->setTextureAttributeAndModes(0, tex, osg::StateAttribute::ON );
948        dstate->setTextureAttribute(0, new osg::TexEnv );
949
950        dstate->setAttributeAndModes( new osg::BlendFunc, osg::StateAttribute::ON );
951
952        osg::AlphaFunc* alphaFunc = new osg::AlphaFunc;
953        alphaFunc->setFunction(osg::AlphaFunc::GEQUAL,0.05f);
954        dstate->setAttributeAndModes( alphaFunc, osg::StateAttribute::ON );
955
956        dstate->setMode( GL_LIGHTING, osg::StateAttribute::OFF );
957
958        dstate->setRenderingHint( osg::StateSet::TRANSPARENT_BIN );
959    }
960   
961
962    _techniqueSwitch = new osg::Switch;
963
964    {
965        std::cout<<"Creating billboard based forest...";
966        osg::Group* group = new osg::Group;
967        group->addChild(createBillboardGraph(cell.get(),dstate));
968        group->addChild(createHUDWithText("Using osg::Billboard's to create a forest\n\nPress left cursor key to select OpenGL shader based forest\nPress right cursor key to select double quad based forest"));
969        _techniqueSwitch->addChild(group);
970        std::cout<<"done."<<std::endl;
971    }
972   
973    {
974        std::cout<<"Creating billboard based forest...";
975        osg::Group* group = new osg::Group;
976        group->addChild(createXGraph(cell.get(),dstate));
977        group->addChild(createHUDWithText("Using double quads to create a forest\n\nPress left cursor key to select osg::Billboard based forest\nPress right cursor key to select osg::MatrixTransform based forest\n"));
978        _techniqueSwitch->addChild(group);
979        std::cout<<"done."<<std::endl;
980    }
981
982    {
983        std::cout<<"Creating billboard based forest...";
984        osg::Group* group = new osg::Group;
985        group->addChild(createTransformGraph(cell.get(),dstate));
986        group->addChild(createHUDWithText("Using osg::MatrixTransform's to create a forest\n\nPress left cursor key to select double quad based forest\nPress right cursor key to select OpenGL shder based forest"));
987        _techniqueSwitch->addChild(group);
988        std::cout<<"done."<<std::endl;
989    }
990
991    {
992        osg::Group* group = new osg::Group;
993       
994
995        osg::StateSet* stateset = new osg::StateSet;
996
997        stateset->setTextureAttributeAndModes(0, tex, osg::StateAttribute::ON );
998        stateset->setRenderingHint( osg::StateSet::TRANSPARENT_BIN );
999
1000        {
1001            osg::Program* program = new osg::Program;
1002            stateset->setAttribute(program);
1003
1004#if 1
1005            // use inline shaders
1006           
1007            ///////////////////////////////////////////////////////////////////
1008            // vertex shader using just Vec4 coefficients
1009            char vertexShaderSource[] =
1010                "varying vec2 texcoord;\n"
1011                "\n"
1012                "void main(void)\n"
1013                "{\n"
1014                "    vec3 position = gl_Vertex.xyz * gl_Color.w + gl_Color.xyz;\n"
1015                "    gl_Position     = gl_ModelViewProjectionMatrix * vec4(position,1.0);\n"
1016                "    gl_FrontColor = vec4(1.0,1.0,1.0,1.0);\n"
1017                "    texcoord = gl_MultiTexCoord0.st;\n"
1018                "}\n";
1019
1020            //////////////////////////////////////////////////////////////////
1021            // fragment shader
1022            //
1023            char fragmentShaderSource[] =
1024                "uniform sampler2D baseTexture; \n"
1025                "varying vec2 texcoord; \n"
1026                "\n"
1027                "void main(void) \n"
1028                "{ \n"
1029                "    gl_FragColor = texture2D( baseTexture, texcoord); \n"
1030                "}\n";
1031
1032            osg::Shader* vertex_shader = new osg::Shader(osg::Shader::VERTEX, vertexShaderSource);
1033            program->addShader(vertex_shader);
1034
1035            osg::Shader* fragment_shader = new osg::Shader(osg::Shader::FRAGMENT, fragmentShaderSource);
1036            program->addShader(fragment_shader);
1037           
1038#else
1039
1040            // get shaders from source
1041            program->addShader(osg::Shader::readShaderFile(osg::Shader::VERTEX, osgDB::findDataFile("shaders/forest.vert")));
1042            program->addShader(osg::Shader::readShaderFile(osg::Shader::FRAGMENT, osgDB::findDataFile("shaders/forest.frag")));
1043
1044#endif
1045
1046            osg::Uniform* baseTextureSampler = new osg::Uniform("baseTexture",0);
1047            stateset->addUniform(baseTextureSampler);
1048        }
1049
1050        std::cout<<"Creating billboard based forest...";
1051        group->addChild(createShaderGraph(cell.get(),stateset));
1052        group->addChild(createHUDWithText("Using OpenGL Shader to create a forest\n\nPress left cursor key to select osg::MatrixTransform based forest\nPress right cursor key to select osg::Billboard based forest"));
1053        _techniqueSwitch->addChild(group);
1054        std::cout<<"done."<<std::endl;
1055    }
1056
1057    _currentTechnique = 0;
1058    _techniqueSwitch->setSingleChildOn(_currentTechnique);
1059   
1060
1061    osg::Group* scene = new osg::Group;
1062   
1063    scene->addChild(terrain.get());
1064    scene->addChild(_techniqueSwitch.get());
1065
1066    return scene;
1067}
1068
1069int main( int argc, char **argv )
1070{
1071
1072    // use an ArgumentParser object to manage the program arguments.
1073    osg::ArgumentParser arguments(&argc,argv);
1074   
1075    // construct the viewer.
1076    osgViewer::Viewer viewer;
1077
1078    float numTreesToCreates = 10000;
1079    arguments.read("--trees",numTreesToCreates);
1080   
1081    osg::ref_ptr<ForestTechniqueManager> ttm = new ForestTechniqueManager;
1082   
1083    viewer.addEventHandler(new TechniqueEventHandler(ttm.get()));
1084
1085    // add model to viewer.
1086    viewer.setSceneData( ttm->createScene((unsigned int)numTreesToCreates) );
1087
1088
1089    return viewer.run();
1090}
Note: See TracBrowser for help on using the browser.