FGFS-4.1/OpenSceneGraph
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Synch with 20010921

Browse Source
This commit is contained in:
Don BURNS
2001-09-22 02:42:08 +00:00
parent d47b8f9c1f
commit 7ae58df42a
197 changed files with 7867 additions and 6189 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/Demos/Makefile
View File

@@ -1,7 +1,7 @@
#!smake
SHELL=/bin/sh
DIRS = sgv osgconv osgcube osgreflect osgtexture osgimpostor osgviews hangglide
DIRS = sgv osgconv osgcube osgreflect osgtexture osgimpostor osgviews hangglide osgcluster
all :
for f in $(DIRS) ; do cd $$f; $(MAKE) || exit 1; cd ..; done

26
src/Demos/osgcluster/osgcluster.cpp
View File

@@ -26,13 +26,15 @@ class CameraPacket {
CameraPacket():_masterKilled(false) {}
void setPacket(const osg::Camera& camera,int tnum, double rtime)
void setPacket(const osg::Camera& camera,const osg::FrameStamp* frameStamp)
{
_eye = camera.getEyePoint();
_center = camera.getCenterPoint();
_up = camera.getUpVector();
_traversalNumber = tnum;
_referenceTime = rtime;
if (frameStamp)
{
_frameStamp = *frameStamp;
}
}
void getCamera(osg::Camera& camera,float angle_offset=0.0f)
@@ -50,8 +52,9 @@ class CameraPacket {
void getSceneViewUpdate(osgUtil::SceneView& sv)
{
sv.setTraversalNumber(_traversalNumber);
sv.setReferenceTime(_referenceTime);
// note pass a seperate reference counted FrameStamp
// rather than this frame stamp as it can get overwritten.
sv.setFrameStamp(new osg::FrameStamp(_frameStamp));
}
void setMasterKilled(const bool flag) { _masterKilled = flag; }
@@ -63,9 +66,12 @@ class CameraPacket {
osg::Vec3 _up;
bool _attachMatrix;
osg::Matrix _matrix;
int _traversalNumber;
double _referenceTime;
// note don't use a ref_ptr as used elsewhere for FrameStamp
// since we don't want to copy the pointer - but the memory.
// FrameStamp doesn't have a private destructor to allow
// us to do this, even though its a reference counted object.
osg::FrameStamp _frameStamp;
};
@@ -99,7 +105,7 @@ class MySceneView : public osgUtil::SceneView {
{
// need to broadcast my death.
CameraPacket cp;
cp.setPacket(*getCamera(),getTraversalNumber(),getReferenceTime());
cp.setPacket(*getCamera(),getFrameStamp());
cp.setMasterKilled(true);
_bc.setBuffer(&cp, sizeof( CameraPacket ));
@@ -119,7 +125,7 @@ class MySceneView : public osgUtil::SceneView {
case(MASTER):
{
CameraPacket cp;
cp.setPacket(*getCamera(),getTraversalNumber(),getReferenceTime());
cp.setPacket(*getCamera(),getFrameStamp());
_bc.setBuffer(&cp, sizeof( CameraPacket ));
_bc.sync();

112
src/Demos/osgcube/osgcube.cpp
View File

@@ -1,11 +1,4 @@
// simple animation demo written by Graeme Harkness.
// note from Robert to Robert. The animiation techinque
// present here using glut timer callbacks is one
// approach, other approaches will soon be supported
// within the osg itself via an app cullback which
// can be attached to nodes themselves. This later
// method will be the prefered approach (have a look
// at osgreflect's app visitor for a clue.)
#include <osg/Geode>
@@ -25,48 +18,60 @@
// ----------------------------------------------------------------------
// Global variables - this is basically the stuff which will be animated
// ----------------------------------------------------------------------
osg::Transform* myTransform;
osg::GeoSet* cube;
int mytime=0; // in milliseconds
unsigned int dt=50; // in milliseconds
double omega=0.002; // in inverse milliseconds
class TransformCallback : public osg::NodeCallback{
// ----------------------------------------------------------------
// This is the callback function registered with GLUT to be called
// at a future time in the GLUT loop
// ----------------------------------------------------------------
void timedCB( int delta_t )
{
public:
static float lastdx = 0;
static float lastdy = 0;
static float lastdz = 0;
TransformCallback(osg::Transform* node,float angularVelocity)
{
_nodeToOperateOn = node;
_angular_velocity = angularVelocity;
_previousTraversalNumber = -1;
_orig_t = _timer.tick();
}
mytime+=dt;
virtual void operator() (osg::Node* node, osg::NodeVisitor* nv)
{
if (nv)
{
if (_nodeToOperateOn && node==_nodeToOperateOn)
{
// ensure that we do not operate on this node more than
// once during this traversal. This is an issue since node
// can be shared between multiple parents.
if (nv->getTraversalNumber()!=_previousTraversalNumber)
{
osg::Timer_t new_t = _timer.tick();
float delta_angle = _angular_velocity*_timer.delta_s(_orig_t,new_t);
osg::Matrix matrix;
matrix.makeRot(delta_angle,1.0f,1.0f,1.0f);
matrix.postTrans(1.0f,0.0f,0.0f);
matrix.postRot(delta_angle,0.0f,0.0f,1.0f);
_nodeToOperateOn->setMatrix(matrix);
// ---------------------------------------------------------
// Update the Transform so that the cube will appear to oscillate
// ---------------------------------------------------------
double dx = 0.5 * cos( (double) omega * (double) mytime );
double dy = 0.5 * sin( (double) omega * (double) mytime );
double dz = 0.0;
myTransform->preTranslate( -lastdx, -lastdy, -lastdz );
myTransform->preTranslate( (float) dx, (float) dy, dz );
lastdx=dx; lastdy=dy; lastdz=dz;
_previousTraversalNumber = nv->getTraversalNumber();
}
}
}
// must continue subgraph traversal.
nv->traverse(*node);
}
protected:
osg::Transform* _nodeToOperateOn;
float _angular_velocity;
// Graeme, commeted out this call as the cube itself remains static.
// cube->dirtyDisplayList();
// -------------------------------------------
// If required, reschedule the timed callback
// -------------------------------------------
if ( delta_t != 0 )
{
glutTimerFunc( (unsigned int) delta_t, timedCB, delta_t );
}
}
int _previousTraversalNumber;
osg::Timer _timer;
osg::Timer_t _orig_t;
};
osg::Geode* createCube()
{
@@ -75,7 +80,7 @@ osg::Geode* createCube()
// -------------------------------------------
// Set up a new GeoSet which will be our cube
// -------------------------------------------
cube = new osg::GeoSet();
osg::GeoSet* cube = new osg::GeoSet();
// set up the primitives
cube->setPrimType( osg::GeoSet::POLYGON );
@@ -145,10 +150,7 @@ osg::Geode* createCube()
osg::StateSet* cubeState = new osg::StateSet();
osg::Material* redMaterial = new osg::Material();
osg::Vec4 red( 1.0f, 0.0f, 0.0f, 1.0f );
redMaterial->setEmission( osg::Material::FRONT_AND_BACK, red );
redMaterial->setAmbient( osg::Material::FRONT_AND_BACK, red );
redMaterial->setDiffuse( osg::Material::FRONT_AND_BACK, red );
redMaterial->setSpecular( osg::Material::FRONT_AND_BACK, red );
cubeState->setAttribute( redMaterial );
cube->setStateSet( cubeState );
@@ -164,23 +166,19 @@ int main( int argc, char **argv )
glutInit( &argc, argv );
myTransform = new osg::Transform();
osg::Transform* myTransform = new osg::Transform();
myTransform->addChild( createCube() );
// move node in a circle at 90 degrees a sec.
myTransform->setAppCallback(new TransformCallback(myTransform,90.0f));
// ---------------------------------------------------------------------
// Register a timer callback with GLUT, in the first instance as a test
// This will call the function "timedCB(value)" after dt ms
// I have decided to use value as the time for the next scheduling
// If the last parameter=0 then don't reschedule the timer.
// ---------------------------------------------------------------------
glutTimerFunc( dt, timedCB, dt );
// create the viewer and the model to it.
osgGLUT::Viewer viewer;
viewer.addViewport( myTransform );
// register trackball, flight and drive.
// register trackball maniupulators.
viewer.registerCameraManipulator(new osgUtil::TrackballManipulator);
viewer.open();
viewer.run();

93
src/Demos/osgreflect/osgreflect.cpp
View File

@@ -41,55 +41,64 @@
// we apply them.
// create an app visitor, to be used on each frame update,
// the below app visitor rotates the loaded model.
class AppVisitor : public osg::NodeVisitor {
class TransformCallback : public osg::NodeCallback{
public:
bool _haveDoneTransformTransform;
float _delta_angle;
float _angular_velocity;
osg::Vec3 _pivotPoint;
osg::Transform* _modifyTransform;
osg::Timer _timer;
osg::Timer_t _previous_t;
AppVisitor() : osg::NodeVisitor(TRAVERSE_ALL_CHILDREN)
TransformCallback(osg::Transform* node,float angularVelocity)
{
_haveDoneTransformTransform = true;
_modifyTransform = NULL;
_delta_angle = 0;
_angular_velocity = 45; //degrees a sec.
_nodeToOperateOn = node;
if (node)
{
_pivotPoint = node->getBound().center();
}
_angular_velocity = angularVelocity;
_previousTraversalNumber = -1;
_previous_t = _timer.tick();
}
virtual void reset()
virtual void operator() (osg::Node* node, osg::NodeVisitor* nv)
{
// set to no transform done so far in this new traversal.
_haveDoneTransformTransform = false;
// update angle of rotation.
osg::Timer_t new_t = _timer.tick();
_delta_angle = _angular_velocity*_timer.delta_s(_previous_t,new_t);
_previous_t = new_t;
}
virtual void apply(osg::Transform& visitor_dcs)
{
if (&visitor_dcs == _modifyTransform && !_haveDoneTransformTransform)
if (nv)
{
// update the specified dcs.
visitor_dcs.preTranslate(_pivotPoint[0],_pivotPoint[1],_pivotPoint[2]);
visitor_dcs.preRotate(_delta_angle,0.0f,0.0f,1.0f);
visitor_dcs.preTranslate(-_pivotPoint[0],-_pivotPoint[1],-_pivotPoint[2]);
if (_nodeToOperateOn && node==_nodeToOperateOn)
{
// ensure that we do not operate on this node more than
// once during this traversal. This is an issue since node
// can be shared between multiple parents.
if (nv->getTraversalNumber()!=_previousTraversalNumber)
{
osg::Timer_t new_t = _timer.tick();
float delta_angle = _angular_velocity*_timer.delta_s(_previous_t,new_t);
_previous_t = new_t;
// set to true to prevent applying rotation more than once
// since the subgraph appears twice in the overall scene.
_haveDoneTransformTransform = true;
// update the specified dcs.
_nodeToOperateOn->preTranslate(_pivotPoint[0],_pivotPoint[1],_pivotPoint[2]);
_nodeToOperateOn->preRotate(delta_angle,0.0f,0.0f,1.0f);
_nodeToOperateOn->preTranslate(-_pivotPoint[0],-_pivotPoint[1],-_pivotPoint[2]);
_previousTraversalNumber = nv->getTraversalNumber();
}
}
}
// must continue subgraph traversal.
nv->traverse(*node);
}
protected:
osg::Transform* _nodeToOperateOn;
float _angular_velocity;
osg::Vec3 _pivotPoint;
int _previousTraversalNumber;
osg::Timer _timer;
osg::Timer_t _previous_t;
};
/*
@@ -463,13 +472,7 @@ int main( int argc, char **argv )
osgGLUT::Viewer viewer;
viewer.addViewport( rootNode );
// create and register the app visitor.
AppVisitor* appVisitor = new AppVisitor();
appVisitor->_modifyTransform = loadedModelTransform;
appVisitor->_pivotPoint = bs.center();
viewer.getViewportSceneView(0)->setAppVisitor(appVisitor);
loadedModelTransform->setAppCallback(new TransformCallback(loadedModelTransform,45.0f));
// register trackball, flight and drive.
viewer.registerCameraManipulator(new osgUtil::TrackballManipulator);

15
src/Demos/sgv/sgv.cpp
View File

@@ -15,7 +15,8 @@
#include <GL/glut.h>
#include <osgGLUT/Viewer>
#include <osg/Quat>
#include <osgUtil/OptimizeStateVisitor>
/*
* Function to read several files (typically one) as specified on the command
@@ -130,6 +131,18 @@ int main( int argc, char **argv )
osg::Timer_t after_load = timer.tick();
cout << "Time for load = "<<timer.delta_s(before_load,after_load)<<" seconds"<<endl;
// note, the Microsoft visual C++ compilers can't handle the STL
// in the OptimizeStateVisitor and crash if we run it. For the
// time being we'll just not use the optimize visitor under windows.
#ifndef WIN32
// optimize the state in scene graph, removing duplicate state.
osgUtil::OptimizeStateVisitor osv;
rootnode->accept(osv);
osv.optimize();
#endif
// initialize the viewer.
osgGLUT::Viewer viewer;
viewer.addViewport( rootnode );