Show
Ignore:
Timestamp:
11/09/15 17:13:03 (2 years ago)
Author:
robert
Message:

Release OpenSceneGraph-3.5.1

Files:
1 modified

Legend:

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

    r6941 r13574  
    2424 setTessellationType(osgUtil::Tessellator::TESS_TYPE_xxx); 
    2525    tscx->setBoundaryOnly(bool); 
    26     tscx->setWindingType( osgUtil::Tessellator::TESS_WINDING_xxx);  
     26    tscx->setWindingType( osgUtil::Tessellator::TESS_WINDING_xxx); 
    2727 * for winding rules: See the red book chap 13. 
    2828 */ 
     
    4141class tessellateDemoGeometry : public osg::Geometry, public osgUtil::Tessellator { 
    4242    // We add the Tessellator to the geometry because we want to access the 
    43     // tessellatable contours again;  you can apply a Tessellator to a Geometry  
    44     // to produce exactly a required tessellation once only, and then  
     43    // tessellatable contours again;  you can apply a Tessellator to a Geometry 
     44    // to produce exactly a required tessellation once only, and then 
    4545    // the contours could be discarded since the geometry does not need to be retessellated. 
    4646public: 
     
    5151}; 
    5252 
    53 osg::Geometry *makePolsTwo (void)  
     53osg::Geometry *makePolsTwo (void) 
    5454{ 
    5555    // an example of using current geometry contours to create next tessellation 
     
    6363    static GLdouble quadstrip[8][3] = 
    6464    { { 1900.0, 1130.0, 0.0 }, 
    65       { 2100.0, 1130.0, 0.0 },  
     65      { 2100.0, 1130.0, 0.0 }, 
    6666      { 1900.0, 1350.0, 0.0 }, 
    67       { 1950.0, 1350.0, 0.0 },  
    68       { 1900.0, 1550.0, 0.0 },  
    69       { 2000.0, 1550.0, 0.0 },  
    70       { 1900.0, 1750.0, 0.0 },  
     67      { 1950.0, 1350.0, 0.0 }, 
     68      { 1900.0, 1550.0, 0.0 }, 
     69      { 2000.0, 1550.0, 0.0 }, 
     70      { 1900.0, 1750.0, 0.0 }, 
    7171      { 2400.0, 1750.0, 0.0 } }; 
    7272    static GLdouble innerquadstrip[8][3] = 
     
    7676      { 1940.0, 1350.0, 0.0 }, 
    7777      { 1920.0, 1550.0, 0.0 }, 
    78       { 1980.0, 1550.0, 0.0 },  
     78      { 1980.0, 1550.0, 0.0 }, 
    7979      { 2000.0, 1650.0, 0.0 }, 
    8080      { 2400.0, 1650.0, 0.0 } }; 
    81      
    82     // add one large quadstrip  
     81 
     82    // add one large quadstrip 
    8383    for (i = 0; i < 8; i++) 
    8484    { 
     
    9393    } 
    9494    gtess->setVertexArray(coords); 
    95     gtess->setNormalArray(nrms); 
    96     gtess->setNormalBinding(osg::Geometry::BIND_PER_VERTEX); 
     95    gtess->setNormalArray(nrms, osg::Array::BIND_PER_VERTEX); 
    9796    gtess->setTexCoordArray(0,tcs); 
    98      
     97 
    9998    // demonstrate that the Tessellator makes textured tessellations 
    10099    osg::StateSet* stateset = new osg::StateSet(); 
    101      
     100 
    102101    osg::Image* image = osgDB::readImageFile("Cubemap_snow/posy.jpg"); 
    103102    if (image) 
     
    110109    } 
    111110    gtess->setStateSet( stateset ); 
    112      
     111 
    113112    int nstart=0; 
    114113    // The derived class tessellateDemoGeometry retains the original contours for re-use. 
     
    119118    gtess->setBoundaryOnly(true); 
    120119    gtess->setWindingType( osgUtil::Tessellator::TESS_WINDING_ABS_GEQ_TWO); // so that first change in wind type makes the commonest tessellation - ODD. 
    121      
     120 
    122121    return gtess; 
    123122} 
     
    135134    static GLdouble wall[4][2] = 
    136135    { { 1130.0, 0.0 }, 
    137       { 1130.0, 300.0 } ,  
     136      { 1130.0, 300.0 } , 
    138137      { 1340.0,300.0 }, 
    139138      { 1340.0,0.0 } }; 
    140139 
    141140    gtess->setVertexArray(coords); 
    142     gtess->setNormalArray(nrms); 
    143     gtess->setNormalBinding(osg::Geometry::BIND_PER_VERTEX); 
     141    gtess->setNormalArray(nrms, osg::Array::BIND_PER_VERTEX); 
    144142    gtess->setTexCoordArray(0,tcs); 
    145143 
     
    168166    } 
    169167    gtess->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::POLYGON,nstart,5));nstart+=5; 
    170      
     168 
    171169    // demonstrate that the Tessellator makes textured tessellations 
    172170    osg::StateSet* stateset = new osg::StateSet(); 
    173      
     171 
    174172    osg::Image* image = osgDB::readImageFile("Cubemap_snow/posx.jpg"); 
    175173    if (image) 
     
    182180    } 
    183181    gtess->setStateSet( stateset ); 
    184      
     182 
    185183 
    186184    osg::ref_ptr<osgUtil::Tessellator> tscx=new osgUtil::Tessellator; // the v1.2 multi-contour Tessellator. 
     
    190188    tscx->setBoundaryOnly(false); 
    191189    tscx->setWindingType( osgUtil::Tessellator::TESS_WINDING_ODD); // so that first change in wind type makes the commonest tessellation - ODD. 
    192      
     190 
    193191    tscx->retessellatePolygons(*gtess); 
    194      
     192 
    195193    return gtess; 
    196194} 
     
    211209    static GLdouble wall[5][2] = 
    212210    { { 2200.0, 1130.0 }, 
    213       { 2600.0, 1130.0 },   
    214       { 2600.0, 1340.0 },  
     211      { 2600.0, 1130.0 }, 
     212      { 2600.0, 1340.0 }, 
    215213      { 2400.0, 1440.0 }, 
    216214      { 2200.0, 1340.0 } }; 
     
    218216    static GLdouble door[4][2] = 
    219217    { { 2360.0, 1130.0 }, 
    220       { 2440.0, 1130.0 },  
     218      { 2440.0, 1130.0 }, 
    221219      { 2440.0, 1230.0 }, 
    222220      { 2360.0, 1230.0 } }; 
     
    224222    static GLdouble windows[16][2] = 
    225223    { { 2240.0, 1180.0 }, 
    226       { 2330.0, 1180.0 },  
     224      { 2330.0, 1180.0 }, 
    227225      { 2330.0, 1220.0 }, 
    228       { 2240.0, 1220.0 },  
     226      { 2240.0, 1220.0 }, 
    229227      { 2460.0, 1180.0 }, 
    230       { 2560.0, 1180.0 },  
     228      { 2560.0, 1180.0 }, 
    231229      { 2560.0, 1220.0 }, 
    232230      { 2460.0, 1220.0 }, 
    233231      { 2240.0, 1280.0 }, 
    234       { 2330.0, 1280.0 },  
     232      { 2330.0, 1280.0 }, 
    235233      { 2330.0, 1320.0 }, 
    236       { 2240.0, 1320.0 },  
     234      { 2240.0, 1320.0 }, 
    237235      { 2460.0, 1280.0 }, 
    238       { 2560.0, 1280.0 },  
     236      { 2560.0, 1280.0 }, 
    239237      { 2560.0, 1320.0 }, 
    240238      { 2460.0, 1320.0 } }; 
    241239 
    242240    gtess->setVertexArray(coords); 
    243     gtess->setNormalArray(nrms); 
    244     gtess->setNormalBinding(osg::Geometry::BIND_PER_VERTEX); 
     241    gtess->setNormalArray(nrms, osg::Array::BIND_PER_VERTEX); 
    245242    gtess->setTexCoordArray(0,tcs); 
    246243 
    247     // add one large pentagon -the wall  
     244    // add one large pentagon -the wall 
    248245    for (i = 0; i < 5; i++) { 
    249246        coords->push_back(osg::Vec3(wall[i][0],zpos,wall[i][1])); 
     
    252249    } 
    253250    gtess->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::POLYGON,nstart,5));nstart+=5; 
    254     // add first hole, a door  
     251    // add first hole, a door 
    255252    for (i = 0; i < 4; i++) { 
    256253        coords->push_back(osg::Vec3(door[i][0],zpos,door[i][1])); 
     
    268265    // demonstrate that the Tessellator makes textured tessellations 
    269266    osg::StateSet* stateset = new osg::StateSet(); 
    270      
     267 
    271268    osg::Image* image = osgDB::readImageFile("Cubemap_snow/posy.jpg"); 
    272269    if (image) 
     
    279276    } 
    280277    gtess->setStateSet( stateset ); 
    281      
    282     // We use a Tessellator to produce the tessellation required once only  
     278 
     279    // We use a Tessellator to produce the tessellation required once only 
    283280    // and the contours are discarded. 
    284281    osg::ref_ptr<osgUtil::Tessellator> tscx=new osgUtil::Tessellator; // the v1.2 multi-contour Tessellator. 
     
    286283    tscx->setBoundaryOnly(false); 
    287284    tscx->setWindingType( osgUtil::Tessellator::TESS_WINDING_ODD); // so that first change in wind type makes the commonest tessellation - ODD. 
    288      
     285 
    289286    tscx->retessellatePolygons(*gtess); 
    290      
     287 
    291288    return gtess; 
    292289} 
     
    307304    osg::Vec3 nrm(0,-1,0); 
    308305    // coordinates from red book code but shifted by 1000 & 2000 for alternate Tessellatory things. 
    309     static GLdouble rects[12][3] =  
     306    static GLdouble rects[12][3] = 
    310307    { { 50.0, 50.0, 0.0 }, 
    311       { 300.0, 50.0, 0.0 },  
     308      { 300.0, 50.0, 0.0 }, 
    312309      { 300.0, 300.0, 0.0 }, 
    313310      { 50.0, 300.0, 0.0 }, 
    314311      { 100.0, 100.0, 0.0 }, 
    315       { 250.0, 100.0, 0.0 },  
     312      { 250.0, 100.0, 0.0 }, 
    316313      { 250.0, 250.0, 0.0 }, 
    317314      { 100.0, 250.0, 0.0 }, 
    318315      { 150.0, 150.0, 0.0 }, 
    319       { 200.0, 150.0, 0.0 },  
     316      { 200.0, 150.0, 0.0 }, 
    320317      { 200.0, 200.0, 0.0 }, 
    321318      { 150.0, 200.0, 0.0 } }; 
     
    323320    static GLdouble rectsMidanti[12][3] = // the centre 2 contours are traversed opposite order to outer contour. 
    324321    { { 1050.0, 50.0, 0.0 }, 
    325       { 1300.0, 50.0, 0.0 },  
     322      { 1300.0, 50.0, 0.0 }, 
    326323      { 1300.0, 300.0, 0.0 }, 
    327324      { 1050.0, 300.0, 0.0 }, 
    328325      { 1250.0, 100.0, 0.0 }, 
    329       { 1100.0, 100.0, 0.0 },  
     326      { 1100.0, 100.0, 0.0 }, 
    330327      { 1100.0, 250.0, 0.0 }, 
    331       { 1250.0, 250.0, 0.0 },  
     328      { 1250.0, 250.0, 0.0 }, 
    332329      { 1200.0, 150.0, 0.0 }, 
    333       { 1150.0, 150.0, 0.0 },  
     330      { 1150.0, 150.0, 0.0 }, 
    334331      { 1150.0, 200.0, 0.0 }, 
    335332      { 1200.0, 200.0, 0.0 } }; 
    336333    static GLdouble spiral[16][3] = // shift by 1000; nb the order of vertices is reversed from that of the red book 
    337334    { { 3400.0, 250.0, 0.0 }, 
    338       { 3400.0, 50.0, 0.0 },  
    339       { 3050.0, 50.0, 0.0 },   
    340       { 3050.0, 400.0, 0.0 },  
    341       { 3350.0, 400.0, 0.0 },  
    342       { 3350.0, 100.0, 0.0 },  
    343       { 3100.0, 100.0, 0.0 },  
    344       { 3100.0, 350.0, 0.0 },  
    345       { 3300.0, 350.0, 0.0 },  
    346       { 3300.0, 150.0, 0.0 },  
    347       { 3150.0, 150.0, 0.0 },  
    348       { 3150.0, 300.0, 0.0 },  
    349       { 3250.0, 300.0, 0.0 },  
    350       { 3250.0, 200.0, 0.0 },  
    351       { 3200.0, 200.0, 0.0 },  
     335      { 3400.0, 50.0, 0.0 }, 
     336      { 3050.0, 50.0, 0.0 }, 
     337      { 3050.0, 400.0, 0.0 }, 
     338      { 3350.0, 400.0, 0.0 }, 
     339      { 3350.0, 100.0, 0.0 }, 
     340      { 3100.0, 100.0, 0.0 }, 
     341      { 3100.0, 350.0, 0.0 }, 
     342      { 3300.0, 350.0, 0.0 }, 
     343      { 3300.0, 150.0, 0.0 }, 
     344      { 3150.0, 150.0, 0.0 }, 
     345      { 3150.0, 300.0, 0.0 }, 
     346      { 3250.0, 300.0, 0.0 }, 
     347      { 3250.0, 200.0, 0.0 }, 
     348      { 3200.0, 200.0, 0.0 }, 
    352349      { 3200.0, 250.0, 0.0 } 
    353350    }; 
    354351    static GLdouble quad1[4][3] = // shift by 2000 for next 3 things 
    355     { { 2050.0, 150.0, 0.0 },  
    356       { 2350.0, 150.0, 0.0 },  
    357       { 2350.0, 200.0, 0.0 },  
     352    { { 2050.0, 150.0, 0.0 }, 
     353      { 2350.0, 150.0, 0.0 }, 
     354      { 2350.0, 200.0, 0.0 }, 
    358355      { 2050.0, 200.0, 0.0 } 
    359356    }; 
    360357    static GLdouble quad2[4][3] = 
    361358    { { 2100.0, 100.0, 0.0 }, 
    362       { 2300.0, 100.0, 0.0 },  
    363       { 2300.0, 350.0, 0.0 },  
     359      { 2300.0, 100.0, 0.0 }, 
     360      { 2300.0, 350.0, 0.0 }, 
    364361      { 2100.0, 350.0, 0.0 } 
    365362    }; 
    366363    static GLdouble tri[3][3] = 
    367     { { 2200.0, 50.0, 0.0 },  
     364    { { 2200.0, 50.0, 0.0 }, 
    368365      { 2250.0, 300.0, 0.0 }, 
    369366      { 2150.0, 300.0, 0.0 } 
    370367    }; 
    371368    static GLdouble quad3[4][3] = 
    372     { { 100.0, 1100.0, 0.0 },  
    373       { 1300.0, 1100.0, 0.0 },  
    374       { 1300.0, 2350.0, 0.0 },  
     369    { { 100.0, 1100.0, 0.0 }, 
     370      { 1300.0, 1100.0, 0.0 }, 
     371      { 1300.0, 2350.0, 0.0 }, 
    375372      { 100.0, 2350.0, 0.0} 
    376373    }; 
    377374    static GLdouble quadstrip[8][3] = 
    378375    { { 900.0, 1130.0, 0.0 }, 
    379       { 1100.0, 1130.0, 0.0 },  
     376      { 1100.0, 1130.0, 0.0 }, 
    380377      { 900.0, 1350.0, 0.0 }, 
    381       { 950.0, 1350.0, 0.0 },  
     378      { 950.0, 1350.0, 0.0 }, 
    382379      { 900.0, 1550.0, 0.0 }, 
    383380      { 1000.0, 1550.0, 0.0 }, 
     
    385382      { 1400.0, 1750.0, 0.0 } 
    386383    }; 
    387      
     384 
    388385    for (i = 0; i < 12; i++) { 
    389386        coords->push_back(osg::Vec3(rects[i][0],rects[i][2],rects[i][1])); 
     
    449446        } 
    450447    } 
    451     // add one large quadstrip  
     448    // add one large quadstrip 
    452449    for (i = 0; i < 8; i++) { 
    453450        coords->push_back(osg::Vec3(quadstrip[i][0],quadstrip[i][2],quadstrip[i][1])); 
     
    456453    } 
    457454    gtess->setVertexArray(coords); 
    458     gtess->setNormalArray(nrms); 
    459     gtess->setNormalBinding(osg::Geometry::BIND_PER_VERTEX); 
     455    gtess->setNormalArray(nrms, osg::Array::BIND_PER_VERTEX); 
    460456    gtess->setTexCoordArray(0,tcs); 
    461      
     457 
    462458    // demonstrate that the Tessellator makes textured tessellations 
    463459    osg::StateSet* stateset = new osg::StateSet(); 
    464      
     460 
    465461    osg::Image* image = osgDB::readImageFile("Cubemap_snow/posz.jpg"); 
    466462    if (image) 
     
    473469    } 
    474470    gtess->setStateSet( stateset ); 
    475      
     471 
    476472    int nstart=0; 
    477473    // the contours accepoted are polygons; quads & tris. Trifans can bve added later. 
     
    489485    // test for quad strip 
    490486    gtess->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::TRIANGLE_STRIP,nstart,8));nstart+=8; 
    491      
     487 
    492488    // We need to access the tessellatable contours again to demonstrate all types of tessellation. 
    493489    // I could add the Tessellator to the geometry as userdata, but here 
    494490    // I use the derived tessellateDemoGeometry to hold both the drawable geode and the original contours. 
    495      
     491 
    496492    gtess->setTessellationType(osgUtil::Tessellator::TESS_TYPE_GEOMETRY); 
    497493    gtess->setBoundaryOnly(true); 
    498494    gtess->setWindingType( osgUtil::Tessellator::TESS_WINDING_ABS_GEQ_TWO); // so that first change in wind type makes the commonest tessellation - ODD. 
    499      
     495 
    500496    return gtess; 
    501497} 
     
    503499{ // add a string reporting the type of winding rule tessellation applied 
    504500    osg::Geode* geode = new osg::Geode(); 
    505      
     501 
    506502    std::string timesFont("fonts/arial.ttf"); 
    507503 
     
    510506    stateset->setMode(GL_LIGHTING,osg::StateAttribute::OFF); 
    511507 
    512     // Disable depth test, and make sure that the hud is drawn after everything  
     508    // Disable depth test, and make sure that the hud is drawn after everything 
    513509    // else so that it always appears ontop. 
    514510    stateset->setMode(GL_DEPTH_TEST,osg::StateAttribute::OFF); 
     
    527523        text->setColor(osg::Vec4(1.0,1.0,0.8,1.0)); 
    528524        position += delta; 
    529          
    530     }     
     525 
     526    } 
    531527    { 
    532528        osgText::Text* text = new  osgText::Text; 
     
    536532        text->setPosition(position); 
    537533        text->setText("Press 'n' to use an alternative tessellation."); 
    538          
    539     }     
     534 
     535    } 
    540536 
    541537    // create the hud. 
     
    574570    // any tessellation can be requested. 
    575571public: 
    576      
     572 
    577573    setTessellateVisitor():osg::NodeVisitor(osg::NodeVisitor::TRAVERSE_ALL_CHILDREN) { 
    578574    } 
     
    632628            } 
    633629        } 
    634     }     
     630    } 
    635631}; 
    636632 
     
    642638    // In this visitor, I reuse the contours to make a different type of tessellation. 
    643639public: 
    644      
     640 
    645641    cxTessellateVisitor():osg::NodeVisitor(osg::NodeVisitor::TRAVERSE_ALL_CHILDREN) { 
    646642    } 
     
    652648            if (geom) { 
    653649                if (!geom->getBoundaryOnly()) { // turn on bounds only 
    654                     // NB this shows only the true boundary of the curves, no internal edges                     
     650                    // NB this shows only the true boundary of the curves, no internal edges 
    655651                    geom->setBoundaryOnly(true); 
    656                      
     652 
    657653                } else { // change to next type of tessellation... 
    658654                    geom->setBoundaryOnly(false); 
     
    675671                    } 
    676672                } 
    677                  
     673 
    678674                switch (geom->getWindingType()) { // a text to be added to the scene. 
    679675                case         osgUtil::Tessellator::TESS_WINDING_ODD: 
     
    694690                } 
    695691                if (geom->getBoundaryOnly()) str += " Boundary"; 
    696                  
     692 
    697693                geom->retessellatePolygons(*geom); 
    698694            } 
     
    707703        traverse(geode); 
    708704    } 
    709      
     705 
    710706    std::string str; // a label for on screen display 
    711707}; 
     
    714710{ // extra event handler traps 'n' key to re-tessellate any tessellated geodes. 
    715711public: 
    716      
     712 
    717713    KeyboardEventHandler(osg::Node *nd): 
    718714        _scene(nd) {} 
    719      
     715 
    720716        virtual bool handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter&) 
    721717        { 
     
    726722                    if (_scene && ea.getKey()=='n') 
    727723                    { 
    728                         // re-tessellate the scene graph.  
    729                         // the same contours are re-tessellated using a new method. Old contours  
     724                        // re-tessellate the scene graph. 
     725                        // the same contours are re-tessellated using a new method. Old contours 
    730726                        // & tessellation type are held internally in the derived Geode class tessellateDemoGeometry. 
    731727                        cxTessellateVisitor tsv; 
     
    740736            return false; 
    741737        } 
    742          
     738 
    743739        osg::Node *_scene; 
    744          
     740 
    745741}; 
    746742 
     
    758754 
    759755    // if no model has been successfully loaded report failure. 
    760     if (!loadedModel)  
     756    if (!loadedModel) 
    761757    { 
    762758        loadedModel=makeTessellateExample();