Changeset 12885

Show
Ignore:
Timestamp:
11/18/11 09:15:36 (2 years ago)
Author:
robert
Message:

Fixed indentation

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/examples/osgforest/osgforest.cpp

    r10711 r12885  
    8686        unsigned int    _type; 
    8787    }; 
    88      
     88 
    8989    typedef std::vector< osg::ref_ptr<Tree> > TreeList; 
    90      
     90 
    9191    class Cell : public osg::Referenced 
    9292    { 
     
    9696        Cell():_parent(0) {} 
    9797        Cell(osg::BoundingBox& bb):_parent(0), _bb(bb) {} 
    98          
     98 
    9999        void addCell(Cell* cell) { cell->_parent=this; _cells.push_back(cell); } 
    100100 
    101101        void addTree(Tree* tree) { _trees.push_back(tree); } 
    102          
     102 
    103103        void addTrees(const TreeList& trees) { _trees.insert(_trees.end(),trees.begin(),trees.end()); } 
    104          
     104 
    105105        void computeBound(); 
    106          
     106 
    107107        bool contains(const osg::Vec3& position) const { return _bb.contains(position); } 
    108          
     108 
    109109        bool divide(unsigned int maxNumTreesPerCell=10); 
    110          
     110 
    111111        bool divide(bool xAxis, bool yAxis, bool zAxis); 
    112          
     112 
    113113        void bin(); 
    114114 
     
    118118        CellList            _cells; 
    119119        TreeList            _trees; 
    120          
     120 
    121121    }; 
    122122 
     
    140140 
    141141    osg::Node* createShaderGraph(Cell* cell,osg::StateSet* stateset); 
    142      
     142 
    143143    osg::Node* createHUDWithText(const std::string& text); 
    144144 
    145145    osg::Node* createScene(unsigned int numTreesToCreates); 
    146      
     146 
    147147    void advanceToNextTechnique(int delta=1) 
    148148    { 
     
    157157        } 
    158158    } 
    159      
     159 
    160160    osg::ref_ptr<osg::Switch>   _techniqueSwitch; 
    161161    int                         _currentTechnique; 
    162      
     162 
    163163 
    164164}; 
     
    170170 
    171171    TechniqueEventHandler(ForestTechniqueManager* ttm=0) { _ForestTechniqueManager = ttm; } 
    172      
     172 
    173173    META_Object(osgforestApp,TechniqueEventHandler); 
    174174 
    175175    virtual bool handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter&, osg::Object*, osg::NodeVisitor*); 
    176      
     176 
    177177    virtual void getUsage(osg::ApplicationUsage& usage) const; 
    178178 
     
    180180 
    181181    ~TechniqueEventHandler() {} 
    182      
     182 
    183183    TechniqueEventHandler(const TechniqueEventHandler&,const osg::CopyOp&) {} 
    184      
     184 
    185185    osg::ref_ptr<ForestTechniqueManager> _ForestTechniqueManager; 
    186186 
    187          
     187 
    188188}; 
    189189 
     
    195195        { 
    196196            if (ea.getKey()=='n' || 
    197                 ea.getKey()==osgGA::GUIEventAdapter::KEY_Right ||  
     197                ea.getKey()==osgGA::GUIEventAdapter::KEY_Right || 
    198198                ea.getKey()==osgGA::GUIEventAdapter::KEY_KP_Right) 
    199199            { 
     
    202202            } 
    203203            else if (ea.getKey()=='p' || 
    204                      ea.getKey()==osgGA::GUIEventAdapter::KEY_Left ||  
    205                      ea.getKey()==osgGA::GUIEventAdapter::KEY_KP_Left) 
     204                    ea.getKey()==osgGA::GUIEventAdapter::KEY_Left || 
     205                    ea.getKey()==osgGA::GUIEventAdapter::KEY_KP_Left) 
    206206            { 
    207207                _ForestTechniqueManager->advanceToNextTechnique(-1); 
     
    261261        } 
    262262        return true; 
    263    } 
    264    else 
    265    { 
    266         return false; 
    267    } 
     263    } 
     264    else 
     265    { 
     266            return false; 
     267    } 
    268268} 
    269269 
     
    330330 
    331331void ForestTechniqueManager::Cell::bin() 
    332 {    
     332{ 
    333333    // put trees in appropriate cells. 
    334334    TreeList treesNotAssigned; 
     
    388388        stateset->setTextureAttributeAndModes(0,texture,osg::StateAttribute::ON); 
    389389    } 
    390      
     390 
    391391    geode->setStateSet( stateset ); 
    392      
     392 
    393393    unsigned int numColumns = 38; 
    394394    unsigned int numRows = 39; 
     
    407407        } 
    408408    } 
    409      
     409 
    410410    float scale_z = size.z()/(max_z-min_z); 
    411411 
     
    428428            } 
    429429        } 
    430          
     430 
    431431        geode->addDrawable(new osg::ShapeDrawable(grid)); 
    432432    } 
     
    434434    { 
    435435        osg::Geometry* geometry = new osg::Geometry; 
    436          
     436 
    437437        osg::Vec3Array& v = *(new osg::Vec3Array(numColumns*numRows)); 
    438438        osg::Vec2Array& t = *(new osg::Vec2Array(numColumns*numRows)); 
    439439        osg::Vec4ubArray& color = *(new osg::Vec4ubArray(1)); 
    440          
     440 
    441441        color[0].set(255,255,255,255); 
    442442 
    443443        float rowCoordDelta = size.y()/(float)(numRows-1); 
    444444        float columnCoordDelta = size.x()/(float)(numColumns-1); 
    445          
     445 
    446446        float rowTexDelta = 1.0f/(float)(numRows-1); 
    447447        float columnTexDelta = 1.0f/(float)(numColumns-1); 
     
    465465            tex.y() += rowTexDelta; 
    466466        } 
    467          
     467 
    468468        geometry->setVertexArray(&v); 
    469469        geometry->setColorArray(&color); 
    470470        geometry->setColorBinding(osg::Geometry::BIND_OVERALL); 
    471471        geometry->setTexCoordArray(0,&t); 
    472          
     472 
    473473        for(r=0;r<numRows-1;++r) 
    474474        { 
     
    482482            } 
    483483        } 
    484          
     484 
    485485        geode->addDrawable(geometry); 
    486          
     486 
    487487        osgUtil::SmoothingVisitor sv; 
    488488        sv.smooth(*geometry); 
    489489    } 
    490      
     490 
    491491    return geode; 
    492492} 
     
    497497    float max_TreeHeight = sqrtf(size.length2()/(float)numTreesToCreate); 
    498498    float max_TreeWidth = max_TreeHeight*0.5f; 
    499      
     499 
    500500    float min_TreeHeight = max_TreeHeight*0.3f; 
    501501    float min_TreeWidth = min_TreeHeight*0.5f; 
     
    512512        tree->_height = random(min_TreeHeight,max_TreeHeight); 
    513513        tree->_type = 0; 
    514          
     514 
    515515        if (terrain) 
    516516        { 
    517             osg::ref_ptr<osgUtil::LineSegmentIntersector> intersector =  
     517            osg::ref_ptr<osgUtil::LineSegmentIntersector> intersector = 
    518518                new osgUtil::LineSegmentIntersector(tree->_position,tree->_position+osg::Vec3(0.0f,0.0f,size.z())); 
    519519 
    520520            osgUtil::IntersectionVisitor iv(intersector.get()); 
    521              
     521 
    522522            terrain->accept(iv); 
    523523 
     
    534534            } 
    535535        } 
    536          
     536 
    537537        trees.push_back(tree); 
    538538    } 
     
    578578    osg::Vec2Array& t = *(new osg::Vec2Array(8)); 
    579579    osg::Vec4ubArray& c = *(new osg::Vec4ubArray(1)); 
    580      
     580 
    581581    float rotation = random(0.0f,osg::PI/2.0f); 
    582582    float sw = sinf(rotation)*w*0.5f; 
     
    623623    bool needGroup = !(cell->_cells.empty()); 
    624624    bool needBillboard = !(cell->_trees.empty()); 
    625      
     625 
    626626    osg::Billboard* billboard = 0; 
    627627    osg::Group* group = 0; 
    628      
     628 
    629629    if (needBillboard) 
    630630    { 
     
    636636        { 
    637637            Tree& tree = **itr; 
    638             billboard->addDrawable(createSprite(tree._width,tree._height,tree._color),tree._position);     
    639         } 
    640     } 
    641      
     638            billboard->addDrawable(createSprite(tree._width,tree._height,tree._color),tree._position); 
     639        } 
     640    } 
     641 
    642642    if (needGroup) 
    643643    { 
     
    649649            group->addChild(createBillboardGraph(itr->get(),stateset)); 
    650650        } 
    651          
     651 
    652652        if (billboard) group->addChild(billboard); 
    653          
     653 
    654654    } 
    655655    if (group) return group; 
     
    661661    bool needGroup = !(cell->_cells.empty()); 
    662662    bool needTrees = !(cell->_trees.empty()); 
    663      
     663 
    664664    osg::Geode* geode = 0; 
    665665    osg::Group* group = 0; 
    666      
     666 
    667667    if (needTrees) 
    668668    { 
    669669        geode = new osg::Geode; 
    670670        geode->setStateSet(stateset); 
    671          
     671 
    672672        for(TreeList::iterator itr=cell->_trees.begin(); 
    673673            itr!=cell->_trees.end(); 
     
    678678        } 
    679679    } 
    680      
     680 
    681681    if (needGroup) 
    682682    { 
     
    688688            group->addChild(createXGraph(itr->get(),stateset)); 
    689689        } 
    690          
     690 
    691691        if (geode) group->addChild(geode); 
    692          
     692 
    693693    } 
    694694    if (group) return group; 
     
    700700    bool needGroup = !(cell->_cells.empty()); 
    701701    bool needTrees = !(cell->_trees.empty()); 
    702      
     702 
    703703    osg::Group* transform_group = 0; 
    704704    osg::Group* group = 0; 
    705      
     705 
    706706    if (needTrees) 
    707707    { 
    708708        transform_group = new osg::Group; 
    709          
     709 
    710710        osg::Geometry* geometry = createOrthogonalQuads(osg::Vec3(0.0f,0.0f,0.0f),1.0f,1.0f,osg::Vec4ub(255,255,255,255)); 
    711          
     711 
    712712        for(TreeList::iterator itr=cell->_trees.begin(); 
    713713            itr!=cell->_trees.end(); 
     
    717717            osg::MatrixTransform* transform = new osg::MatrixTransform; 
    718718            transform->setMatrix(osg::Matrix::scale(tree._width,tree._width,tree._height)*osg::Matrix::translate(tree._position)); 
    719      
     719 
    720720            osg::Geode* geode = new osg::Geode; 
    721721            geode->setStateSet(stateset); 
     
    725725        } 
    726726    } 
    727      
     727 
    728728    if (needGroup) 
    729729    { 
     
    735735            group->addChild(createTransformGraph(itr->get(),stateset)); 
    736736        } 
    737          
     737 
    738738        if (transform_group) group->addChild(transform_group); 
    739          
     739 
    740740    } 
    741741    if (group) return group; 
     
    748748    osg::Vec3Array& v = *(new osg::Vec3Array(8)); 
    749749    osg::Vec2Array& t = *(new osg::Vec2Array(8)); 
    750      
     750 
    751751    float rotation = random(0.0f,osg::PI/2.0f); 
    752752    float sw = sinf(rotation)*w*0.5f; 
     
    796796 
    797797        typedef std::vector<osg::Vec4> PositionSizeList; 
    798          
     798 
    799799        virtual void drawImplementation(osg::RenderInfo& renderInfo) const 
    800800        { 
     
    823823            return bb; 
    824824        } 
    825          
     825 
    826826        void setGeometry(osg::Geometry* geometry) 
    827827        { 
    828828            _geometry = geometry; 
    829829        } 
    830          
     830 
    831831        void addTree(ForestTechniqueManager::Tree& tree) 
    832832        { 
    833833            _trees.push_back(osg::Vec4(tree._position.x(), tree._position.y(), tree._position.z(), tree._height)); 
    834834        } 
    835          
     835 
    836836        osg::ref_ptr<osg::Geometry> _geometry; 
    837837 
     
    839839 
    840840    protected: 
    841      
     841 
    842842        virtual ~ShaderGeometry() {} 
    843          
     843 
    844844}; 
    845845 
     
    857857    bool needGroup = !(cell->_cells.empty()); 
    858858    bool needTrees = !(cell->_trees.empty()); 
    859      
     859 
    860860    osg::Geode* geode = 0; 
    861861    osg::Group* group = 0; 
    862      
     862 
    863863    if (needTrees) 
    864864    { 
    865865        geode = new osg::Geode; 
    866          
     866 
    867867        ShaderGeometry* shader_geometry = new ShaderGeometry; 
    868868        shader_geometry->setGeometry(shared_geometry); 
    869          
    870          
     869 
     870 
    871871        for(TreeList::iterator itr=cell->_trees.begin(); 
    872872            itr!=cell->_trees.end(); 
     
    881881        geode->addDrawable(shader_geometry); 
    882882    } 
    883      
     883 
    884884    if (needGroup) 
    885885    { 
     
    891891            group->addChild(createShaderGraph(itr->get(),stateset)); 
    892892        } 
    893          
     893 
    894894        if (geode) group->addChild(geode); 
    895          
     895 
    896896    } 
    897897    if (group) return group; 
     
    902902{ 
    903903    osg::Geode* geode = new osg::Geode(); 
    904      
     904 
    905905    std::string timesFont("fonts/arial.ttf"); 
    906906 
     
    909909    stateset->setMode(GL_LIGHTING,osg::StateAttribute::OFF); 
    910910 
    911     // or disable depth test, and make sure that the hud is drawn after everything  
     911    // or disable depth test, and make sure that the hud is drawn after everything 
    912912    // else so that it always appears ontop. 
    913913    stateset->setMode(GL_DEPTH_TEST,osg::StateAttribute::OFF); 
     
    924924        text->setPosition(position); 
    925925        text->setText(str); 
    926          
     926 
    927927        position += delta; 
    928     }     
    929  
    930     
     928    } 
     929 
     930 
    931931    // create the hud. 
    932932    osg::MatrixTransform* modelview_abs = new osg::MatrixTransform; 
     
    950950    osg::ref_ptr<osg::Node> terrain = createTerrain(origin,size); 
    951951    std::cout<<"done."<<std::endl; 
    952      
     952 
    953953    std::cout<<"Creating tree locations...";std::cout.flush(); 
    954954    TreeList trees; 
    955955    createTreeList(terrain.get(),origin,size,numTreesToCreates,trees); 
    956956    std::cout<<"done."<<std::endl; 
    957      
     957 
    958958    std::cout<<"Creating cell subdivision..."; 
    959959    osg::ref_ptr<Cell> cell = new Cell; 
    960960    cell->addTrees(trees); 
    961961    cell->divide(); 
    962      std::cout<<"done."<<std::endl; 
    963     
    964      
     962    std::cout<<"done."<<std::endl; 
     963 
     964 
    965965    osg::Texture2D *tex = new osg::Texture2D; 
    966966    tex->setWrap( osg::Texture2D::WRAP_S, osg::Texture2D::CLAMP ); 
     
    969969 
    970970    osg::StateSet *dstate = new osg::StateSet; 
    971     {     
     971    { 
    972972        dstate->setTextureAttributeAndModes(0, tex, osg::StateAttribute::ON ); 
    973973 
     
    984984        dstate->setRenderingHint( osg::StateSet::TRANSPARENT_BIN ); 
    985985    } 
    986      
     986 
    987987 
    988988    _techniqueSwitch = new osg::Switch; 
     
    996996        std::cout<<"done."<<std::endl; 
    997997    } 
    998      
     998 
    999999    { 
    10001000        std::cout<<"Creating double quad based forest..."; 
     
    10261026            vp_oss << 
    10271027                "!!ARBvp1.0\n" 
    1028                  
     1028 
    10291029                "ATTRIB vpos = vertex.position;\n" 
    10301030                "ATTRIB vcol = vertex.color;\n" 
     
    10351035 
    10361036                "TEMP position;\n" 
    1037                  
    1038                  // vec3 position = gl_Vertex.xyz * gl_Color.w + gl_Color.xyz; 
     1037 
     1038                // vec3 position = gl_Vertex.xyz * gl_Color.w + gl_Color.xyz; 
    10391039                "MAD position, vpos, vcol.w, vcol;\n" 
    10401040 
     
    10491049                "MOV result.color.front.primary, one;\n" 
    10501050 
    1051                  // texcoord = gl_MultiTexCoord0.st; 
     1051                // texcoord = gl_MultiTexCoord0.st; 
    10521052                "MOV result.texcoord, tc;\n" 
    10531053                "END\n"; 
     
    10881088#if 1 
    10891089            // use inline shaders 
    1090              
     1090 
    10911091            /////////////////////////////////////////////////////////////////// 
    10921092            // vertex shader using just Vec4 coefficients 
    1093             char vertexShaderSource[] =  
     1093            char vertexShaderSource[] = 
    10941094                "varying vec2 texcoord;\n" 
    10951095                "\n" 
     
    11051105            // fragment shader 
    11061106            // 
    1107             char fragmentShaderSource[] =  
     1107            char fragmentShaderSource[] = 
    11081108                "uniform sampler2D baseTexture; \n" 
    11091109                "varying vec2 texcoord; \n" 
     
    11191119            osg::Shader* fragment_shader = new osg::Shader(osg::Shader::FRAGMENT, fragmentShaderSource); 
    11201120            program->addShader(fragment_shader); 
    1121              
     1121 
    11221122#else 
    11231123 
     
    11401140    _currentTechnique = 0; 
    11411141    _techniqueSwitch->setSingleChildOn(_currentTechnique); 
    1142      
     1142 
    11431143 
    11441144    osg::Group* scene = new osg::Group; 
    1145      
     1145 
    11461146    scene->addChild(terrain.get()); 
    11471147    scene->addChild(_techniqueSwitch.get()); 
     
    11551155    // use an ArgumentParser object to manage the program arguments. 
    11561156    osg::ArgumentParser arguments(&argc,argv); 
    1157     
     1157 
    11581158    // construct the viewer. 
    11591159    osgViewer::Viewer viewer(arguments); 
     
    11611161    float numTreesToCreates = 10000; 
    11621162    arguments.read("--trees",numTreesToCreates); 
    1163      
     1163 
    11641164    osg::ref_ptr<ForestTechniqueManager> ttm = new ForestTechniqueManager; 
    1165      
     1165 
    11661166    // add the stats handler 
    11671167    viewer.addEventHandler(new osgViewer::StatsHandler);