void motion(int x, int y)
{
float w = win->getWidth(),
h = win->getHeight();
float a = -2 * ( lastx / w - 0.5 ),
b = -2 * ( 0.5 - lasty / h ),
c = -2 * ( x / w - 0.5 ),
d = -2 * ( 0.5 - y / h );
if ( mouseb & ( 1 << GLUT_LEFT_BUTTON ) )
{
trackball.updateRotation( a, b, c, d );
}
else if ( mouseb & ( 1 << GLUT_MIDDLE_BUTTON ) )
{
trackball.updatePosition( a, b, c, d );
}
else if ( mouseb & ( 1 << GLUT_RIGHT_BUTTON ) )
{
trackball.updatePositionNeg( a, b, c, d );
}
lastx = x;
lasty = y;
}
void mouse(int button, int state, int x, int y)
{
if ( state == 0 )
{
switch ( button )
{
case GLUT_LEFT_BUTTON: break;
case GLUT_MIDDLE_BUTTON:tball.setAutoPosition(true);
break;
case GLUT_RIGHT_BUTTON: tball.setAutoPositionNeg(true);
break;
}
mouseb |= 1 << button;
}
else if ( state == 1 )
{
switch ( button )
{
case GLUT_LEFT_BUTTON: break;
case GLUT_MIDDLE_BUTTON:tball.setAutoPosition(false);
break;
case GLUT_RIGHT_BUTTON: tball.setAutoPositionNeg(false);
break;
}
mouseb &= ~(1 << button);
}
lastx = x;
lasty = y;
}
void MyOSGQGLWidget::mouseMoveEvent(QMouseEvent *me)
{
OSG::Real32 w = osgWin->getWidth(); // force the calc to Real32
OSG::Real32 h = osgWin->getHeight();
OSG::Real32 a = -2. * (lastx / w - .5 );
OSG::Real32 b = -2. * (.5 - lasty / h );
OSG::Real32 c = -2. * (me->pos().x() / w - .5);
OSG::Real32 d = -2. * (.5 - me->pos().y() / h);
if(mouseb & Qt::LeftButton)
{
tball.updateRotation(a, b, c, d);
}
else if(mouseb & Qt::MidButton)
{
tball.updatePosition(a, b, c, d);
}
else if(mouseb & Qt::RightButton)
{
tball.updatePositionNeg(a, b, c, d);
}
lastx = me->pos().x();
lasty = me->pos().y();
updateGL();
}
void motion(int x, int y)
{
OSG::Real32 w = win->getWidth(), h = win->getHeight();
OSG::Real32 a = -2. * ( lastx / w - .5 ),
b = -2. * ( .5 - lasty / h ),
c = -2. * ( x / w - .5 ),
d = -2. * ( .5 - y / h );
if ( mouseb & ( 1 << GLUT_LEFT_BUTTON ) )
{
tball.updateRotation( a, b, c, d );
}
else if ( mouseb & ( 1 << GLUT_MIDDLE_BUTTON ) )
{
tball.updatePosition( a, b, c, d );
}
else if ( mouseb & ( 1 << GLUT_RIGHT_BUTTON ) )
{
tball.updatePositionNeg( a, b, c, d );
}
lastx = x;
lasty = y;
}
void display(void)
{
#if 0
Matrix m1, m2, m3;
Quaternion q1;
tball.getRotation().getValue(m3);
q1.setValue(m3);
m1.setRotate(q1);
m2.setTranslate( tball.getPosition() );
m1.mult( m2 );
if(move_obj == true)
{
scene_trans->editSFMatrix()->setValue( m1 );
}
else
{
cam_trans->editSFMatrix()->setValue( m1 );
}
#endif
cam_trans->editSFMatrix()->setValue(tball.getFullTrackballMatrix());
#if 0
fprintf(stderr, "%f %f %f\n",
cam_trans->getMatrix()[3][0],
cam_trans->getMatrix()[3][1],
cam_trans->getMatrix()[3][2]);
#endif
OSG::Real32 t = glutGet(GLUT_ELAPSED_TIME);
for(OSG::UInt32 i = 0; i < 6; ++i)
{
if(pAnimTrs[i] != NULL)
{
pAnimTrs[i]->editRotation().setValueAsAxisDeg(
0.f, 1.f, 0.f,
t / 50.f);
}
}
OSG::commitChanges();
// fprintf(stderr, "Frame start\n");
// fprintf(stderr, "============================================\n");
win->render(rentravact);
}
void display(void)
{
osg::Matrix m1, m2;
osg::Quaternion q1;
m1.setRotate( trackball.getRotation() );
m2.setTranslate( trackball.getPosition() );
m1.mult( m2 );
cam_trans->getSFMatrix()->setValue( m1 );
//move_and_check();
win->draw( render_action );
}
void redraw ( void )
{
OSG::Matrix m1, m2, m3;
OSG::Quaternion q1;
tball.getRotation().getValue(m3);
q1.setValue(m3);
m1.setRotate(q1);
m2.setTranslate( tball.getPosition() );
m1.mult( m2 );
cam_trans->editSFMatrix()->setValue( m1 );
OSG::Thread::getCurrentChangeList()->commitChanges();
win->render(ract);
}
void MyOSGQGLWidget::paintGL(void)
{
OSG::Matrix m1, m2, m3;
OSG::Quaternion q1;
tball.getRotation().getValue(m3);
q1.setValue(m3);
m1.setRotate(q1);
m2.setTranslate( tball.getPosition() );
m1.mult( m2 );
cam_trans->setMatrix( m1 );
OSG::commitChanges();
osgWin->render(ract); // draw the viewports
}
void MyOSGQGLWidget::mousePressEvent(QMouseEvent *me)
{
switch(me->button())
{
case Qt::MidButton:
tball.setAutoPosition(true);
break;
case Qt::RightButton:
tball.setAutoPositionNeg(true);
break;
default:
break;
}
mouseb |= me->button();
lastx = me->x();
lasty = me->y();
}
void display(void)
{
OSG::Matrix m1;
m1 = tball.getFullTrackballMatrix();
cam_trans->editSFMatrix()->setValue(m1);
OSG::commitChanges();
win->render(rentravact);
}
int init(int argc, char **argv)
{
OSG::osgInit(argc,argv);
// GLUT init
glutInit(&argc, argv);
glutInitDisplayMode( GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE);
int winid = glutCreateWindow("OpenSG");
glutKeyboardFunc(key);
glutVisibilityFunc(vis);
glutReshapeFunc(reshape);
glutDisplayFunc(display);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutIdleFunc(display);
// OSG
OSG::SceneFileHandler::the()->print();
// create the graph
// beacon for camera and light
OSG::NodeUnrecPtr b1n = OSG::Node::create();
OSG::GroupUnrecPtr b1 = OSG::Group::create();
b1n->setCore(b1);
// transformation
OSG::NodeUnrecPtr t1n = OSG::Node::create();
OSG::TransformUnrecPtr t1 = OSG::Transform::create();
t1n->setCore (t1 );
t1n->addChild(b1n);
cam_trans = t1;
// light
OSG::NodeUnrecPtr dlight = OSG::Node::create();
OSG::DirectionalLightUnrecPtr dl = OSG::DirectionalLight::create();
dlight->setCore(dl);
dl->setAmbient (0.0, 0.0, 0.0, 1.0);
dl->setDiffuse (0.8, 0.8, 0.8, 1.0);
dl->setDirection(0.0, 0.0, 1.0 );
dl->setBeacon (b1n );
// root
OSG::NodeUnrecPtr root = OSG::Node::create();
OSG::GroupUnrecPtr gr1 = OSG::Group::create();
root->setCore (gr1 );
root->addChild(t1n );
root->addChild(dlight);
// Load the file
OSG::NodeUnrecPtr file = NULL;
if(argc > 1)
{
file = OSG::SceneFileHandler::the()->read(argv[1], NULL);
}
if(file == NULL)
{
std::cerr << "Couldn't load file, ignoring" << std::endl;
//file = OSG::makeSphere(4, 2.0);
file = OSG::Node::create();
OSG::AlgorithmStageUnrecPtr pStage = OSG::AlgorithmStage::create();
file->setCore(pStage);
pAlgo = OSG::GPUVolRTV2::create();
pStage->setAlgorithm(pAlgo);
// fix/freeze the node volume
file->editVolume().setStatic(true);
file->editVolume().setBounds( 0.f, 0.f, 0.f,
1.f, 1.f, 1.f);
}
OSG::commitChanges();
file->updateVolume();
OSG::Vec3f min,max;
file->getVolume().getBounds( min, max );
std::cout << "Volume: from " << min << " to " << max << std::endl;
OSG::MultiCoreUnrecPtr pMCore = OSG::MultiCore::create();
pCOver = OSG::ChunkOverrideGroup::create();
OSG::TransformRecPtr scene_trans = OSG::Transform::create();
pMCore->addCore(scene_trans);
pMCore->addCore(pCOver );
pPoly = OSG::PolygonChunk::create();
OSG::NodeUnrecPtr sceneTrN = OSG::Node::create();
sceneTrN->setCore (pMCore);
sceneTrN->addChild(file );
dlight->addChild(sceneTrN);
// Camera
OSG::PerspectiveCameraRecPtr cam = OSG::PerspectiveCamera::create();
cam->setBeacon(b1n );
cam->setFov (OSG::osgDegree2Rad(60));
cam->setNear (0.1 );
cam->setFar (400 );
// Background
OSG::SolidBackgroundUnrecPtr bkgnd = OSG::SolidBackground::create();
bkgnd->setColor(OSG::Color3f(0,0,0));
// Viewport
OSG::ViewportRecPtr vp = OSG::Viewport::create();
vp->setCamera (cam );
vp->setBackground(bkgnd );
vp->setRoot (root );
vp->setSize (0, 0, 1, 1);
// Window
std::cout << "GLUT winid: " << winid << std::endl;
GLint glvp[4];
glGetIntegerv(GL_VIEWPORT, glvp);
OSG::GLUTWindowUnrecPtr gwin = OSG::GLUTWindow::create();
gwin->setGlutId(winid);
gwin->setSize( glvp[2], glvp[3] );
win = gwin;
win->addPort(vp);
win->init();
// Action
rentravact = OSG::RenderAction::create();
// renact->setFrustumCulling(false);
// tball
OSG::Vec3f pos;
pos.setValues(min[0] + ((max[0] - min[0]) * 0.5),
min[1] + ((max[1] - min[1]) * 0.5),
max[2] + ( max[2] - min[2] ) * 1.5 );
float scale = (max[2] - min[2] + max[1] - min[1] + max[0] - min[0]) / 6;
OSG::Pnt3f tCenter(min[0] + (max[0] - min[0]) / 2,
min[1] + (max[1] - min[1]) / 2,
min[2] + (max[2] - min[2]) / 2);
fprintf(stderr, "Startpos : %f %f %f\n", pos[0], pos[1], pos[2]);
tball.setMode (OSG::Trackball::OSGObject);
tball.setStartPosition (pos, true );
tball.setSum (true );
tball.setTranslationMode (OSG::Trackball::OSGFree );
tball.setTranslationScale(scale );
tball.setRotationCenter (tCenter );
// run...
return 0;
}
void display(void)
{
OSG::Time t;
// std::cout << glutGet(GLUT_WINDOW_WIDTH) << std::endl;
t=-OSG::getSystemTime();
if(animate && animPos.size()>1)
{
if(animLength>0)
animTime = frameCount * (animPos.size())/float(animLength);
OSG::UInt32 i=OSG::UInt32(animTime);
OSG::Real32 a=animTime-i;
OSG::Vec3f v;
OSG::Quaternion q;
if(i+1 < animPos.size())
{
v = animPos[i] + (animPos[i+1] - animPos[i]) * a;
q = OSG::Quaternion::slerp(animOri[i],animOri[i+1],a);
}
else
{
v = animPos[i];
q = animOri[i];
}
cam_trans->editMatrix().setTranslate(v[0],v[1],v[2]);
cam_trans->editMatrix().setRotate(q);
}
else
{
cam_trans->editSFMatrix()->setValue( tball.getFullTrackballMatrix() );
}
try
{
OSG::Thread::getCurrentChangeList()->commitChanges();
#if 0
clusterWindow->activate();
clusterWindow->frameInit();
clusterWindow->renderAllViewports(ract);
#endif
clusterWindow->renderNoFinish(ract);
#if 0
if(showInfo)
{
displayInfo(10,90);
/*
char text[1024];
sprintf(text,"FPS: %12.1f",1.0/frame_time);
showText(10,70,text);
sprintf(text,"Positions: %12d",sum_positions);
showText(10,50,text);
sprintf(text,"Triangles: %12d",sum_triangles);
showText(10,30,text);
sprintf(text,"Geometries: %12d",sum_geometries);
showText(10,10,text);
*/
}
#endif
#if 0
clusterWindow->swap();
clusterWindow->frameExit();
#endif
clusterWindow->frameFinish();
// clear changelist from prototypes
OSG::Thread::getCurrentChangeList()->clear();
}
catch(OSG_STDEXCEPTION_NAMESPACE::exception &e)
{
std::cout << e.what() << std::endl;
cleanup();
exit(0);
}
t+=OSG::getSystemTime();
frame_time = t;
if(animate && animPos.size()>1)
{
OSG::Vec3f v;
printf("Frame %8.3f %8.5f %8.3f\n",
animTime,
t,1/t);
frameCount++;
if(frameCount == animLength)
{
animTime = 0;
frameCount = 0;
if(animLoops > 0)
{
animLoops--;
if(!animLoops)
{
cleanup();
exit(0);
}
}
}
}
}
void init(std::vector<std::string> &filenames)
{
size_t i;
OSG::DirectionalLightUnrecPtr dl;
OSG::Real32 x,y,z;
OSG::BoxVolume volume;
OSG::Vec3f min,max;
OSG::Vec3f size;
glEnable( GL_DEPTH_TEST );
glEnable( GL_LIGHTING );
glEnable( GL_LIGHT0 );
// GLint twoSide = 1;
// glLightModeliv(GL_LIGHT_MODEL_TWO_SIDE,&twoSide);
glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
// create the graph
// beacon for camera and light
OSG::NodeUnrecPtr b1n = OSG::Node::create();
OSG::GroupUnrecPtr b1 = OSG::Group::create();
b1n->setCore( b1 );
// transformation
OSG::NodeUnrecPtr t1n = OSG::Node::create();
OSG::TransformUnrecPtr t1 = OSG::Transform::create();
t1n->setCore( t1 );
t1n->addChild( b1n );
cam_trans = t1;
// light
OSG::NodeUnrecPtr dlight = OSG::Node::create();
dl = OSG::DirectionalLight::create();
dlight->setCore( dl );
dl->setAmbient( .3f, .3f, .3f, 1 );
dl->setDiffuse( 1, 1, 1, 1 );
dl->setDirection(0,0,1);
dl->setBeacon( b1n);
// root
root = OSG::Node::create();
OSG::GroupUnrecPtr gr1 = OSG::Group::create();
root->setCore( gr1 );
root->addChild( t1n );
root->addChild( dlight );
// Load the file
OSG::NodeUnrecPtr scene = OSG::Node::create();
scene->setCore(OSG::Group::create());
OSG::NodeUnrecPtr file;
for(i=0;i<filenames.size();i++)
{
file = OSG::SceneFileHandler::the()->read(filenames[i].c_str(),0);
if(file != NULL)
scene->addChild(file);
else
std::cerr << "Couldn't load file, ignoring " << filenames[i] << std::endl;
}
if ( filenames.size()==0 )
{
file = OSG::makeTorus( .5, 2, 16, 16 );
scene->addChild(file);
// scene->addChild(makeBox(.6,.6,.6,5,5,5));
}
prepareSceneGraph(scene);
OSG::Thread::getCurrentChangeList()->commitChanges();
scene->invalidateVolume();
scene->updateVolume();
volume=scene->getVolume();
volume.getBounds(min,max);
size = max-min;
if(ca>0)
{
if(cb==-1)
cb=ca;
if(cc==-1)
cc=cb;
OSG::NodeUnrecPtr node;
OSG::NodeUnrecPtr geoNode;
OSG::TransformUnrecPtr trans;
for(x=-ca/2.0 ; x<ca/2.0 ; x++)
for(y=-cb/2.0 ; y<cb/2.0 ; y++)
for(z=-cc/2.0 ; z<cc/2.0 ; z++)
{
trans=OSG::Transform::create();
node=OSG::Node::create();
node->setCore(trans);
trans->editMatrix().setTranslate(
x*size[0]*1.1,
y*size[1]*1.1,
z*size[2]*1.1);
geoNode = OSG::cloneTree(scene);
geoNode->editSFVolume()->getValue() = scene->getSFVolume()->getValue();
geoNode->editVolume(false).setValid(true);
node->addChild( geoNode );
dlight->addChild(node);
}
}
else
{
dlight->addChild(scene);
}
if(ca>0)
{
sum_geometries*=OSG::UInt32(ca*cb*cc);
sum_triangles *=OSG::UInt32(ca*cb*cc);
sum_positions *=OSG::UInt32(ca*cb*cc);
}
OSG::Thread::getCurrentChangeList()->commitChanges();
// dlight->invalidateVolume();
printf("update Volume\n");
dlight->updateVolume();
printf("update Volume OK\n");
// should check first. ok for now.
const OSG::BoxVolume &vol = dlight->getVolume();
OSG::Pnt3f center;
vol.getBounds(min, max);
vol.getCenter(center);
size = max - min;
std::cout << "Volume: from " << min << " to " << max << std::endl;
std::cout << "Center: " << center << std::endl;
// Camera
OSG::PerspectiveCameraUnrecPtr cam = OSG::PerspectiveCamera::create();
cam->setBeacon( b1n );
cam->setFov( OSG::osgDegree2Rad( 60 ) );
cam->setNear( 10 );
cam->setFar( 50000 );
// Solid Background
bkgnd = OSG::SolidBackground::create();
bkgnd->setColor( OSG::Color3f(0,0,0) );
// bkgnd->setColor( OSG::Color3f(.1,.1,.6) );
// bkgnd->setColor( OSG::Color3f(1,1,1) );
// Viewport
OSG::ViewportUnrecPtr vp1;
OSG::ViewportUnrecPtr vp2;
if(stereoMode == 0)
{
vp1 = OSG::Viewport::create();
vp1->setCamera ( cam );
vp1->setBackground( bkgnd );
vp1->setRoot ( root );
vp1->setSize ( 0,0, 1,1 );
if(multiport)
{
vp2 = OSG::Viewport::create();
vp2->setCamera ( cam );
vp2->setBackground( bkgnd );
vp2->setRoot ( root );
vp2->setSize ( .1f, .55f, .7f,.95f );
}
}
else if(stereoMode == 1)
{
OSG::ShearedStereoCameraDecoratorUnrecPtr deco;
// left
deco=OSG::ShearedStereoCameraDecorator::create();
deco->setLeftEye(true);
deco->setEyeSeparation(eyedistance);
deco->setDecoratee(cam);
deco->setZeroParallaxDistance(zeroparallax);
vp1 = OSG::Viewport::create();
vp1->setCamera ( deco );
vp1->setBackground( bkgnd );
vp1->setRoot ( root );
vp1->setSize ( 0,0, .5,1 );
// right
deco=OSG::ShearedStereoCameraDecorator::create();
deco->setLeftEye(false);
deco->setEyeSeparation(eyedistance);
deco->setDecoratee(cam);
deco->setZeroParallaxDistance(zeroparallax);
vp2 = OSG::Viewport::create();
vp2->setCamera ( deco );
vp2->setBackground( bkgnd );
vp2->setRoot ( root );
vp2->setSize ( .5,0,1,1 );
}
else if(stereoMode == 2)
{
OSG::ShearedStereoCameraDecoratorUnrecPtr deco;
// left
deco=OSG::ShearedStereoCameraDecorator::create();
deco->setLeftEye(true);
deco->setEyeSeparation(eyedistance);
deco->setDecoratee(cam);
deco->setZeroParallaxDistance(zeroparallax);
OSG::ColorBufferViewportUnrecPtr cvp1 =
OSG::ColorBufferViewport::create();
cvp1->setCamera ( deco );
cvp1->setBackground( bkgnd );
cvp1->setRoot ( root );
cvp1->setSize ( 0,0, 1,1 );
cvp1->setRed(GL_FALSE);
cvp1->setGreen(GL_TRUE);
cvp1->setBlue(GL_TRUE);
cvp1->setAlpha(GL_TRUE);
vp1 = cvp1;
// right
deco=OSG::ShearedStereoCameraDecorator::create();
deco->setLeftEye(false);
deco->setEyeSeparation(eyedistance);
deco->setDecoratee(cam);
deco->setZeroParallaxDistance(zeroparallax);
OSG::ColorBufferViewportUnrecPtr cvp2 =
OSG::ColorBufferViewport::create();
cvp2->setCamera ( deco );
cvp2->setBackground( bkgnd );
cvp2->setRoot ( root );
cvp2->setSize ( 0,0,1,1 );
cvp2->setRed(GL_TRUE);
cvp2->setGreen(GL_FALSE);
cvp2->setBlue(GL_FALSE);
cvp2->setAlpha(GL_FALSE);
vp2 = cvp2;
}
GLint glvp[4];
glGetIntegerv( GL_VIEWPORT, glvp );
if(serverx>0 && servery>0)
clusterWindow->setSize( serverx, servery );
else
clusterWindow->setSize( glvp[2], glvp[3] );
clusterWindow->addPort( vp1 );
if(multiport || stereoMode > 0)
clusterWindow->addPort( vp2 );
if(serviceInterfaceValid == true)
{
clusterWindow->setServiceInterface(serviceInterface);
fprintf(stderr, "tcclient use if %s\n", serviceInterface.c_str());
}
if(serviceAddressValid == true)
{
clusterWindow->setServiceAddress(serviceAddress);
fprintf(stderr, "tcclient use ba %s\n", serviceAddress.c_str());
}
// tball
OSG::Vec3f pos(min[0] + ((max[0] - min[0]) * 0.5),
min[1] + ((max[1] - min[1]) * 0.5),
max[2] + ( max[2] - min[2] ) * 1.5 );
float scale = (max[2] - min[2] + max[1] - min[1] + max[0] - min[0]) / 6;
tball.setMode( OSG::Trackball::OSGObject );
tball.setStartPosition( pos, true );
tball.setSum( true );
tball.setTranslationMode( OSG::Trackball::OSGFree );
tball.setTranslationScale(scale);
tball.setRotationCenter(center);
tball.setTranslationGen(OSG::Trackball::OSGAbsoluteTranslation);
// run...
std::cout << size.length() << std::endl;
cam->setFar (size.length() * 100.0);
cam->setNear(size.length() * 100.0 / 100000.0);
}
int init(int argc, char **argv)
{
OSG::osgInit(argc,argv);
// GLUT init
glutInit(&argc, argv);
glutInitDisplayMode( GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE);
int winid = glutCreateWindow("OpenSG");
glutKeyboardFunc(key);
glutVisibilityFunc(vis);
glutReshapeFunc(reshape);
glutDisplayFunc(display);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutIdleFunc(display);
// glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
// glEnable( GL_DEPTH_TEST );
// glEnable( GL_LIGHTING );
// glEnable( GL_LIGHT0 );
// glFrontFace(GL_CW);
glEnable(GL_CULL_FACE);
// OSG
OSG::SceneFileHandler::the()->print();
// create the graph
// beacon for camera and light
OSG::NodeUnrecPtr b1n = OSG::Node::create();
OSG::GroupUnrecPtr b1 = OSG::Group::create();
b1n->setCore( b1 );
// transformation
OSG::NodeUnrecPtr t1n = OSG::Node::create();
OSG::TransformUnrecPtr t1 = OSG::Transform::create();
t1n->setCore( t1 );
t1n->addChild( b1n );
cam_trans = t1;
// light
OSG::NodeUnrecPtr dlight = OSG::Node::create();
OSG::DirectionalLightUnrecPtr dl = OSG::DirectionalLight::create();
dlight->setCore( dl );
// dlight->setCore( Group::create() );
dl->setAmbient( .0, .0, .0, 1 );
dl->setDiffuse( .8f, .8f, .8f, 1.f );
dl->setDirection(0,0,1);
dl->setBeacon( b1n);
// root
root = OSG::Node::create();
OSG::GroupUnrecPtr gr1 = OSG::Group::create();
root->setCore( gr1 );
root->addChild( t1n );
root->addChild( dlight );
// Load the file
OSG::NodeUnrecPtr file = NULL;
if(argc > 1)
file = OSG::SceneFileHandler::the()->read(argv[1], NULL);
if ( file == NULL )
{
std::cerr << "Couldn't load file, ignoring" << std::endl;
file = OSG::makeSphere(4, 2.0);
}
#if 0
OSG::GeometryPtr pGeo = cast_dynamic<OSG::GeometryPtr>(file->getCore());
if(pGeo == NULL && file->getNChildren() != 0)
{
pGeo = cast_dynamic<OSG::GeometryPtr>(file->getChild(0)->getCore());
}
if(pGeo == NULL)
{
fprintf(stderr, "no geo\n");
}
#endif
// OSG::GraphOpRefPtr op = OSG::GraphOpFactory::the()->create("Stripe");
// op->traverse(file);
// createOptimizedPrimitives(pGeo);
// createSharedIndex(pGeo);
OSG::Thread::getCurrentChangeList()->commitChanges();
// file->dump();
file->updateVolume();
#if 0
const char *outFileName = "/tmp/foo1.osg";
OSG::IndentFileOutStream outFileStream(outFileName);
if( !outFileStream )
{
std::cerr << "Can not open output stream to file: "
<< outFileName << std::endl;
return -1;
}
std::cerr << "STARTING PRINTOUT:" << std::endl;
OSGWriter writer( outFileStream, 4 );
writer.write( file );
outFileStream.close();
OSG::SceneFileHandler::the()->write(file, "/tmp/foo.osb");
#endif
// return 0;
OSG::Vec3f min,max;
file->getVolume().getBounds( min, max );
std::cout << "Volume: from " << min << " to " << max << std::endl;
OSG::MultiCoreUnrecPtr pMCore = OSG::MultiCore::create();
pCOver = OSG::ChunkOverrideGroup::create();
scene_trans = OSG::Transform::create();
pMCore->addCore(scene_trans);
pMCore->addCore(pCOver );
OSG::NodeUnrecPtr sceneTrN = OSG::Node::create();
sceneTrN->setCore(pMCore);
sceneTrN->addChild(file);
dlight->addChild(sceneTrN);
std::cerr << "Tree: " << std::endl;
// root->dump();
// Camera
cam = OSG::PerspectiveCamera::create();
cam->setBeacon( b1n );
cam->setFov( OSG::osgDegree2Rad( 90 ) );
cam->setNear( 0.1f );
cam->setFar( 100000 );
// Background
OSG::SolidBackgroundUnrecPtr bkgnd = OSG::SolidBackground::create();
bkgnd->setColor(OSG::Color3f(1,0,0));
// Viewport
vp = OSG::Viewport::create();
vp->setCamera( cam );
vp->setBackground( bkgnd );
vp->setRoot( root );
vp->setSize( 0,0, 1,1 );
#if 0
OSG::UInt8 imgdata[] =
{
64,64,64, 128,128,128, 192,192,192, 255,255,255
};
#endif
pImg = OSG::Image::create();
pImg->set(OSG::Image::OSG_RGB_PF, 128, 128); //, 1, 1, 1, 0.0, imgdata);
tx1o = OSG::TextureObjChunk::create();
tx1e = OSG::TextureEnvChunk::create();
tx1o->setImage (pImg );
tx1o->setMinFilter(GL_LINEAR );
tx1o->setMagFilter(GL_LINEAR );
tx1o->setWrapS (GL_CLAMP );
tx1o->setWrapT (GL_CLAMP );
tx1e->setEnvMode (GL_REPLACE);
OSG::SimpleMaterialUnrecPtr mat = OSG::SimpleMaterial::create();
mat->setDiffuse(OSG::Color3f(1,1,1));
mat->setLit (false );
mat->addChunk (tx1o );
mat->addChunk (tx1e );
OSG::PolygonForegroundUnrecPtr pFG = OSG::PolygonForeground::create();
pFG->setMaterial(mat);
OSG::MFPnt2f *pPos = pFG->editMFPositions();
OSG::MFVec3f *pTex = pFG->editMFTexCoords();
pPos->push_back(OSG::Pnt2f(0.0f, 0.0f));
pPos->push_back(OSG::Pnt2f(0.3f, 0.0f));
pPos->push_back(OSG::Pnt2f(0.3f, 0.3f));
pPos->push_back(OSG::Pnt2f(0.0f, 0.3f));
pTex->push_back(OSG::Vec3f(0.0f, 1.0f, 0.0f));
pTex->push_back(OSG::Vec3f(1.0f, 1.0f, 0.0f));
pTex->push_back(OSG::Vec3f(1.0f, 0.0f, 0.0f));
pTex->push_back(OSG::Vec3f(0.0f, 0.0f, 0.0f));
vp->addForeground(pFG);
OSG::SimpleMaterialUnrecPtr matFgCheck = OSG::SimpleMaterial::create();
matFgCheck->setDiffuse(OSG::Color3f(0,1,0));
matFgCheck->setLit (false );
OSG::PolygonForegroundUnrecPtr pFGCheck = OSG::PolygonForeground::create();
pFGCheck->setMaterial(matFgCheck);
pPos = pFGCheck->editMFPositions();
pPos->push_back(OSG::Pnt2f(0.6f, 0.0f));
pPos->push_back(OSG::Pnt2f(0.9f, 0.0f));
pPos->push_back(OSG::Pnt2f(0.9f, 0.3f));
pPos->push_back(OSG::Pnt2f(0.6f, 0.3f));
vp->addForeground(pFG);
vp->addForeground(pFGCheck);
// vp->dump();
// Background
OSG::SolidBackgroundUnrecPtr bkgndFBO = OSG::SolidBackground::create();
bkgndFBO->setColor(OSG::Color3f(1.0,0.5,0.5));
// Viewport
vpFBO = OSG::FBOViewport::create();
vpFBO->setCamera (cam );
vpFBO->setBackground(bkgndFBO );
vpFBO->setRoot (root );
vpFBO->setSize (0, 0, 1, 1);
vpFBO->addForeground(pFGCheck);
OSG::FrameBufferObjectUnrecPtr pFBO = OSG::FrameBufferObject::create();
pTexBuffer = OSG::TextureBuffer::create();
OSG::RenderBufferUnrecPtr pDepthBuffer = OSG::RenderBuffer ::create();
pDepthBuffer->setInternalFormat(GL_DEPTH_COMPONENT24 );
pTexBuffer->setTexture(tx1o);
pFBO->setSize(128, 128);
pFBO->setColorAttachment(pTexBuffer, 0);
pFBO->setDepthAttachment(pDepthBuffer );
pFBO->editMFDrawBuffers()->clear();
pFBO->editMFDrawBuffers()->push_back(GL_COLOR_ATTACHMENT0_EXT);
vpFBO->setFrameBufferObject(pFBO);
// Window
std::cout << "GLUT winid: " << winid << std::endl;
GLint glvp[4];
glGetIntegerv( GL_VIEWPORT, glvp );
gwin = OSG::GLUTWindow::create();
gwin->setGlutId(winid);
gwin->setSize( glvp[2], glvp[3] );
win = gwin;
win->addPort(vpFBO );
win->addPort(vp );
win->init();
// Action
rentravact = OSG::RenderAction::create();
// renact->setFrustumCulling(false);
// tball
OSG::Vec3f pos;
pos.setValues(min[0] + ((max[0] - min[0]) * 0.5),
min[1] + ((max[1] - min[1]) * 0.5),
max[2] + ( max[2] - min[2] ) * 1.5 );
float scale = (max[2] - min[2] + max[1] - min[1] + max[0] - min[0]) / 6;
OSG::Pnt3f tCenter(min[0] + (max[0] - min[0]) / 2,
min[1] + (max[1] - min[1]) / 2,
min[2] + (max[2] - min[2]) / 2);
fprintf(stderr, "Startpos : %f %f %f\n", pos[0], pos[1], pos[2]);
tball.setMode( OSG::Trackball::OSGObject );
tball.setStartPosition( pos, true );
tball.setSum( true );
tball.setTranslationMode( OSG::Trackball::OSGFree );
tball.setTranslationScale(scale);
tball.setRotationCenter(tCenter);
// run...
pPoly = OSG::PolygonChunk::create();
pCOver->subChunk(pPoly);
return 0;
}
int main( int argc, char *argv[] )
{
// OSG init
osg::osgLog().setLogLevel(osg::LOG_WARNING);
osg::osgInit(argc, argv);
// parse command line options
parsecommandline( argc, argv );
// disable display lists
osg::FieldContainerPtr pProto= osg::Geometry::getClassType().getPrototype();
osg::GeometryPtr pGeoProto = osg::GeometryPtr::dcast(pProto);
if ( pGeoProto != osg::NullFC )
pGeoProto->setDlistCache(false);
// create the graph
osg::NodePtr node;
// root
root = osg::Node::create();
beginEditCP(root);
root->setCore( osg::Group::create() );
// beacon for camera and light
osg::NodePtr beacon;
beacon = osg::Node::create();
beginEditCP(beacon);
beacon->setCore( osg::Group::create() );
endEditCP(beacon);
// light
light_node = osg::Node::create();
osg::DirectionalLightPtr light = osg::DirectionalLight::create();
beginEditCP( light_node );
light_node->setCore( light );
root->addChild( light_node );
beginEditCP(light);
light->setAmbient( .3, .3, .3, 1 );
light->setDiffuse( 1, 1, 1, 1 );
light->setDirection(0,0,1);
light->setBeacon( beacon );
endEditCP(light);
// transformation, parent of beacon
node = osg::Node::create();
cam_trans = osg::Transform::create();
beginEditCP(node);
node->setCore( cam_trans );
node->addChild( beacon );
endEditCP(node);
root->addChild( node );
// Camera
osg::PerspectiveCameraPtr cam = osg::PerspectiveCamera::create();
cam->setBeacon( beacon );
cam->setFov( 50 );
cam->setNear( 0.1 );
cam->setFar( 10000 );
// Background
osg::SolidBackgroundPtr background = osg::SolidBackground::create();
if ( White_background )
{
beginEditCP( background );
background->setColor(osg::Color3f(1,1,1));
endEditCP( background );
}
// Viewport
osg::ViewportPtr vp = osg::Viewport::create();
vp->setCamera( cam );
vp->setBackground( background );
vp->setRoot( root );
vp->setSize( 0,0, 1,1 );
if ( With_window )
{
// GLUT init
glutInitWindowSize( 400, 400 ); // before glutInit so user can
glutInitWindowPosition( 100, 100 ); // override with comannd line args
glutInit(&argc, argv);
glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
int winid = glutCreateWindow("Collision Benchmark");
glutKeyboardFunc(key);
glutVisibilityFunc(vis);
glutReshapeFunc(reshape);
glutDisplayFunc(display);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutIdleFunc(display);
glEnable( GL_DEPTH_TEST );
glEnable( GL_LIGHTING );
glEnable( GL_LIGHT0 );
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 1);
// Window
osg::GLUTWindowPtr gwin;
GLint glvp[4];
glGetIntegerv( GL_VIEWPORT, glvp );
gwin = osg::GLUTWindow::create();
gwin->setId(winid);
gwin->setSize( glvp[2], glvp[3] );
win = gwin;
win->addPort( vp );
// Action
render_action = osg::DrawAction::create();
// trackball
Vec3f min(-2.5,-2.5,-2.5), max(2.5,2.5,2.5);
trackball.setMode( osg::Trackball::OSGObject );
float d = max[2] + (max[2]-min[2]);
trackball.setStartPosition( 0, 0, d, true );
trackball.setSum( true );
trackball.setTranslationMode( osg::Trackball::OSGFree );
}
// create moving objects
if ( geom_type != OBJ_FILE )
createGeom( geom_type, Complexity, &fixed_node, &fixed_geom );
// else: has been loaded from file
light_node->addChild( fixed_node );
if ( geom_type != OBJ_FILE )
createGeom( geom_type, Complexity, &moving_node, &moving_geom );
//#define DOPTREE_NUM_ORI 16
double pi = 3.141592653589793f;
vector<Vec3f> translates;
vector<Vec3f> rotation_xyzs;
vector<float> rotates;
//string config("");
if(configFile.length() == 0)
{
printf("config file is null, use -r configFileName\n");
return 0;
}
ifstream fin(configFile.data());
string line;
int i = 0;
int angle;
float x,y,z;
while(std::getline(fin, line))
{
stringstream ss;
ss << line;
if(i & 0x1) // tranls
{
ss >> x >> y >> z;
translates.push_back(Vec3f(x,y,z));
}else //angle rot
{
int main( int argc, char *argv[] )
{
// parse command line options
parsecommandline( argc, argv );
// OSG init
osg::osgLog().setLogLevel(osg::LOG_WARNING);
osg::osgInit(argc, argv);
// disable display lists
osg::FieldContainerPtr pProto= osg::Geometry::getClassType().getPrototype();
osg::GeometryPtr pGeoProto = osg::GeometryPtr::dcast(pProto);
if ( pGeoProto != osg::NullFC )
pGeoProto->setDlistCache(false);
// create the graph
osg::NodePtr node;
// root
root = osg::Node::create();
beginEditCP(root);
root->setCore( osg::Group::create() );
// beacon for camera and light
osg::NodePtr beacon;
beacon = osg::Node::create();
beginEditCP(beacon);
beacon->setCore( osg::Group::create() );
endEditCP(beacon);
// light
light_node = osg::Node::create();
osg::DirectionalLightPtr light = osg::DirectionalLight::create();
beginEditCP( light_node );
light_node->setCore( light );
endEditCP( light_node );
root->addChild( light_node );
beginEditCP(light);
light->setAmbient( .3, .3, .3, 1 );
light->setDiffuse( 1, 1, 1, 1 );
light->setDirection(0,0,1);
light->setBeacon( beacon );
endEditCP(light);
// transformation, parent of beacon
node = osg::Node::create();
cam_trans = osg::Transform::create();
beginEditCP(node);
node->setCore( cam_trans );
node->addChild( beacon );
endEditCP(node);
root->addChild( node );
// finish scene graph
endEditCP(root);
// Camera
osg::PerspectiveCameraPtr cam = osg::PerspectiveCamera::create();
cam->setBeacon( beacon );
cam->setFov( 50 );
cam->setNear( 0.1 );
cam->setFar( 10000 );
// Background
osg::SolidBackgroundPtr background = osg::SolidBackground::create();
// Viewport
osg::ViewportPtr vp = osg::Viewport::create();
vp->setCamera( cam );
vp->setBackground( background );
vp->setRoot( root );
vp->setSize( 0,0, 1,1 );
if ( with_window )
{
// GLUT init
glutInitWindowSize( 400, 400 ); // before glutInit so user can
glutInitWindowPosition( 100, 100 ); // override with comannd line args
glutInit(&argc, argv);
glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
int winid = glutCreateWindow("Polygon Intersection Check Test");
glutKeyboardFunc(key);
glutVisibilityFunc(vis);
glutReshapeFunc(reshape);
glutDisplayFunc(display);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutIdleFunc(display);
glEnable( GL_DEPTH_TEST );
glEnable( GL_LIGHTING );
glEnable( GL_LIGHT0 );
// Window
osg::GLUTWindowPtr gwin;
GLint glvp[4];
glGetIntegerv( GL_VIEWPORT, glvp );
gwin = osg::GLUTWindow::create();
gwin->setId(winid);
gwin->setSize( glvp[2], glvp[3] );
win = gwin;
win->addPort( vp );
// Action
render_action = osg::DrawAction::create();
// trackball
Vec3f min(-1,-1,-1), max(1,1,1);
// root->updateVolume();
// const osg::BoxVolume &vol = dynamic_cast<const osg::BoxVolume &>(root->getVolume());
// // in the long term, the abstract volume will be able to provide min/max
// vol.getBounds( min, max );
trackball.setMode( osg::Trackball::OSGObject );
float d = max[2] + (max[2]-min[2])*1.5;
trackball.setStartPosition( 0, 0, d, true );
trackball.setSum( true );
trackball.setTranslationMode( osg::Trackball::OSGFree );
// run...
glutMainLoop();
}
else
{
// run in batch mode
int phase = 0;
do
testcase( &phase );
while ( phase > 0 );
}
return 0;
}
int doMain (int argc, char **argv)
{
int dummy;
// OSG init
OSG::osgInit(argc, argv);
// create the graph
// beacon for camera and light
OSG::NodeUnrecPtr b1n = OSG::Node::create();
OSG::GroupUnrecPtr b1 = OSG::Group::create();
b1n->setCore( b1 );
// transformation
OSG::NodeUnrecPtr t1n = OSG::Node::create();
OSG::TransformUnrecPtr t1 = OSG::Transform::create();
t1n->setCore( t1 );
t1n->addChild( b1n );
cam_trans = t1;
// light
OSG::NodeUnrecPtr dlight = OSG::Node::create();
OSG::DirectionalLightUnrecPtr dl = OSG::DirectionalLight::create();
dlight->setCore( dl );
dl->setAmbient( .3, .3, .3, 1 );
dl->setDiffuse( 1, 1, 1, 1 );
dl->setDirection(0,0,1);
dl->setBeacon( b1n);
// root
root = OSG::Node::create();
OSG::GroupUnrecPtr gr1 = OSG::Group::create();
root->setCore( gr1 );
root->addChild( t1n );
root->addChild( dlight );
// Load the file
OSG::NodeUnrecPtr file = NULL;
if ( argc > 1 )
file = OSG::SceneFileHandler::the()->read(argv[1]);
if ( file == NULL )
{
std::cerr << "Couldn't load file, ignoring" << std::endl;
file = OSG::makeTorus( .5, 2, 16, 16 );
}
OSG::Thread::getCurrentChangeList()->commitChanges();
file->updateVolume();
OSG::Vec3f min,max;
file->getVolume().getBounds( min, max );
std::cout << "Volume: from " << min << " to " << max << std::endl;
dlight->addChild( file );
std::cerr << "Tree: " << std::endl;
//root->dump();
// Camera
cam = OSG::PerspectiveCamera::create();
cam->setBeacon( b1n );
cam->setFov( OSG::osgDegree2Rad( 90 ) );
cam->setNear( 0.1 );
cam->setFar( 100000 );
// Background
OSG::SolidBackgroundUnrecPtr bkgnd = OSG::SolidBackground::create();
bkgnd->setColor(OSG::Color3f(0,0,1));
// Viewport
vp = OSG::Viewport::create();
vp->setCamera( cam );
vp->setBackground( bkgnd );
vp->setRoot( root );
vp->setSize( 0,0, 1,1 );
// Action
ract = OSG::RenderAction::create();
// tball
OSG::Vec3f pos;
pos.setValues(min[0] + ((max[0] - min[0]) * 0.5),
min[1] + ((max[1] - min[1]) * 0.5),
max[2] + ( max[2] - min[2] ) * 1.5 );
float scale = (max[2] - min[2] + max[1] - min[1] + max[0] - min[0]) / 6;
OSG::Pnt3f tCenter(min[0] + (max[0] - min[0]) / 2,
min[1] + (max[1] - min[1]) / 2,
min[2] + (max[2] - min[2]) / 2);
tball.setMode( OSG::Trackball::OSGObject );
tball.setStartPosition( pos, true );
tball.setSum( true );
tball.setTranslationMode( OSG::Trackball::OSGFree );
tball.setTranslationScale(scale);
tball.setRotationCenter(tCenter);
// CoreGL init
// Install event handler
EventHandlerUPP eventHandlerUPP = NewEventHandlerUPP(eventHandler);
EventTypeSpec eventList[] =
{
{ kEventClassTextInput, kEventTextInputUnicodeForKeyEvent },
{ kEventClassMouse, kEventMouseDown },
{ kEventClassMouse, kEventMouseUp },
{ kEventClassMouse, kEventMouseDragged }
};
InstallApplicationEventHandler(eventHandlerUPP, GetEventTypeCount(eventList), eventList, 0, 0);
CGDisplayCapture(kCGDirectMainDisplay);
CGLPixelFormatAttribute attribs[] =
{
kCGLPFADoubleBuffer,
kCGLPFAFullScreen,
kCGLPFADepthSize,
(CGLPixelFormatAttribute)16,
kCGLPFADisplayMask,
(CGLPixelFormatAttribute)CGDisplayIDToOpenGLDisplayMask(kCGDirectMainDisplay),
(CGLPixelFormatAttribute)0
};
CGLPixelFormatObj pixelFormatObj;
GLint numPixelFormats;
CGLChoosePixelFormat(attribs, &pixelFormatObj, &numPixelFormats);
CGLContextObj contextObj;
CGLCreateContext(pixelFormatObj, 0, &contextObj);
CGLDestroyPixelFormat(pixelFormatObj);
CGLSetCurrentContext(contextObj);
CGLSetFullScreen(contextObj);
// Create OpenSG window
win = OSG::CoreGLWindow::create();
win->addPort( vp );
win->setContext ( contextObj );
win->init();
win->resize( CGDisplayPixelsWide(kCGDirectMainDisplay), CGDisplayPixelsHigh(kCGDirectMainDisplay) );
win->activate();
// do some OpenGL init. Will move into State Chunks later.
glEnable( GL_DEPTH_TEST );
glEnable( GL_LIGHTING );
glEnable( GL_LIGHT0 );
redraw();
// Main loop ( event dispatching )
RunApplicationEventLoop();
// Cleanup
CGLSetCurrentContext(0);
CGLClearDrawable(contextObj);
CGLDestroyContext(contextObj);
CGReleaseAllDisplays();
DisposeEventHandlerUPP(eventHandlerUPP);
ract = NULL;
win = NULL;
root = NULL;
file = NULL;
vp = NULL;
cam_trans = NULL;
cam = NULL;
return 0;
}
void key(unsigned char key, int x, int y)
{
switch ( key )
{
case 27:
fprintf(stderr, "Start Destruction\n\n");
rentravact = NULL;
hdrroot = NULL;
root = NULL;
// file = NULL;
cam = NULL;
vp = NULL;
win = NULL;
cam_trans = NULL;
scene_trans = NULL;
pAnimTrs[0] = NULL;
pAnimTrs[1] = NULL;
pAnimTrs[2] = NULL;
pAnimTrs[3] = NULL;
pAnimTrs[4] = NULL;
pAnimTrs[5] = NULL;
OSG::osgExit();
exit(0);
case 'a':
glDisable( GL_LIGHTING );
std::cerr << "Lighting disabled." << std::endl;
break;
case 's':
glEnable( GL_LIGHTING );
std::cerr << "Lighting enabled." << std::endl;
break;
case 'r':
{
std::cerr << "Sending ray through " << x << "," << y << std::endl;
OSG::Line l;
cam->calcViewRay( l, x, y, *vp );
std::cerr << "From " << l.getPosition() << ", dir "
<< l.getDirection()
<< std::endl;
}
break;
case 'g':
hdrroot->setCore(OSG::Group::create());
break;
case 'h':
createHDRCore(hdrroot);
break;
case 'd':
OSG::ActionDataSlotPool::the()->dumpState();
OSG::StageIdPool ::the()->dumpState();
rentravact->dumpStore();
break;
case ' ':
{
OSG::Matrix m;
OSG::Quaternion q;
OSG::Vec3f v;
q = oldq;
v = oldv;
oldq = tball.getRotation();
oldv = tball.getPosition();
move_obj = ! move_obj;
if ( move_obj )
{
puts("moving object");
tball.setMode( OSG::Trackball::OSGCamera );
}
else
{
puts("moving camera");
tball.setMode( OSG::Trackball::OSGObject );
}
tball.setStartPosition( v, true );
tball.setStartRotation( q, true );
}
break;
case '1':
{
OSG::HDR2Stage* pHDR = dynamic_cast<OSG::HDR2Stage*>(hdrroot->getCore());
if (pHDR) pHDR->setTarget(OSG::HDR2Stage::SCENE_TEXTURE);
}
break;
case '2':
{
OSG::HDR2Stage* pHDR = dynamic_cast<OSG::HDR2Stage*>(hdrroot->getCore());
if (pHDR) pHDR->setTarget(OSG::HDR2Stage::LUMINANCE_TEXTURE);
}
break;
case '3':
{
OSG::HDR2Stage* pHDR = dynamic_cast<OSG::HDR2Stage*>(hdrroot->getCore());
if (pHDR) pHDR->setTarget(OSG::HDR2Stage::ADAPTED_LUMINANCE_TEXTURE);
}
break;
case '4':
{
OSG::HDR2Stage* pHDR = dynamic_cast<OSG::HDR2Stage*>(hdrroot->getCore());
if (pHDR) pHDR->setTarget(OSG::HDR2Stage::THRESHOLD_TEXTURE);
}
break;
case '5':
{
OSG::HDR2Stage* pHDR = dynamic_cast<OSG::HDR2Stage*>(hdrroot->getCore());
if (pHDR) pHDR->setTarget(OSG::HDR2Stage::BLURRED_TEXTURE);
}
break;
case '6':
{
OSG::HDR2Stage* pHDR = dynamic_cast<OSG::HDR2Stage*>(hdrroot->getCore());
if (pHDR) pHDR->setTarget(OSG::HDR2Stage::COMPOSITE_TEXTURE);
}
break;
case '7':
{
OSG::HDR2Stage* pHDR = dynamic_cast<OSG::HDR2Stage*>(hdrroot->getCore());
if (pHDR) pHDR->setTarget(OSG::HDR2Stage::EXPOSURE_TEXTURE);
}
break;
}
}
static OSStatus handleMouseEvent(EventHandlerCallRef nextHandler, EventRef event, void *userData)
{
OSStatus err;
OSG::Real32 w,h,a,b,c,d;
// Get the pressed mouse button
EventMouseButton mouseButton;
err = GetEventParameter(event, kEventParamMouseButton, typeMouseButton, 0, sizeof(mouseButton), 0, &mouseButton);
if (err != noErr)
return err;
// Get the modifier keys
::UInt32 modifierKeys;
err = GetEventParameter(event, kEventParamKeyModifiers, typeUInt32, 0, sizeof(modifierKeys), 0, &modifierKeys);
if (err != noErr)
return err;
// Traditionally, Apple mice just have one button. It is common practice to simulate
// the middle and the right button by pressing the option or the control key.
if (mouseButton == kEventMouseButtonPrimary)
{
if (modifierKeys & optionKey)
mouseButton = kEventMouseButtonTertiary;
if (modifierKeys & controlKey)
mouseButton = kEventMouseButtonSecondary;
}
// Get the location of the mouse pointer
::Point location;
err = GetEventParameter(event, kEventParamMouseLocation, typeQDPoint, 0, sizeof(location), 0, &location);
if (err != noErr)
return err;
// Handle the different kinds of events
::UInt32 eventKind = GetEventKind(event);
switch (eventKind)
{
// mouse button pressed
case kEventMouseDown:
lastx = location.h;
lasty = location.v;
switch (mouseButton)
{
case kEventMouseButtonPrimary: // left button
break;
case kEventMouseButtonSecondary: // right button
tball.setAutoPositionNeg(true);
break;
case kEventMouseButtonTertiary: // middle button
tball.setAutoPosition(true);
break;
}
break;
// mouse button released
case kEventMouseUp:
switch (mouseButton)
{
case kEventMouseButtonPrimary: // left button
break;
case kEventMouseButtonSecondary: // right button
tball.setAutoPositionNeg(false);
break;
case kEventMouseButtonTertiary: // middle button
tball.setAutoPosition(false);
break;
}
break;
// mouse moved while a button is pressed
case kEventMouseDragged:
w = win->getWidth();
h = win->getHeight();
a = -2. * ( lastx / w - .5 );
b = -2. * ( .5 - lasty / h );
c = -2. * ( location.h / w - .5 );
d = -2. * ( .5 - location.v / h );
switch (mouseButton)
{
case kEventMouseButtonPrimary: // left button
tball.updateRotation( a, b, c, d );
break;
case kEventMouseButtonSecondary: // right button
tball.updatePositionNeg( a, b, c, d );
break;
case kEventMouseButtonTertiary: // middle button
tball.updatePosition( a, b, c, d );
break;
}
lastx = location.h;
lasty = location.v;
// Redraw the whole window
redraw();
break;
}
// We have to return eventNotHandledErr, otherwise the system is
// not able to operate the menu and the window border
return eventNotHandledErr;
}
void key(unsigned char key, int x, int y)
{
switch ( key )
{
case 27:
fprintf(stderr, "Start Destruction\n\n");
rentravact = NULL;
hdrroot = NULL;
root = NULL;
file = NULL;
cam = NULL;
vp = NULL;
win = NULL;
cam_trans = NULL;
scene_trans = NULL;
pAnimTrs[0] = NULL;
pAnimTrs[1] = NULL;
pAnimTrs[2] = NULL;
pAnimTrs[3] = NULL;
pAnimTrs[4] = NULL;
pAnimTrs[5] = NULL;
OSG::osgExit();
exit(0);
case 'a':
glDisable( GL_LIGHTING );
std::cerr << "Lighting disabled." << std::endl;
break;
case 's':
glEnable( GL_LIGHTING );
std::cerr << "Lighting enabled." << std::endl;
break;
case 'r':
{
std::cerr << "Sending ray through " << x << "," << y << std::endl;
OSG::Line l;
cam->calcViewRay( l, x, y, *vp );
std::cerr << "From " << l.getPosition() << ", dir "
<< l.getDirection()
<< std::endl;
}
break;
case 'd':
OSG::ActionDataSlotPool::the()->dumpState();
OSG::StageIdPool ::the()->dumpState();
rentravact->dumpStore();
break;
case ' ':
{
OSG::Matrix m;
OSG::Quaternion q;
OSG::Vec3f v;
q = oldq;
v = oldv;
oldq = tball.getRotation();
oldv = tball.getPosition();
move_obj = ! move_obj;
if ( move_obj )
{
puts("moving object");
tball.setMode( OSG::Trackball::OSGCamera );
}
else
{
puts("moving camera");
tball.setMode( OSG::Trackball::OSGObject );
}
tball.setStartPosition( v, true );
tball.setStartRotation( q, true );
}
break;
}
}
void key(unsigned char key, int x, int y)
{
switch ( key )
{
case 27:
root = NULL;
file = NULL;
cam = NULL;
vp = NULL;
win = NULL;
cam_trans = NULL;
scene_trans = NULL;
pPoly = NULL;
pCOver = NULL;
gwin = NULL;
tx1o = NULL;
tx1e = NULL;
vpFBO = NULL;
vpFBO_RB = NULL;
pTexBuffer = NULL;
pRenBuffer = NULL;
pImg = NULL;
delete rentravact;
OSG::osgExit();
exit(0);
case 'f':
vpFBO->setTravMask(~vpFBO->getTravMask());
break;
case 'd':
oldTravMask = vpFBO->getTravMask();
if(oldTravMask == 0x0000)
{
vpFBO->setTravMask(~vpFBO->getTravMask());
}
dumpImg = true;
pTexBuffer ->setReadBack (true);
vpFBO->getFrameBufferObject()->setPostProcessOnDeactivate(true);
break;
case 'r':
{
// OSG::FieldContainerFactory::the()->dump();
//RenderBuffer Readback
// Background
OSG::SolidBackgroundUnrecPtr bkgndFBO_RB =
OSG::SolidBackground::create();
bkgndFBO_RB->setColor(OSG::Color3f(0.5,1.0,0.5));
// Viewport
vpFBO_RB = OSG::FBOViewport::create();
vpFBO_RB->setCamera (cam );
vpFBO_RB->setBackground(bkgndFBO_RB);
vpFBO_RB->setRoot (root );
vpFBO_RB->setSize (0, 0, 1, 1 );
OSG::FrameBufferObjectUnrecPtr pFBO_RB =
OSG::FrameBufferObject::create();
pRenBuffer = OSG::RenderBuffer::create();
OSG::RenderBufferUnrecPtr pDepthBuffer_RB =
OSG::RenderBuffer::create();
pDepthBuffer_RB->setInternalFormat(GL_DEPTH_COMPONENT24 );
pRenBuffer->setInternalFormat(GL_RGBA);
OSG::ImageUnrecPtr pImg_RB = OSG::Image::create();
OSG::UInt32 uiImgSize = 4096;
pImg_RB->set(OSG::Image::OSG_RGB_PF, uiImgSize, uiImgSize);
fprintf(stderr, "Image data : %p\n", pImg_RB->getData());
pRenBuffer->setImage(pImg_RB);
pFBO_RB->setSize(uiImgSize, uiImgSize);
pFBO_RB->setColorAttachment(pRenBuffer, 0);
pFBO_RB->setDepthAttachment(pDepthBuffer_RB );
pFBO_RB->editMFDrawBuffers()->clear();
pFBO_RB->editMFDrawBuffers()->push_back(GL_COLOR_ATTACHMENT0_EXT);
vpFBO_RB->setFrameBufferObject(pFBO_RB);
pRenBuffer ->setReadBack (true);
vpFBO_RB->getFrameBufferObject()->setPostProcessOnDeactivate(true);
win->addPort(vpFBO_RB);
dumpImg_RB = true;
}
break;
case 'v':
rentravact->setVolumeDrawing(!rentravact->getVolumeDrawing());
break;
case 'a':
glDisable( GL_LIGHTING );
std::cerr << "Lighting disabled." << std::endl;
break;
case 's':
glEnable( GL_LIGHTING );
std::cerr << "Lighting enabled." << std::endl;
break;
case 'z':
pPoly->setFrontMode(GL_POINT);
pPoly->setBackMode(GL_POINT);
std::cerr << "PolygonMode: Point." << std::endl;
break;
case 'x':
pPoly->setFrontMode(GL_LINE);
pPoly->setBackMode(GL_LINE);
std::cerr << "PolygonMode: Line." << std::endl;
break;
case 'c':
pPoly->setFrontMode(GL_FILL);
pPoly->setBackMode(GL_FILL);
std::cerr << "PolygonMode: Fill." << std::endl;
break;
case 'p':
{
if(bPolyActive == true)
{
OSG_ASSERT(pCOver->subChunk(pPoly) == true);
bPolyActive = false;
}
else
{
OSG_ASSERT(pCOver->addChunk(pPoly) == true);
bPolyActive = true;
}
break;
}
case ' ':
{
OSG::Matrix m;
OSG::Quaternion q;
OSG::Vec3f v;
q = oldq;
v = oldv;
oldq = tball.getRotation();
oldv = tball.getPosition();
move_obj = ! move_obj;
if ( move_obj )
{
puts("moving object");
// m = scene_trans->getSFMatrix()->getValue();
tball.setMode( OSG::Trackball::OSGCamera );
}
else
{
puts("moving camera");
// m = cam_trans->getSFMatrix()->getValue();
tball.setMode( OSG::Trackball::OSGObject );
}
// q.setValue(m);
tball.setStartPosition( v, true );
tball.setStartRotation( q, true );
// std::cout << q << std::endl;
// std::cout << v << std::endl;
// std::cout << " " << m[3][0] << " " << m[3][1] << " " << m[3][2] << std::endl;
}
break;
}
}
int doMain (int argc, char **argv)
{
OSG::osgInit(argc,argv);
// GLUT init
glutInit(&argc, argv);
glutInitDisplayMode( GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE);
glutInitWindowSize(800, 800);
int winid = glutCreateWindow("OpenSG");
glutKeyboardFunc(key);
glutVisibilityFunc(vis);
glutReshapeFunc(reshape);
glutDisplayFunc(display);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutIdleFunc(display);
// OSG
OSG::SceneFileHandler::the()->print();
// create the graph
// beacon for camera and light
OSG::NodeUnrecPtr b1n = OSG::Node::create();
OSG::GroupUnrecPtr b1 = OSG::Group::create();
fprintf(stderr, "Create b1n %p %d %d \n",
b1n.get(),
b1n->getRefCount(),
b1n->getWeakRefCount());
b1n->setCore( b1 );
// transformation
OSG::NodeUnrecPtr t1n = OSG::Node::create();
OSG::TransformUnrecPtr t1 = OSG::Transform::create();
t1n->setCore (t1 );
t1n->addChild(b1n);
fprintf(stderr, "Create t1n %p %d %d \n",
t1n.get(),
t1n->getRefCount(),
t1n->getWeakRefCount());
cam_trans = t1;
// light
OSG::NodeUnrecPtr dlight = OSG::Node::create();
OSG::DirectionalLightUnrecPtr dl = OSG::DirectionalLight::create();
{
dlight->setCore(dl);
dl->setAmbient( .3f, .3f, .3f, 1 );
dl->setDiffuse( .8f, .8f, .8f, .8f );
dl->setDirection(0,0,1);
dl->setBeacon( b1n);
}
fprintf(stderr, "Create dlight %p %d %d \n",
dlight.get(),
dlight->getRefCount(),
dlight->getWeakRefCount());
hdrroot = OSG::Node::create();
hdrroot->editVolume().setInfinite();
hdrroot->editVolume().setStatic ();
hdrroot->setCore(OSG::Group::create());
// root
root = OSG::Node:: create();
OSG::GroupUnrecPtr gr1 = OSG::Group::create();
root->setCore(gr1);
hdrroot->addChild(root);
root->addChild(t1n );
root->addChild(dlight);
fprintf(stderr, "Create root %p %d %d \n",
root.get(),
root->getRefCount(),
root->getWeakRefCount());
// Load the file
OSG::NodeUnrecPtr file = NULL;
if(argc > 1)
{
file = OSG::SceneFileHandler::the()->read(argv[1], NULL);
}
if(file == NULL)
{
std::cerr << "Couldn't load file, ignoring" << std::endl;
// file = makeBox(2.f, 2.f, 2.f, 2, 2, 2);
file = OSG::makeSphere(4, 2.0);
}
OSG::NodeUnrecPtr pCubeRoot = OSG::Node::create();
OSG::CubeMapGeneratorUnrecPtr pCubeGen = OSG::CubeMapGenerator::create();
pCubeRoot->addChild(file);
pCubeRoot->setCore(pCubeGen);
// pCubeRoot->setCore(Group::create());
OSG::NodeUnrecPtr pCubeSceneRoot = OSG::Node::create();
OSG::VisitSubTreeUnrecPtr pCubeVisit = OSG::VisitSubTree::create();
pCubeSceneRoot->setCore(pCubeVisit);
pCubeVisit->setSubTreeRoot(root);
pCubeGen->setRoot (pCubeSceneRoot);
pCubeGen->setTextureFormat(GL_RGB32F_ARB );
pCubeGen->setSize (512,
512 );
pCubeGen->setTexUnit (3);
// Cubemap Background
OSG::SolidBackgroundUnrecPtr cubeBkgnd = OSG::SolidBackground::create();
{
cubeBkgnd->setColor(OSG::Color3f(0.5f, 0.3f, 0.3f));
}
pCubeGen->setBackground(cubeBkgnd);
OSG::NodeUnrecPtr pAnimRoot = setupAnim();
scene_trans = OSG::Transform::create();
OSG::NodeUnrecPtr sceneTrN = OSG::Node::create();
scene_trans->editMatrix()[3][2] = -50.f;
sceneTrN->setCore (scene_trans);
sceneTrN->addChild(pCubeRoot );
sceneTrN->addChild(pAnimRoot );
OSG::Thread::getCurrentChangeList()->commitChanges();
OSG::Vec3f min,max;
sceneTrN->updateVolume();
sceneTrN->getVolume().getBounds(min, max);
std::cout << "Volume: from " << min << " to " << max << std::endl;
dlight->addChild(sceneTrN);
// Camera
cam = OSG::PerspectiveCamera::create();
{
cam->setBeacon( b1n );
cam->setFov( OSG::osgDegree2Rad( 90 ) );
cam->setNear( 0.1f );
cam->setFar( 100000 );
}
// Background
OSG::SolidBackgroundUnrecPtr bkgnd = OSG::SolidBackground::create();
{
bkgnd->setColor(OSG::Color3f(0.3f, 0.3f, 0.3f));
}
// Viewport
vp = OSG::Viewport::create();
{
vp->setCamera( cam );
vp->setBackground( bkgnd );
vp->setRoot( hdrroot );
// vp->setRoot( root );
vp->setSize( 0,0, 1,1 );
}
// Window
OSG::GLUTWindowUnrecPtr gwin;
GLint glvp[4];
glGetIntegerv(GL_VIEWPORT, glvp);
gwin = OSG::GLUTWindow::create();
{
gwin->setGlutId(winid);
gwin->setSize( glvp[2], glvp[3] );
win = gwin;
win->addPort( vp );
win->init();
}
// Action
rentravact = OSG::RenderAction::create();
rentravact->setVolumeDrawing(true);
// rentravact->setFrustumCulling(false);
// tball
OSG::Vec3f pos;
pos.setValues(min[0] + ((max[0] - min[0]) * 0.5),
min[1] + ((max[1] - min[1]) * 0.5),
max[2] + ( max[2] - min[2] ) * 1.5 );
float scale = (max[2] - min[2] + max[1] - min[1] + max[0] - min[0]) / 6;
OSG::Pnt3f tCenter(min[0] + (max[0] - min[0]) / 2,
min[1] + (max[1] - min[1]) / 2,
min[2] + (max[2] - min[2]) / 2);
fprintf(stderr, "Startpos : %f %f %f\n", pos[0], pos[1], pos[2]);
tball.setMode (OSG::Trackball::OSGObject);
tball.setStartPosition (pos, true );
tball.setSum (true );
tball.setTranslationMode (OSG::Trackball::OSGFree );
tball.setTranslationScale(scale );
tball.setRotationCenter (tCenter );
fprintf(stderr, "Create b1n %p %d %d \n",
b1n.get(),
b1n->getRefCount(),
b1n->getWeakRefCount());
fprintf(stderr, "Create t1n %p %d %d \n",
t1n.get(),
t1n->getRefCount(),
t1n->getWeakRefCount());
fprintf(stderr, "Create dlight %p %d %d \n",
dlight.get(),
dlight->getRefCount(),
dlight->getWeakRefCount());
fprintf(stderr, "Create hdrroot %p %d %d \n",
hdrroot.get(),
hdrroot->getRefCount(),
hdrroot->getWeakRefCount());
fprintf(stderr, "Create root %p %d %d \n",
root.get(),
root->getRefCount(),
root->getWeakRefCount());
return 0;
}
void display(void)
{
OSG::Matrix m1, m2, m3;
OSG::Quaternion q1;
tball.getRotation().getValue(m3);
q1.setValue(m3);
m1.setRotate(q1);
// std::cout << "TBROT" << std::endl << tball.getRotation() << endl;
// std::cout << "M3" << std::endl << m3 << std::endl;
// std::cout << "Q1" << std::endl << q1 << std::endl;
// std::cout << "M1" << std::endl << m1 << std::endl;
// m1.setRotate( tball.getRotation() );
m2.setTranslate( tball.getPosition() );
//std::cout << "Pos: " << tball.getPosition() << ", Rot: " << tball.getRotation() << std::endl;
// std::cout << tball.getRotation() << std::endl;
m1.mult( m2 );
// std::cerr << m1 << std::endl;
m1 = tball.getFullTrackballMatrix();
if(move_obj == true)
{
scene_trans->editSFMatrix()->setValue( m1 );
}
else
{
cam_trans->editSFMatrix()->setValue( m1 );
}
OSG::commitChangesAndClear();
win->render(rentravact);
if(dumpImg == true)
{
vpFBO->setTravMask(oldTravMask);
pTexBuffer ->setReadBack (false);
vpFBO->getFrameBufferObject()->setPostProcessOnDeactivate(false);
pImg->write("/tmp/test.png");
dumpImg = false;
}
if(dumpImg_RB == true)
{
pRenBuffer->getImage()->write("/tmp/test1.png");
dumpImg_RB = false;
win->subPortByObj(vpFBO_RB);
vpFBO_RB = NULL;
pRenBuffer = NULL;
win->runFrameExit();
// OSG::FieldContainerFactory::the()->dump();
}
// win->render(renact);
// std::cerr << "------------- AR START --------------" << std::endl;
// Thread::getCurrentChangeList()->dump();
}
int doMain (int argc, char **argv)
{
osx_AllowForeground();
// OSG init
OSG::osgInit(argc, argv);
// create the graph
// beacon for camera and light
OSG::NodeUnrecPtr b1n = OSG::Node::create();
OSG::GroupUnrecPtr b1 = OSG::Group::create();
b1n->setCore( b1 );
// transformation
OSG::NodeUnrecPtr t1n = OSG::Node::create();
OSG::TransformUnrecPtr t1 = OSG::Transform::create();
t1n->setCore( t1 );
t1n->addChild( b1n );
cam_trans = t1;
// light
OSG::NodeUnrecPtr dlight = OSG::Node::create();
OSG::DirectionalLightUnrecPtr dl = OSG::DirectionalLight::create();
dlight->setCore( dl );
dl->setAmbient( .0, .0, .0, 1 );
dl->setDiffuse( .8, .8, .8, .8 );
dl->setDirection(0,0,1);
dl->setBeacon( b1n);
// root
root = OSG::Node::create();
OSG::GroupUnrecPtr gr1 = OSG::Group::create();
root->setCore( gr1 );
root->addChild( t1n );
root->addChild( dlight );
// Load the file
OSG::NodeUnrecPtr file = NULL;
if ( argc > 1 )
file = OSG::SceneFileHandler::the()->read(argv[1]);
if ( file == NULL )
{
std::cerr << "Couldn't load file, ignoring" << std::endl;
file = OSG::makeTorus( .5, 2, 16, 16 );
}
OSG::Thread::getCurrentChangeList()->commitChanges();
file->updateVolume();
OSG::Vec3f min,max;
file->getVolume().getBounds( min, max );
std::cout << "Volume: from " << min << " to " << max << std::endl;
dlight->addChild( file );
std::cerr << "Tree: " << std::endl;
//root->dump();
// Camera
cam = OSG::PerspectiveCamera::create();
cam->setBeacon( b1n );
cam->setFov( OSG::osgDegree2Rad( 90 ) );
cam->setNear( 0.1 );
cam->setFar( 100000 );
// Background
OSG::SolidBackgroundUnrecPtr bkgnd = OSG::SolidBackground::create();
bkgnd->setColor(OSG::Color3f(0,0,1));
// Viewport
vp = OSG::Viewport::create();
vp->setCamera( cam );
vp->setBackground( bkgnd );
vp->setRoot( root );
vp->setSize( 0,0, 1,1 );
// Action
ract = OSG::RenderAction::create();
// tball
OSG::Vec3f pos;
pos.setValues(min[0] + ((max[0] - min[0]) * 0.5),
min[1] + ((max[1] - min[1]) * 0.5),
max[2] + ( max[2] - min[2] ) * 1.5 );
float scale = (max[2] - min[2] + max[1] - min[1] + max[0] - min[0]) / 6;
OSG::Pnt3f tCenter(min[0] + (max[0] - min[0]) / 2,
min[1] + (max[1] - min[1]) / 2,
min[2] + (max[2] - min[2]) / 2);
tball.setMode( OSG::Trackball::OSGObject );
tball.setStartPosition( pos, true );
tball.setSum( true );
tball.setTranslationMode( OSG::Trackball::OSGFree );
tball.setTranslationScale(scale);
tball.setRotationCenter(tCenter);
// Carbon init
// Create window
WindowAttributes windowAttrs =
kWindowStandardDocumentAttributes |
kWindowLiveResizeAttribute |
kWindowStandardHandlerAttribute;
Rect contentRect;
SetRect(&contentRect, 0, 0, 300, 300);
WindowRef window;
CreateNewWindow(kDocumentWindowClass, windowAttrs, &contentRect, &window);
SetWindowTitleWithCFString(window, CFSTR("testWindowCarbon"));
// Install event handler
EventHandlerUPP eventHandlerUPP = NewEventHandlerUPP(eventHandler);
EventTypeSpec eventList[] =
{
{ kEventClassTextInput, kEventTextInputUnicodeForKeyEvent },
{ kEventClassMouse, kEventMouseDown },
{ kEventClassMouse, kEventMouseUp },
{ kEventClassMouse, kEventMouseDragged },
{ kEventClassWindow, kEventWindowClose },
{ kEventClassWindow, kEventWindowDrawContent },
{ kEventClassWindow, kEventWindowBoundsChanged }
};
InstallWindowEventHandler(window, eventHandlerUPP, GetEventTypeCount(eventList), eventList, /*this*/0, 0);
// Initialize OpenGL
GLint attribs[] = { AGL_RGBA, AGL_DOUBLEBUFFER, AGL_DEPTH_SIZE, 16, AGL_NONE };
AGLPixelFormat pixelFormat = aglChoosePixelFormat(0, 0, attribs);
if (pixelFormat == 0)
std::cerr << "Cannot choose pixel format" << std::endl;
AGLContext context = aglCreateContext(pixelFormat, 0);
aglDestroyPixelFormat(pixelFormat);
if (context == 0)
std::cerr << "Cannot create context" << std::endl;
aglSetDrawable(context, GetWindowPort(window));
// Create OpenSG window
win = OSG::CarbonWindow::create();
win->addPort( vp );
win->setContext ( context );
win->init();
win->resize( 300, 300 );
// Show window
RepositionWindow(window, 0, kWindowCascadeOnMainScreen);
ShowWindow(window);
win->activate();
// do some OpenGL init. Will move into State Chunks later.
glEnable( GL_DEPTH_TEST );
glEnable( GL_LIGHTING );
glEnable( GL_LIGHT0 );
// Main loop ( event dispatching )
RunApplicationEventLoop();
// Cleanup
aglDestroyContext(context);
DisposeWindow(window);
DisposeEventHandlerUPP(eventHandlerUPP);
ract = NULL;
win = NULL;
root = NULL;
file = NULL;
vp = NULL;
cam_trans = NULL;
cam = NULL;
return 0;
}
