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

Revision 3896, 27.1 kB (checked in by robert, 9 years ago)

Fixed old handle(..) method call parameters

  • 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
17#include <osgDB/ReadFile>
18
19#include <osgUtil/IntersectVisitor>
20#include <osgUtil/SmoothingVisitor>
21
22#include <osgText/Text>
23
24#include <osgProducer/Viewer>
25
26// for the grid data..
27#include "../osghangglide/terrain_coords.h"
28
29// class to create the forest and manage the movement between various techniques.
30class ForestTechniqueManager : public osg::Referenced
31{
32public:
33
34    ForestTechniqueManager() {}
35
36    class Tree : public osg::Referenced
37    {
38    public:
39
40        Tree():
41            _color(255,255,255,255),
42            _width(1.0f),
43            _height(1.0f),
44            _type(0) {}
45
46        Tree(const osg::Vec3& position, const osg::UByte4& color, float width, float height, unsigned int type):
47            _position(position),
48            _color(color),
49            _width(width),
50            _height(height),
51            _type(type) {}
52
53        osg::Vec3       _position;
54        osg::UByte4     _color;
55        float           _width;
56        float           _height;
57        unsigned int    _type;
58    };
59   
60    typedef std::vector< osg::ref_ptr<Tree> > TreeList;
61   
62    class Cell : public osg::Referenced
63    {
64    public:
65        typedef std::vector< osg::ref_ptr<Cell> > CellList;
66
67        Cell():_parent(0) {}
68        Cell(osg::BoundingBox& bb):_parent(0), _bb(bb) {}
69       
70        void addCell(Cell* cell) { cell->_parent=this; _cells.push_back(cell); }
71
72        void addTree(Tree* tree) { _trees.push_back(tree); }
73       
74        void addTrees(const TreeList& trees) { _trees.insert(_trees.end(),trees.begin(),trees.end()); }
75       
76        void computeBound();
77       
78        bool contains(const osg::Vec3& position) const { return _bb.contains(position); }
79       
80        bool divide(unsigned int maxNumTreesPerCell=10);
81       
82        bool devide(bool xAxis, bool yAxis, bool zAxis);
83       
84        void bin();
85
86
87        Cell*               _parent;
88        osg::BoundingBox    _bb;
89        CellList            _cells;
90        TreeList            _trees;
91       
92    };
93
94    float random(float min,float max) { return min + (max-min)*(float)rand()/(float)RAND_MAX; }
95    int random(int min,int max) { return min + (int)((float)(max-min)*(float)rand()/(float)RAND_MAX); }
96
97    osg::Geode* createTerrain(const osg::Vec3& origin, const osg::Vec3& size);
98
99    void createTreeList(osg::Node* terrain,const osg::Vec3& origin, const osg::Vec3& size,unsigned int numTreesToCreate,TreeList& trees);
100
101    osg::Geometry* createSprite( float w, float h, osg::UByte4 color );
102
103    osg::Geometry* createOrthogonalQuads( const osg::Vec3& pos, float w, float h, osg::UByte4 color );
104
105    osg::Node* createBillboardGraph(Cell* cell,osg::StateSet* stateset);
106
107    osg::Node* createXGraph(Cell* cell,osg::StateSet* stateset);
108
109    osg::Node* createTransformGraph(Cell* cell,osg::StateSet* stateset);
110   
111    osg::Node* createHUDWithText(const std::string& text);
112
113    osg::Node* createScene(unsigned int numTreesToCreates);
114   
115    void advanceToNextTechnique(int delta=1)
116    {
117        if (_techniqueSwitch.valid())
118        {
119            _currentTechnique += delta;
120            if (_currentTechnique<0)
121                _currentTechnique = _techniqueSwitch->getNumChildren()-1;
122            if (_currentTechnique>=(int)_techniqueSwitch->getNumChildren())
123                _currentTechnique = 0;
124            _techniqueSwitch->setSingleChildOn(_currentTechnique);
125        }
126    }
127   
128    osg::ref_ptr<osg::Switch>   _techniqueSwitch;
129    int                         _currentTechnique;
130   
131
132};
133
134// event handler to capture keyboard events and use them to advance the technique used for rendering
135class TechniqueEventHandler : public osgGA::GUIEventHandler, public osg::NodeCallback
136{
137public:
138
139    TechniqueEventHandler(ForestTechniqueManager* ttm=0) { _ForestTechniqueManager = ttm; }
140   
141    META_Object(osgforestApp,TechniqueEventHandler);
142
143    virtual void accept(osgGA::GUIEventHandlerVisitor& v) { v.visit(*this); }
144
145    virtual bool handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter&, osg::Object*, osg::NodeVisitor*);
146   
147    virtual void getUsage(osg::ApplicationUsage& usage) const;
148
149protected:
150
151    ~TechniqueEventHandler() {}
152   
153    TechniqueEventHandler(const TechniqueEventHandler&,const osg::CopyOp&) {}
154   
155    osg::ref_ptr<ForestTechniqueManager> _ForestTechniqueManager;
156
157       
158};
159
160bool TechniqueEventHandler::handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter&, osg::Object*, osg::NodeVisitor*)
161{
162    switch(ea.getEventType())
163    {
164        case(osgGA::GUIEventAdapter::KEYDOWN):
165        {
166            if (ea.getKey()=='n' ||
167                ea.getKey()==osgGA::GUIEventAdapter::KEY_Right ||
168                ea.getKey()==osgGA::GUIEventAdapter::KEY_KP_Right)
169            {
170                _ForestTechniqueManager->advanceToNextTechnique(1);
171                return true;
172            }
173            else if (ea.getKey()=='p' ||
174                     ea.getKey()==osgGA::GUIEventAdapter::KEY_Left ||
175                     ea.getKey()==osgGA::GUIEventAdapter::KEY_KP_Left)
176            {
177                _ForestTechniqueManager->advanceToNextTechnique(-1);
178                return true;
179            }
180            return false;
181        }
182
183        default:
184            return false;
185    }
186}
187
188void TechniqueEventHandler::getUsage(osg::ApplicationUsage& usage) const
189{
190    usage.addKeyboardMouseBinding("n or Left Arrow","Advance to next technique");
191    usage.addKeyboardMouseBinding("p or Right Array","Move to previous technique");
192}
193
194
195void ForestTechniqueManager::Cell::computeBound()
196{
197    _bb.init();
198    for(CellList::iterator citr=_cells.begin();
199        citr!=_cells.end();
200        ++citr)
201    {
202        (*citr)->computeBound();
203        _bb.expandBy((*citr)->_bb);
204    }
205
206    for(TreeList::iterator titr=_trees.begin();
207        titr!=_trees.end();
208        ++titr)
209    {
210        _bb.expandBy((*titr)->_position);
211    }
212}
213
214bool ForestTechniqueManager::Cell::divide(unsigned int maxNumTreesPerCell)
215{
216
217    if (_trees.size()<=maxNumTreesPerCell) return false;
218
219    computeBound();
220
221    float radius = _bb.radius();
222    float divide_distance = radius*0.7f;
223    if (devide((_bb.xMax()-_bb.xMin())>divide_distance,(_bb.yMax()-_bb.yMin())>divide_distance,(_bb.zMax()-_bb.zMin())>divide_distance))
224    {
225        // recusively divide the new cells till maxNumTreesPerCell is met.
226        for(CellList::iterator citr=_cells.begin();
227            citr!=_cells.end();
228            ++citr)
229        {
230            (*citr)->divide(maxNumTreesPerCell);
231        }
232        return true;
233   }
234   else
235   {
236        return false;
237   }
238}
239
240bool ForestTechniqueManager::Cell::devide(bool xAxis, bool yAxis, bool zAxis)
241{
242    if (!(xAxis || yAxis || zAxis)) return false;
243
244    if (_cells.empty())
245        _cells.push_back(new Cell(_bb));
246
247    if (xAxis)
248    {
249        unsigned int numCellsToDivide=_cells.size();
250        for(unsigned int i=0;i<numCellsToDivide;++i)
251        {
252            Cell* orig_cell = _cells[i].get();
253            Cell* new_cell = new Cell(orig_cell->_bb);
254
255            float xCenter = (orig_cell->_bb.xMin()+orig_cell->_bb.xMax())*0.5f;
256            orig_cell->_bb.xMax() = xCenter;
257            new_cell->_bb.xMin() = xCenter;
258
259            _cells.push_back(new_cell);
260        }
261    }
262
263    if (yAxis)
264    {
265        unsigned int numCellsToDivide=_cells.size();
266        for(unsigned int i=0;i<numCellsToDivide;++i)
267        {
268            Cell* orig_cell = _cells[i].get();
269            Cell* new_cell = new Cell(orig_cell->_bb);
270
271            float yCenter = (orig_cell->_bb.yMin()+orig_cell->_bb.yMax())*0.5f;
272            orig_cell->_bb.yMax() = yCenter;
273            new_cell->_bb.yMin() = yCenter;
274
275            _cells.push_back(new_cell);
276        }
277    }
278
279    if (zAxis)
280    {
281        unsigned int numCellsToDivide=_cells.size();
282        for(unsigned int i=0;i<numCellsToDivide;++i)
283        {
284            Cell* orig_cell = _cells[i].get();
285            Cell* new_cell = new Cell(orig_cell->_bb);
286
287            float zCenter = (orig_cell->_bb.zMin()+orig_cell->_bb.zMax())*0.5f;
288            orig_cell->_bb.zMax() = zCenter;
289            new_cell->_bb.zMin() = zCenter;
290
291            _cells.push_back(new_cell);
292        }
293    }
294
295    bin();
296
297    return true;
298
299}
300
301void ForestTechniqueManager::Cell::bin()
302{   
303    // put trees in apprpriate cells.
304    TreeList treesNotAssigned;
305    for(TreeList::iterator titr=_trees.begin();
306        titr!=_trees.end();
307        ++titr)
308    {
309        Tree* tree = titr->get();
310        bool assigned = false;
311        for(CellList::iterator citr=_cells.begin();
312            citr!=_cells.end() && !assigned;
313            ++citr)
314        {
315            if ((*citr)->contains(tree->_position))
316            {
317                (*citr)->addTree(tree);
318                assigned = true;
319            }
320        }
321        if (!assigned) treesNotAssigned.push_back(tree);
322    }
323
324    // put the unassigned trees back into the original local tree list.
325    _trees.swap(treesNotAssigned);
326
327
328    // prune empty cells.
329    CellList cellsNotEmpty;
330    for(CellList::iterator citr=_cells.begin();
331        citr!=_cells.end();
332        ++citr)
333    {
334        if (!((*citr)->_trees.empty()))
335        {
336            cellsNotEmpty.push_back(*citr);
337        }
338    }
339    _cells.swap(cellsNotEmpty);
340
341
342}
343
344osg::Geode* ForestTechniqueManager::createTerrain(const osg::Vec3& origin, const osg::Vec3& size)
345{
346    osg::Geode* geode = new osg::Geode();
347
348    // ---------------------------------------
349    // Set up a StateSet to texture the objects
350    // ---------------------------------------
351    osg::StateSet* stateset = new osg::StateSet();
352
353    osg::Image* image = osgDB::readImageFile("Images/lz.rgb");
354    if (image)
355    {
356        osg::Texture2D* texture = new osg::Texture2D;
357        texture->setImage(image);
358        stateset->setTextureAttributeAndModes(0,texture,osg::StateAttribute::ON);
359    }
360   
361    geode->setStateSet( stateset );
362   
363    unsigned int numColumns = 38;
364    unsigned int numRows = 39;
365    unsigned int r;
366    unsigned int c;
367
368    // compute z range of z values of grid data so we can scale it.
369    float min_z = FLT_MAX;
370    float max_z = -FLT_MAX;
371    for(r=0;r<numRows;++r)
372    {
373        for(c=0;c<numColumns;++c)
374        {
375            min_z = osg::minimum(min_z,vertex[r+c*numRows][2]);
376            max_z = osg::maximum(max_z,vertex[r+c*numRows][2]);
377        }
378    }
379   
380    float scale_z = size.z()/(max_z-min_z);
381
382
383    bool createGrid = false;
384    if (createGrid)
385    {
386
387        osg::HeightField* grid = new osg::HeightField;
388        grid->allocateGrid(numColumns,numRows);
389        grid->setOrigin(origin);
390        grid->setXInterval(size.x()/(float)(numColumns-1));
391        grid->setYInterval(size.y()/(float)(numRows-1));
392
393        for(r=0;r<numRows;++r)
394        {
395            for(c=0;c<numColumns;++c)
396            {
397                grid->setHeight(c,r,(vertex[r+c*numRows][2]-min_z)*scale_z);
398            }
399        }
400       
401        geode->addDrawable(new osg::ShapeDrawable(grid));
402    }
403    else
404    {
405        osg::Geometry* geometry = new osg::Geometry;
406       
407        osg::Vec3Array& v = *(new osg::Vec3Array(numColumns*numRows));
408        osg::Vec2Array& t = *(new osg::Vec2Array(numColumns*numRows));
409        osg::UByte4Array& color = *(new osg::UByte4Array(1));
410       
411        color[0].set(255,255,255,255);
412
413        float rowCoordDelta = size.y()/(float)(numRows-1);
414        float columnCoordDelta = size.x()/(float)(numColumns-1);
415       
416        float rowTexDelta = 1.0f/(float)(numRows-1);
417        float columnTexDelta = 1.0f/(float)(numColumns-1);
418
419        osg::Vec3 pos = origin;
420        osg::Vec2 tex(0.0f,0.0f);
421        int vi=0;
422        for(r=0;r<numRows;++r)
423        {
424            pos.x() = origin.x();
425            tex.x() = 0.0f;
426            for(c=0;c<numColumns;++c)
427            {
428                v[vi].set(pos.x(),pos.y(),pos.z()+(vertex[r+c*numRows][2]-min_z)*scale_z);
429                t[vi].set(tex.x(),tex.y());
430                pos.x()+=columnCoordDelta;
431                tex.x()+=columnTexDelta;
432                ++vi;
433            }
434            pos.y() += rowCoordDelta;
435            tex.y() += rowTexDelta;
436        }
437       
438        geometry->setVertexArray(&v);
439        geometry->setColorArray(&color);
440        geometry->setColorBinding(osg::Geometry::BIND_OVERALL);
441        geometry->setTexCoordArray(0,&t);
442       
443        for(r=0;r<numRows-1;++r)
444        {
445            osg::DrawElementsUShort& drawElements = *(new osg::DrawElementsUShort(GL_QUAD_STRIP,2*numColumns));
446            geometry->addPrimitiveSet(&drawElements);
447            int ei=0;
448            for(c=0;c<numColumns;++c)
449            {
450                drawElements[ei++] = (r+1)*numColumns+c;
451                drawElements[ei++] = (r)*numColumns+c;
452            }
453        }
454       
455        geode->addDrawable(geometry);
456       
457        osgUtil::SmoothingVisitor sv;
458        sv.smooth(*geometry);
459    }
460   
461    return geode;
462}
463
464void ForestTechniqueManager::createTreeList(osg::Node* terrain,const osg::Vec3& origin, const osg::Vec3& size,unsigned int numTreesToCreate,TreeList& trees)
465{
466
467    float max_TreeHeight = sqrtf(size.length2()/(float)numTreesToCreate);
468    float max_TreeWidth = max_TreeHeight*0.5f;
469   
470    float min_TreeHeight = max_TreeHeight*0.3f;
471    float min_TreeWidth = min_TreeHeight*0.5f;
472
473    trees.reserve(trees.size()+numTreesToCreate);
474
475
476    for(unsigned int i=0;i<numTreesToCreate;++i)
477    {
478        Tree* tree = new Tree;
479        tree->_position.set(random(origin.x(),origin.x()+size.x()),random(origin.y(),origin.y()+size.y()),origin.z());
480        tree->_color.set(random(128,255),random(128,255),random(128,255),255);
481        tree->_width = random(min_TreeWidth,max_TreeWidth);
482        tree->_height = random(min_TreeHeight,max_TreeHeight);
483        tree->_type = 0;
484       
485        if (terrain)
486        {
487            osgUtil::IntersectVisitor iv;
488            osg::ref_ptr<osg::LineSegment> segDown = new osg::LineSegment;
489
490            segDown->set(tree->_position,tree->_position+osg::Vec3(0.0f,0.0f,size.z()));
491            iv.addLineSegment(segDown.get());
492           
493            terrain->accept(iv);
494
495            if (iv.hits())
496            {
497                osgUtil::IntersectVisitor::HitList& hitList = iv.getHitList(segDown.get());
498                if (!hitList.empty())
499                {
500                    osg::Vec3 ip = hitList.front().getWorldIntersectPoint();
501                    osg::Vec3 np = hitList.front().getWorldIntersectNormal();
502                    tree->_position = ip;
503                }
504            }
505        }
506       
507        trees.push_back(tree);
508    }
509}
510
511osg::Geometry* ForestTechniqueManager::createSprite( float w, float h, osg::UByte4 color )
512{
513    // set up the coords
514    osg::Vec3Array& v = *(new osg::Vec3Array(4));
515    osg::Vec2Array& t = *(new osg::Vec2Array(4));
516    osg::UByte4Array& c = *(new osg::UByte4Array(1));
517
518    v[0].set(-w*0.5f,0.0f,0.0f);
519    v[1].set( w*0.5f,0.0f,0.0f);
520    v[2].set( w*0.5f,0.0f,h);
521    v[3].set(-w*0.5f,0.0f,h);
522
523    c[0] = color;
524
525    t[0].set(0.0f,0.0f);
526    t[1].set(1.0f,0.0f);
527    t[2].set(1.0f,1.0f);
528    t[3].set(0.0f,1.0f);
529
530    osg::Geometry *geom = new osg::Geometry;
531
532    geom->setVertexArray( &v );
533
534    geom->setTexCoordArray( 0, &t );
535
536    geom->setColorArray( &c );
537    geom->setColorBinding( osg::Geometry::BIND_OVERALL );
538
539    geom->addPrimitiveSet( new osg::DrawArrays(osg::PrimitiveSet::QUADS,0,4) );
540
541    return geom;
542}
543
544osg::Geometry* ForestTechniqueManager::createOrthogonalQuads( const osg::Vec3& pos, float w, float h, osg::UByte4 color )
545{
546    // set up the coords
547    osg::Vec3Array& v = *(new osg::Vec3Array(8));
548    osg::Vec2Array& t = *(new osg::Vec2Array(8));
549    osg::UByte4Array& c = *(new osg::UByte4Array(1));
550   
551    float rotation = random(0.0f,osg::PI/2.0f);
552    float sw = sinf(rotation)*w*0.5f;
553    float cw = cosf(rotation)*w*0.5f;
554
555    v[0].set(pos.x()-sw,pos.y()-cw,pos.z()+0.0f);
556    v[1].set(pos.x()+sw,pos.y()+cw,pos.z()+0.0f);
557    v[2].set(pos.x()+sw,pos.y()+cw,pos.z()+h);
558    v[3].set(pos.x()-sw,pos.y()-cw,pos.z()+h);
559
560    v[4].set(pos.x()-cw,pos.y()+sw,pos.z()+0.0f);
561    v[5].set(pos.x()+cw,pos.y()-sw,pos.z()+0.0f);
562    v[6].set(pos.x()+cw,pos.y()-sw,pos.z()+h);
563    v[7].set(pos.x()-cw,pos.y()+sw,pos.z()+h);
564
565    c[0] = color;
566
567    t[0].set(0.0f,0.0f);
568    t[1].set(1.0f,0.0f);
569    t[2].set(1.0f,1.0f);
570    t[3].set(0.0f,1.0f);
571
572    t[4].set(0.0f,0.0f);
573    t[5].set(1.0f,0.0f);
574    t[6].set(1.0f,1.0f);
575    t[7].set(0.0f,1.0f);
576
577    osg::Geometry *geom = new osg::Geometry;
578
579    geom->setVertexArray( &v );
580
581    geom->setTexCoordArray( 0, &t );
582
583    geom->setColorArray( &c );
584    geom->setColorBinding( osg::Geometry::BIND_OVERALL );
585
586    geom->addPrimitiveSet( new osg::DrawArrays(osg::PrimitiveSet::QUADS,0,8) );
587
588    return geom;
589}
590
591osg::Node* ForestTechniqueManager::createBillboardGraph(Cell* cell,osg::StateSet* stateset)
592{
593    bool needGroup = !(cell->_cells.empty());
594    bool needBillboard = !(cell->_trees.empty());
595   
596    osg::Billboard* billboard = 0;
597    osg::Group* group = 0;
598   
599    if (needBillboard)
600    {
601        billboard = new osg::Billboard;
602        billboard->setStateSet(stateset);
603        for(TreeList::iterator itr=cell->_trees.begin();
604            itr!=cell->_trees.end();
605            ++itr)
606        {
607            Tree& tree = **itr;
608            billboard->addDrawable(createSprite(tree._width,tree._height,tree._color),tree._position);   
609        }
610    }
611   
612    if (needGroup)
613    {
614        group = new osg::Group;
615        for(Cell::CellList::iterator itr=cell->_cells.begin();
616            itr!=cell->_cells.end();
617            ++itr)
618        {
619            group->addChild(createBillboardGraph(itr->get(),stateset));
620        }
621       
622        if (billboard) group->addChild(billboard);
623       
624    }
625    if (group) return group;
626    else return billboard;
627}
628
629osg::Node* ForestTechniqueManager::createXGraph(Cell* cell,osg::StateSet* stateset)
630{
631    bool needGroup = !(cell->_cells.empty());
632    bool needTrees = !(cell->_trees.empty());
633   
634    osg::Geode* geode = 0;
635    osg::Group* group = 0;
636   
637    if (needTrees)
638    {
639        geode = new osg::Geode;
640        geode->setStateSet(stateset);
641       
642        for(TreeList::iterator itr=cell->_trees.begin();
643            itr!=cell->_trees.end();
644            ++itr)
645        {
646            Tree& tree = **itr;
647            geode->addDrawable(createOrthogonalQuads(tree._position,tree._width,tree._height,tree._color));
648        }
649    }
650   
651    if (needGroup)
652    {
653        group = new osg::Group;
654        for(Cell::CellList::iterator itr=cell->_cells.begin();
655            itr!=cell->_cells.end();
656            ++itr)
657        {
658            group->addChild(createXGraph(itr->get(),stateset));
659        }
660       
661        if (geode) group->addChild(geode);
662       
663    }
664    if (group) return group;
665    else return geode;
666}
667
668osg::Node* ForestTechniqueManager::createTransformGraph(Cell* cell,osg::StateSet* stateset)
669{
670    bool needGroup = !(cell->_cells.empty());
671    bool needTrees = !(cell->_trees.empty());
672   
673    osg::Group* transform_group = 0;
674    osg::Group* group = 0;
675   
676    if (needTrees)
677    {
678        transform_group = new osg::Group;
679       
680        osg::Geometry* geometry = createOrthogonalQuads(osg::Vec3(0.0f,0.0f,0.0f),1.0f,1.0f,osg::UByte4(255,255,255,255));
681       
682        for(TreeList::iterator itr=cell->_trees.begin();
683            itr!=cell->_trees.end();
684            ++itr)
685        {
686            Tree& tree = **itr;
687            osg::MatrixTransform* transform = new osg::MatrixTransform;
688            transform->setMatrix(osg::Matrix::scale(tree._width,tree._width,tree._height)*osg::Matrix::translate(tree._position));
689   
690            osg::Geode* geode = new osg::Geode;
691            geode->setStateSet(stateset);
692            geode->addDrawable(geometry);
693            transform->addChild(geode);
694            transform_group->addChild(transform);
695        }
696    }
697   
698    if (needGroup)
699    {
700        group = new osg::Group;
701        for(Cell::CellList::iterator itr=cell->_cells.begin();
702            itr!=cell->_cells.end();
703            ++itr)
704        {
705            group->addChild(createTransformGraph(itr->get(),stateset));
706        }
707       
708        if (transform_group) group->addChild(transform_group);
709       
710    }
711    if (group) return group;
712    else return transform_group;
713}
714
715osg::Node* ForestTechniqueManager::createHUDWithText(const std::string& str)
716{
717    osg::Geode* geode = new osg::Geode();
718   
719    std::string timesFont("fonts/arial.ttf");
720
721    // turn lighting off for the text and disable depth test to ensure its always ontop.
722    osg::StateSet* stateset = geode->getOrCreateStateSet();
723    stateset->setMode(GL_LIGHTING,osg::StateAttribute::OFF);
724
725    // or disable depth test, and make sure that the hud is drawn after everything
726    // else so that it always appears ontop.
727    stateset->setMode(GL_DEPTH_TEST,osg::StateAttribute::OFF);
728    stateset->setRenderBinDetails(11,"RenderBin");
729
730    osg::Vec3 position(150.0f,800.0f,0.0f);
731    osg::Vec3 delta(0.0f,-120.0f,0.0f);
732
733    {
734        osgText::Text* text = new  osgText::Text;
735        geode->addDrawable( text );
736
737        text->setFont(timesFont);
738        text->setPosition(position);
739        text->setText(str);
740       
741        position += delta;
742    }   
743
744   
745    // create the hud.
746    osg::MatrixTransform* modelview_abs = new osg::MatrixTransform;
747    modelview_abs->setReferenceFrame(osg::Transform::ABSOLUTE_RF);
748    modelview_abs->setMatrix(osg::Matrix::identity());
749    modelview_abs->addChild(geode);
750
751    osg::Projection* projection = new osg::Projection;
752    projection->setMatrix(osg::Matrix::ortho2D(0,1280,0,1024));
753    projection->addChild(modelview_abs);
754
755    return projection;
756}
757
758osg::Node* ForestTechniqueManager::createScene(unsigned int numTreesToCreates)
759{
760    osg::Vec3 origin(0.0f,0.0f,0.0f);
761    osg::Vec3 size(1000.0f,1000.0f,200.0f);
762
763    std::cout<<"Creating terrain...";
764    osg::ref_ptr<osg::Node> terrain = createTerrain(origin,size);
765    std::cout<<"done."<<std::endl;
766   
767    std::cout<<"Creating tree locations...";std::cout.flush();
768    TreeList trees;
769    createTreeList(terrain.get(),origin,size,numTreesToCreates,trees);
770    std::cout<<"done."<<std::endl;
771   
772    std::cout<<"Creating cell subdivision...";
773    osg::ref_ptr<Cell> cell = new Cell;
774    cell->addTrees(trees);
775    cell->divide();
776     std::cout<<"done."<<std::endl;
777   
778   
779    osg::Texture2D *tex = new osg::Texture2D;
780    tex->setWrap( osg::Texture2D::WRAP_S, osg::Texture2D::CLAMP );
781    tex->setWrap( osg::Texture2D::WRAP_T, osg::Texture2D::CLAMP );
782    tex->setImage(osgDB::readImageFile("Images/tree0.rgba"));
783
784    osg::StateSet *dstate = new osg::StateSet;
785    {   
786        dstate->setTextureAttributeAndModes(0, tex, osg::StateAttribute::ON );
787        dstate->setTextureAttribute(0, new osg::TexEnv );
788
789        dstate->setAttributeAndModes( new osg::BlendFunc, osg::StateAttribute::ON );
790
791        osg::AlphaFunc* alphaFunc = new osg::AlphaFunc;
792        alphaFunc->setFunction(osg::AlphaFunc::GEQUAL,0.05f);
793        dstate->setAttributeAndModes( alphaFunc, osg::StateAttribute::ON );
794
795        dstate->setMode( GL_LIGHTING, osg::StateAttribute::OFF );
796
797        dstate->setRenderingHint( osg::StateSet::TRANSPARENT_BIN );
798    }
799   
800
801    _techniqueSwitch = new osg::Switch;
802   
803    {
804        std::cout<<"Creating billboard based forest...";
805        osg::Group* group = new osg::Group;
806        group->addChild(createBillboardGraph(cell.get(),dstate));
807        group->addChild(createHUDWithText("Using osg::Billboard's to create a forest\n\nPress left cursor key to select osg::MatrixTransform based forest\nPress right cursor key to select double quad based forest"));
808        _techniqueSwitch->addChild(group);
809        std::cout<<"done."<<std::endl;
810    }
811   
812    {
813        std::cout<<"Creating billboard based forest...";
814        osg::Group* group = new osg::Group;
815        group->addChild(createXGraph(cell.get(),dstate));
816        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"));
817        _techniqueSwitch->addChild(group);
818        std::cout<<"done."<<std::endl;
819    }
820
821    {
822        std::cout<<"Creating billboard based forest...";
823        osg::Group* group = new osg::Group;
824        group->addChild(createTransformGraph(cell.get(),dstate));
825        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 osg::Billboard based forest"));
826        _techniqueSwitch->addChild(group);
827        std::cout<<"done."<<std::endl;
828    }
829   
830    _currentTechnique = 0;
831    _techniqueSwitch->setSingleChildOn(_currentTechnique);
832   
833
834    osg::Group* scene = new osg::Group;
835   
836    scene->addChild(terrain.get());
837    scene->addChild(_techniqueSwitch.get());
838
839    return scene;
840}
841
842int main( int argc, char **argv )
843{
844
845    // use an ArgumentParser object to manage the program arguments.
846    osg::ArgumentParser arguments(&argc,argv);
847
848    // set up the usage document, in case we need to print out how to use this program.
849    arguments.getApplicationUsage()->setDescription(arguments.getApplicationName()+" is the example which demonstrates the osg::Shape classes.");
850    arguments.getApplicationUsage()->setCommandLineUsage(arguments.getApplicationName()+" [options] filename ...");
851    arguments.getApplicationUsage()->addCommandLineOption("-h or --help","Display this information");
852    arguments.getApplicationUsage()->addCommandLineOption("--trees <number>","Set the number of trees to create");
853   
854    // construct the viewer.
855    osgProducer::Viewer viewer(arguments);
856
857    float numTreesToCreates = 10000;
858    arguments.read("--trees",numTreesToCreates);
859
860    // set up the value with sensible default event handlers.
861    viewer.setUpViewer(osgProducer::Viewer::STANDARD_SETTINGS);
862   
863    osg::ref_ptr<ForestTechniqueManager> ttm = new ForestTechniqueManager;
864   
865    viewer.getEventHandlerList().push_front(new TechniqueEventHandler(ttm.get()));
866
867    // get details on keyboard and mouse bindings used by the viewer.
868    viewer.getUsage(*arguments.getApplicationUsage());
869
870    // if user request help write it out to cout.
871    if (arguments.read("-h") || arguments.read("--help"))
872    {
873        arguments.getApplicationUsage()->write(std::cout);
874        return 1;
875    }
876
877    // any option left unread are converted into errors to write out later.
878    arguments.reportRemainingOptionsAsUnrecognized();
879
880    // report any errors if they have occured when parsing the program aguments.
881    if (arguments.errors())
882    {
883        arguments.writeErrorMessages(std::cout);
884        return 1;
885    }
886   
887    osg::Node* node = ttm->createScene((unsigned int)numTreesToCreates);
888
889    // add model to viewer.
890    viewer.setSceneData( node );
891
892    // create the windows and run the threads.
893    viewer.realize();
894
895    while( !viewer.done() )
896    {
897        // wait for all cull and draw threads to complete.
898        viewer.sync();
899
900        // update the scene by traversing it with the the update visitor which will
901        // call all node update callbacks and animations.
902        viewer.update();
903         
904        // fire off the cull and draw traversals of the scene.
905        viewer.frame();
906       
907    }
908   
909    // wait for all cull and draw threads to complete before exit.
910    viewer.sync();
911
912    return 0;
913}
Note: See TracBrowser for help on using the browser.