Show
Ignore:
Timestamp:
10/24/04 16:23:42 (10 years ago)
Author:
robert
Message:

From Rainer Oder, updates to osgplanets

Files:
1 modified

Legend:

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

    r3515 r3522  
    66#include <osg/Geometry> 
    77#include <osg/Geode> 
     8#include <osg/ShapeDrawable> 
    89 
    910#include <osgUtil/Optimizer> 
     
    1920 
    2021 
    21 struct SolarSystemParameters 
    22 { 
    23     SolarSystemParameters(): 
    24         radiusSun(20.0), 
    25         RorbitEarth(100.0), 
    26         radiusEarth(10.0), 
    27         radiusMoon(2.0), 
    28         RorbitMoon(20.0), 
    29         tiltEarth(5.0), 
    30         rotateSpeedEarth(5.0) 
     22osg::AnimationPath* createAnimationPath(const osg::Vec3& center,float radius,double looptime) 
     23{ 
     24    // set up the animation path  
     25    osg::AnimationPath* animationPath = new osg::AnimationPath; 
     26    animationPath->setLoopMode(osg::AnimationPath::LOOP); 
     27     
     28    int numSamples = 40; 
     29    float yaw = 0.0f; 
     30    float yaw_delta = 2.0f*osg::PI/((float)numSamples-1.0f); 
     31    float roll = osg::inDegrees(30.0f); 
     32     
     33    double time=0.0f; 
     34    double time_delta = looptime/(double)numSamples; 
     35    for(int i=0;i<numSamples;++i) 
     36    { 
     37        osg::Vec3 position(center+osg::Vec3(sinf(yaw)*radius,cosf(yaw)*radius,0.0f)); 
     38        osg::Quat rotation(osg::Quat(roll,osg::Vec3(0.0,1.0,0.0))*osg::Quat(-(yaw+osg::inDegrees(90.0f)),osg::Vec3(0.0,0.0,1.0))); 
     39         
     40        animationPath->insert(time,osg::AnimationPath::ControlPoint(position,rotation)); 
     41 
     42        yaw += yaw_delta; 
     43        time += time_delta; 
     44 
     45    } 
     46    return animationPath;     
     47}// end createAnimationPath 
     48 
     49 
     50osg::MatrixTransform* createEarthTranslationAndTilt( double RorbitEarth, double tiltEarth )  
     51{ 
     52        osg::MatrixTransform* earthPositioned = new osg::MatrixTransform; 
     53        //earthPositioned->setDataVariance(osg::Object::STATIC); 
     54        earthPositioned->setMatrix(osg::Matrix::translate(osg::Vec3( 0.0, RorbitEarth, 0.0 ) )* 
     55                                     osg::Matrix::scale(1.0, 1.0, 1.0)* 
     56                                     osg::Matrix::rotate(osg::inDegrees( tiltEarth ),0.0f,0.0f,1.0f)); 
     57                                      
     58        return earthPositioned; 
     59}// end createEarthTranslationAndTilt 
     60 
     61 
     62osg::MatrixTransform* createRotation( double orbit, double speed ) 
     63{ 
     64    osg::Vec3 center( 0.0, 0.0, 0.0 ); 
     65    float animationLength = 10.0f; 
     66    osg::AnimationPath* animationPath = createAnimationPath( center, orbit, animationLength ); 
     67     
     68    osg::MatrixTransform* rotation = new osg::MatrixTransform; 
     69    rotation->setUpdateCallback( new osg::AnimationPathCallback( animationPath, 0.0f, speed ) ); 
     70     
     71    return rotation; 
     72}// end createEarthRotation 
     73 
     74 
     75osg::MatrixTransform* createMoonTranslation( double RorbitMoon ) 
     76{ 
     77    osg::MatrixTransform* moonPositioned = new osg::MatrixTransform; 
     78    //earthPositioned->setDataVariance(osg::Object::STATIC); 
     79    //earthPositioned->setMatrix(osg::Matrix::translate(osg::Vec3( RorbitEarth, 0.0, 0.0 ) )* 
     80    moonPositioned->setMatrix(osg::Matrix::translate(osg::Vec3( 0.0, RorbitMoon, 0.0 ) )* 
     81    //earthPositioned->setMatrix(osg::Matrix::translate(osg::Vec3( 0.0, 0.0, RorbitEarth ) )* 
     82                                 osg::Matrix::scale(1.0, 1.0, 1.0)* 
     83                                 osg::Matrix::rotate(osg::inDegrees(0.0f),0.0f,0.0f,1.0f)); 
     84 
     85    return moonPositioned; 
     86}// end createMoonTranslation 
     87 
     88 
     89osg::Geode* createPlanet( double radius, std::string name, osg::Vec4 color ) 
     90{ 
     91    // create a cube shape 
     92    osg::Sphere *planetSphere = new osg::Sphere( osg::Vec3( 0.0, 0.0, 0.0 ), radius ); 
     93 
     94    // create a container that makes the sphere drawable 
     95    osg::ShapeDrawable *sPlanetSphere = new osg::ShapeDrawable( planetSphere ); 
     96  
     97    // set the object color 
     98    sPlanetSphere->setColor( color ); 
     99    
     100    // create a geode object to as a container for our drawable sphere object 
     101    osg::Geode* geodePlanet = new osg::Geode(); 
     102    geodePlanet->setName( name ); 
     103     
     104    // add our drawable sphere to the geode container 
     105    geodePlanet->addDrawable( sPlanetSphere ); 
     106 
     107    return( geodePlanet ); 
     108}// end createPlanet 
     109 
     110 
     111class SolarSystem 
     112{ 
     113 
     114public: 
     115    double _radiusSun; 
     116    double _radiusEarth; 
     117    double _RorbitEarth; 
     118    double _tiltEarth; 
     119    double _rotateSpeedEarthAndMoon; 
     120    double _rotateSpeedEarth; 
     121    double _radiusMoon; 
     122    double _RorbitMoon; 
     123    double _rotateSpeedMoon; 
     124     
     125    SolarSystem( 
     126        double _radiusSun = 20.0, 
     127        double _radiusEarth = 10.0, 
     128        double _RorbitEarth = 100.0, 
     129        double _tiltEarth = 5.0, 
     130        double _rotateSpeedEarthAndMoon = 5.0, 
     131        double _rotateSpeedEarth = 5.0, 
     132        double _radiusMoon = 2.0, 
     133        double _RorbitMoon = 20.0, 
     134        double _rotateSpeedMoon = 5.0 ) 
    31135    {} 
    32136     
    33     double radiusSun; 
    34     double RorbitEarth; 
    35     double radiusEarth; 
    36     double radiusMoon; 
    37     double RorbitMoon; 
    38     double tiltEarth; 
    39     double rotateSpeedEarth; 
    40 }; 
    41  
    42 osg::Node* createSolarSystem(SolarSystemParameters& parameters) 
    43 { 
    44     return 0; 
    45 } 
     137    osg::Group* built() 
     138    { 
     139        osg::Group* thisSystem = new osg::Group; 
     140         
     141         
     142        // create the sun 
     143        osg::Node* sun = createPlanet( _radiusSun, "Sun", osg::Vec4( 1.0f, 1.0f, 0.5f, 1.0f) ); 
     144         
     145        // stick sun right under root, no transformations for the sun 
     146        thisSystem->addChild( sun ); 
     147         
     148         
     149         
     150        //creating right side of the graph with earth and moon and the rotations above it 
     151         
     152        // create earth and moon 
     153        osg::Node* earth = createPlanet( _radiusEarth, "Earth", osg::Vec4( 0.0f, 0.0f, 1.0f, 1.0f) ); 
     154        osg::Node* moon = createPlanet( _radiusMoon, "Moon", osg::Vec4( 1.0f, 1.0f, 1.0f, 1.0f) ); 
     155         
     156        // create transformations for the earthMoonGroup 
     157        osg::MatrixTransform* aroundSunRotation = createRotation( _RorbitEarth, _rotateSpeedEarthAndMoon ); 
     158        osg::MatrixTransform* earthPosition = createEarthTranslationAndTilt( _RorbitEarth, _tiltEarth ); 
     159         
     160        //Group with earth and moon under it 
     161        osg::Group* earthMoonGroup = new osg::Group; 
     162         
     163        //transformation to rotate the earth around itself 
     164        osg::MatrixTransform* earthRotationAroundItself = createRotation ( 0.0, _rotateSpeedEarth ); 
     165         
     166        //transformations for the moon 
     167        osg::MatrixTransform* moonAroundEarthXform = createRotation( _RorbitMoon, _rotateSpeedMoon ); 
     168        osg::MatrixTransform* moonTranslation = createMoonTranslation( _RorbitMoon ); 
     169         
     170         
     171        moonTranslation->addChild( moon ); 
     172        moonAroundEarthXform->addChild( moonTranslation ); 
     173        earthMoonGroup->addChild( moonAroundEarthXform ); 
     174         
     175        earthRotationAroundItself->addChild( earth ); 
     176        earthMoonGroup->addChild( earthRotationAroundItself ); 
     177         
     178         
     179        earthPosition->addChild( earthMoonGroup ); 
     180        aroundSunRotation->addChild( earthPosition ); 
     181         
     182         
     183        thisSystem->addChild( aroundSunRotation ); 
     184                 
     185        return( thisSystem ); 
     186    } 
     187     
     188    void printParameters() 
     189    { 
     190        std::cout << "radiusSun\t= " << _radiusSun << std::endl; 
     191        std::cout << "radiusEarth\t= " << _radiusEarth << std::endl; 
     192        std::cout << "RorbitEarth\t= " << _RorbitEarth << std::endl; 
     193        std::cout << "tiltEarth\t= " << _tiltEarth << std::endl; 
     194        std::cout << "rotateSpeedEarthAndMoon= " << _rotateSpeedEarthAndMoon     << std::endl; 
     195        std::cout << "rotateSpeedEarth= " << _rotateSpeedEarth << std::endl; 
     196        std::cout << "radiusMoon\t= " << _radiusMoon << std::endl; 
     197        std::cout << "RorbitMoon\t= " << _RorbitMoon << std::endl; 
     198        std::cout << "rotateSpeedMoon\t= " << _rotateSpeedMoon << std::endl; 
     199    } 
     200     
     201};  // end SolarSystem 
     202 
    46203 
    47204int main( int argc, char **argv ) 
     
    64221    viewer.getUsage(*arguments.getApplicationUsage()); 
    65222 
    66  
    67  
    68     SolarSystemParameters parameters; 
    69  
    70     while (arguments.read("--radiusMoon",parameters.radiusMoon)) {} 
    71  
     223    SolarSystem solarSystem; 
     224 
     225    while (arguments.read("--radiusSun",solarSystem._radiusSun)) { } 
     226    while (arguments.read("--radiusEarth",solarSystem._radiusEarth)) { } 
     227    while (arguments.read("--RorbitEarth",solarSystem._RorbitEarth)) { } 
     228    while (arguments.read("--tiltEarth",solarSystem._tiltEarth)) { } 
     229    while (arguments.read("--rotateSpeedEarthAndMoon",solarSystem._rotateSpeedEarthAndMoon)) { } 
     230    while (arguments.read("--rotateSpeedEarth",solarSystem._rotateSpeedEarth)) { } 
     231    while (arguments.read("--radiusMoon",solarSystem._radiusMoon)) { } 
     232    while (arguments.read("--RorbitMoon",solarSystem._RorbitMoon)) { } 
     233    while (arguments.read("--rotateSpeedMoon",solarSystem._rotateSpeedMoon)) { } 
     234 
     235 
     236    // solarSystem.printParameters(); 
    72237 
    73238    // if user request help write it out to cout. 
    74239    if (arguments.read("-h") || arguments.read("--help")) 
    75240    { 
    76         arguments.getApplicationUsage()->write(std::cout); 
     241        std::cout << "setup the following arguments: " << std::endl; 
     242        std::cout << "--radiusSun: double" << std::endl; 
     243        std::cout << "--radiusEarth: double" << std::endl; 
     244        std::cout << "--RorbitEarth: double" << std::endl; 
     245        std::cout << "--tiltEarth: double" << std::endl; 
     246        std::cout << "--rotateSpeedEarthAndMoon: double" << std::endl; 
     247        std::cout << "--rotateSpeedEarth: double" << std::endl; 
     248        std::cout << "--radiusMoon: double" << std::endl; 
     249        std::cout << "--RorbitMoon: double" << std::endl; 
     250        std::cout << "--rotateSpeedMoon: double" << std::endl; 
     251                 
    77252        return 1; 
    78253    } 
     
    88263    } 
    89264     
    90     // load the nodes from the commandline arguments. 
    91     osg::Node* model = createSolarSystem(parameters); 
    92     if (!model) 
    93     { 
    94         return 1; 
    95     } 
    96      
    97     std::cout << "radiusSun = " << parameters.radiusSun << std::endl; 
    98     std::cout << "RorbitEarth = " << parameters.RorbitEarth << std::endl; 
    99     std::cout << "radiusEarth = " << parameters.radiusEarth << std::endl; 
    100     std::cout << "radiusMoon = " << parameters.radiusMoon << std::endl; 
    101     std::cout << "RorbitMoon = " << parameters.RorbitMoon << std::endl; 
    102     std::cout << "tiltEarth = " << parameters.tiltEarth << std::endl; 
    103     std::cout << "rotateSpeedEarth = " << parameters.rotateSpeedEarth << std::endl; 
    104  
    105      
     265     
     266    osg::Group* root = solarSystem.built(); 
     267         
    106268    /* 
    107269    // tilt the scene so the default eye position is looking down on the model. 
     
    109271    rootnode->setMatrix(osg::Matrix::rotate(osg::inDegrees(30.0f),1.0f,0.0f,0.0f)); 
    110272    rootnode->addChild(model); 
     273    */ 
    111274 
    112275    // run optimization over the scene graph 
    113276    osgUtil::Optimizer optimzer; 
    114     optimzer.optimize(rootnode); 
     277    optimzer.optimize( root ); 
    115278      
    116279    // set the scene to render 
    117     viewer.setSceneData(rootnode); 
     280    viewer.setSceneData( root ); 
    118281 
    119282    // create the windows and run the threads. 
     
    136299    // wait for all cull and draw threads to complete before exit. 
    137300    viewer.sync(); 
    138 */ 
     301 
    139302    return 0; 
    140303} 
    141  
    142 /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
    143 osg::AnimationPath* createAnimationPath(const osg::Vec3& center,float radius,double looptime) 
    144 { 
    145     // set up the animation path  
    146     osg::AnimationPath* animationPath = new osg::AnimationPath; 
    147     animationPath->setLoopMode(osg::AnimationPath::LOOP); 
    148      
    149     int numSamples = 40; 
    150     float yaw = 0.0f; 
    151     float yaw_delta = 2.0f*osg::PI/((float)numSamples-1.0f); 
    152     float roll = osg::inDegrees(30.0f); 
    153      
    154     double time=0.0f; 
    155     double time_delta = looptime/(double)numSamples; 
    156     for(int i=0;i<numSamples;++i) 
    157     { 
    158         osg::Vec3 position(center+osg::Vec3(sinf(yaw)*radius,cosf(yaw)*radius,0.0f)); 
    159         osg::Quat rotation(osg::Quat(roll,osg::Vec3(0.0,1.0,0.0))*osg::Quat(-(yaw+osg::inDegrees(90.0f)),osg::Vec3(0.0,0.0,1.0))); 
    160          
    161         animationPath->insert(time,osg::AnimationPath::ControlPoint(position,rotation)); 
    162  
    163         yaw += yaw_delta; 
    164         time += time_delta; 
    165  
    166     } 
    167     return animationPath;     
    168 } 
    169  
    170 osg::Node* createBase(const osg::Vec3& center,float radius) 
    171 { 
    172  
    173      
    174  
    175     int numTilesX = 10; 
    176     int numTilesY = 10; 
    177      
    178     float width = 2*radius; 
    179     float height = 2*radius; 
    180      
    181     osg::Vec3 v000(center - osg::Vec3(width*0.5f,height*0.5f,0.0f)); 
    182     osg::Vec3 dx(osg::Vec3(width/((float)numTilesX),0.0,0.0f)); 
    183     osg::Vec3 dy(osg::Vec3(0.0f,height/((float)numTilesY),0.0f)); 
    184      
    185     // fill in vertices for grid, note numTilesX+1 * numTilesY+1... 
    186     osg::Vec3Array* coords = new osg::Vec3Array; 
    187     int iy; 
    188     for(iy=0;iy<=numTilesY;++iy) 
    189     { 
    190         for(int ix=0;ix<=numTilesX;++ix) 
    191         { 
    192             coords->push_back(v000+dx*(float)ix+dy*(float)iy); 
    193         } 
    194     } 
    195      
    196     //Just two colours - black and white. 
    197     osg::Vec4Array* colors = new osg::Vec4Array; 
    198     colors->push_back(osg::Vec4(1.0f,1.0f,1.0f,1.0f)); // white 
    199     colors->push_back(osg::Vec4(0.0f,0.0f,0.0f,1.0f)); // black 
    200     int numColors=colors->size(); 
    201      
    202      
    203     int numIndicesPerRow=numTilesX+1; 
    204     osg::UByteArray* coordIndices = new osg::UByteArray; // assumes we are using less than 256 points... 
    205     osg::UByteArray* colorIndices = new osg::UByteArray; 
    206     for(iy=0;iy<numTilesY;++iy) 
    207     { 
    208         for(int ix=0;ix<numTilesX;++ix) 
    209         { 
    210             // four vertices per quad. 
    211             coordIndices->push_back(ix    +(iy+1)*numIndicesPerRow); 
    212             coordIndices->push_back(ix    +iy*numIndicesPerRow); 
    213             coordIndices->push_back((ix+1)+iy*numIndicesPerRow); 
    214             coordIndices->push_back((ix+1)+(iy+1)*numIndicesPerRow); 
    215              
    216             // one color per quad 
    217             colorIndices->push_back((ix+iy)%numColors); 
    218         } 
    219     } 
    220      
    221  
    222     // set up a single normal 
    223     osg::Vec3Array* normals = new osg::Vec3Array; 
    224     normals->push_back(osg::Vec3(0.0f,0.0f,1.0f)); 
    225      
    226  
    227     osg::Geometry* geom = new osg::Geometry; 
    228     geom->setVertexArray(coords); 
    229     geom->setVertexIndices(coordIndices); 
    230      
    231     geom->setColorArray(colors); 
    232     geom->setColorIndices(colorIndices); 
    233     geom->setColorBinding(osg::Geometry::BIND_PER_PRIMITIVE); 
    234      
    235     geom->setNormalArray(normals); 
    236     geom->setNormalBinding(osg::Geometry::BIND_OVERALL); 
    237      
    238     geom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::QUADS,0,coordIndices->size())); 
    239      
    240     osg::Geode* geode = new osg::Geode; 
    241     geode->addDrawable(geom); 
    242      
    243     return geode; 
    244 } 
    245  
    246 osg::Node* createMovingModel(const osg::Vec3& center, float radius) 
    247 { 
    248     float animationLength = 10.0f; 
    249  
    250     osg::AnimationPath* animationPath = createAnimationPath(center,radius,animationLength); 
    251  
    252     osg::Group* model = new osg::Group; 
    253  
    254     osg::Node* glider = osgDB::readNodeFile("glider.osg"); 
    255     if (glider) 
    256     { 
    257         const osg::BoundingSphere& bs = glider->getBound(); 
    258  
    259         float size = radius/bs.radius()*0.3f; 
    260         osg::MatrixTransform* positioned = new osg::MatrixTransform; 
    261         positioned->setDataVariance(osg::Object::STATIC); 
    262         positioned->setMatrix(osg::Matrix::translate(-bs.center())* 
    263                                      osg::Matrix::scale(size,size,size)* 
    264                                      osg::Matrix::rotate(osg::inDegrees(-90.0f),0.0f,0.0f,1.0f)); 
    265      
    266         positioned->addChild(glider); 
    267      
    268         osg::PositionAttitudeTransform* xform = new osg::PositionAttitudeTransform;     
    269         xform->setUpdateCallback(new osg::AnimationPathCallback(animationPath,0.0,1.0)); 
    270         xform->addChild(positioned); 
    271  
    272         model->addChild(xform); 
    273     } 
    274   
    275     osg::Node* cessna = osgDB::readNodeFile("cessna.osg"); 
    276     if (cessna) 
    277     { 
    278         const osg::BoundingSphere& bs = cessna->getBound(); 
    279  
    280         float size = radius/bs.radius()*0.3f; 
    281         osg::MatrixTransform* positioned = new osg::MatrixTransform; 
    282         positioned->setDataVariance(osg::Object::STATIC); 
    283         positioned->setMatrix(osg::Matrix::translate(-bs.center())* 
    284                                      osg::Matrix::scale(size,size,size)* 
    285                                      osg::Matrix::rotate(osg::inDegrees(180.0f),0.0f,0.0f,1.0f)); 
    286      
    287         positioned->addChild(cessna); 
    288      
    289         osg::MatrixTransform* xform = new osg::MatrixTransform; 
    290         xform->setUpdateCallback(new osg::AnimationPathCallback(animationPath,0.0f,2.0)); 
    291         xform->addChild(positioned); 
    292  
    293         model->addChild(xform); 
    294     } 
    295      
    296     return model; 
    297 } 
    298  
    299 osg::Node* createModel() 
    300 { 
    301     osg::Vec3 center(0.0f,0.0f,0.0f); 
    302     float radius = 100.0f; 
    303  
    304     osg::Group* root = new osg::Group; 
    305  
    306     root->addChild(createMovingModel(center,radius*0.8f)); 
    307  
    308     root->addChild(createBase(center-osg::Vec3(0.0f,0.0f,radius*0.5),radius)); 
    309  
    310     return root; 
    311 } */