int main(int argc, char** argv)
{
std::cout << "osgInit()..." << std::endl;
osgInit( argc, argv );
std::cout << "glutInit()..." << std::endl;
glutInit( &argc, argv );
glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE );
int winID = glutCreateWindow("OpenSG");
glutKeyboardFunc(key);
glutVisibilityFunc(vis);
glutReshapeFunc(resize);
glutDisplayFunc(display);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutIdleFunc(display);
glEnable( GL_DEPTH_TEST );
glEnable( GL_LIGHTING );
glEnable( GL_LIGHT0 );
glClearColor( .3, .3, .8, 1 );
std::cout << "Creating objects..." << std::endl;
//BEACON
NodePtr beaconNode = Node::create();
GroupPtr beaconCore = Group::create();
beginEditCP( beaconNode );
beaconNode->setCore( beaconCore );
endEditCP( beaconNode );
/*
//LIGHT
NodePtr dlightNode = Node::create();
DirectionalLightPtr dlightCore = DirectionalLight::create();
beginEditCP(dlightNode);
dlightNode->setCore(dlightCore);
endEditCP(dlightNode);
beginEditCP(dlightCore);
dlightCore->setAmbient( .3, .3, .3, 1 );
dlightCore->setDiffuse( .5, .5, .5, 1 );
dlightCore->setDirection( 0, 0 , 1 );
dlightCore->setBeacon( beaconNode );
endEditCP(dlightCore);
*/
//TRANSFORM
NodePtr transNode = Node::create();
TransformPtr transCore = Transform::create();
beginEditCP( transNode );
transNode->setCore( transCore );
transNode->addChild( beaconNode );
endEditCP( transNode );
cam_trans = transCore;
//LOD
NodePtr lowDetailNode = makeBox( 1,1,1, 1,1,1 );
GeometryPtr boxCore = GeometryPtr::dcast(lowDetailNode->getCore());
SimpleMaterialPtr lowDetailMat = SimpleMaterial::create();
lowDetailMat->setDiffuse( Color3f( 1,0,0 ) );
lowDetailMat->setAmbient( Color3f( 1,0,0 ) );
boxCore->setMaterial( lowDetailMat );
NodePtr medDetailNode = makeSphere( 1, 1 );
GeometryPtr medSphereCore = GeometryPtr::dcast(medDetailNode->getCore());
SimpleMaterialPtr medDetailMat = SimpleMaterial::create();
medDetailMat->setDiffuse( Color3f( 0,1,0 ) );
medDetailMat->setAmbient( Color3f( 0,1,0 ) );
medSphereCore->setMaterial( medDetailMat );
NodePtr highDetailNode = makeSphere( 2, 1 );
GeometryPtr highSphereCore = GeometryPtr::dcast(highDetailNode->getCore());
SimpleMaterialPtr highDetailMat = SimpleMaterial::create();
highDetailMat->setDiffuse( Color3f( 0,0,1 ) );
highDetailMat->setAmbient( Color3f( 0,0,1 ) );
highDetailMat->setSpecular( Color3f(1, 1, 1) );
highDetailMat->setShininess( 10 );
highSphereCore->setMaterial( highDetailMat );
NodePtr lodNode = Node::create();
DistanceLODPtr lodNodeCore = DistanceLOD::create();
beginEditCP(lodNode);
lodNode->setCore(lodNodeCore);
lodNode->addChild( highDetailNode );
lodNode->addChild( medDetailNode );
lodNode->addChild( lowDetailNode );
endEditCP(lodNode);
beginEditCP(lodNodeCore);
lodNodeCore->editSFCenter()->setValue( Pnt3f(0, 0, 2) );
lodNodeCore->editMFRange()->push_back( 4.0 );
lodNodeCore->editMFRange()->push_back( 8.0 );
lodNodeCore->editMFRange()->push_back( 11.0 );
endEditCP(lodNodeCore);
//TRANSFORM LOD
NodePtr transLODNode = Node::create();
TransformPtr transLODCore = Transform::create();
transMat.setTranslate( 1, -1, -1 );
beginEditCP(transLODCore);
transLODCore->editSFMatrix()->setValue( transMat );
endEditCP(transLODCore);
beginEditCP( transLODNode );
transLODNode->setCore( transLODCore );
transLODNode->addChild( lodNode );
endEditCP( transLODNode );
//ROOT
root = Node::create();
GroupPtr rootCore = Group::create();
beginEditCP(root);
root->setCore(rootCore);
root->addChild(transNode);
root->addChild(transLODNode);
endEditCP(root);
camera = PerspectiveCamera::create();
beginEditCP(camera);
camera->setBeacon( beaconNode );
camera->setFov( deg2rad(90) );
camera->setNear( 0.1 );
camera->setFar( 10000 );
endEditCP(camera);
SolidBackgroundPtr background = SolidBackground::create();
viewp = Viewport::create();
beginEditCP(viewp);
viewp->setCamera( camera );
viewp->setBackground( background );
viewp->setRoot( root );
viewp->setSize( 0,0, 1,1 );
endEditCP(viewp);
GLint glVP[4];
glGetIntegerv( GL_VIEWPORT, glVP );
GLUTWindowPtr gwin = GLUTWindow::create();
gwin->setId(winID);
gwin->setSize(glVP[2], glVP[3]);
window = gwin;
beginEditCP(window);
window->addPort( viewp );
window->init();
endEditCP(window);
drAct = DrawAction::create();
Vec3f pos( 0, 0, 3 );
tball.setMode( Trackball::OSGObject );
tball.setStartPosition( pos, true );
tball.setSum( true );
tball.setTranslationMode( Trackball::OSGFree );
glutMainLoop();
return 0;
}
int main (int argc, char **argv)
{
osgInit(argc,argv);
// GLUT init
glutInit(&argc, argv);
glutInitDisplayMode( GLUT_RGB | 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 );
// OSG
SceneFileHandler::the().print();
// create the graph
// beacon for camera and light
NodePtr b1n = Node::create();
GroupPtr b1 = Group::create();
beginEditCP(b1n);
b1n->setCore( b1 );
endEditCP(b1n);
// transformation
NodePtr t1n = Node::create();
TransformPtr t1 = Transform::create();
beginEditCP(t1n);
t1n->setCore( t1 );
t1n->addChild( b1n );
endEditCP(t1n);
cam_trans = t1;
// light
NodePtr dlight = Node::create();
DirectionalLightPtr dl = DirectionalLight::create();
beginEditCP(dlight);
dlight->setCore( dl );
endEditCP(dlight);
beginEditCP(dl);
dl->setAmbient( .3, .3, .3, 1 );
dl->setDiffuse( 1, 1, 1, 1 );
dl->setDirection(0,0,1);
dl->setBeacon( b1n);
endEditCP(dl);
// root
root = Node::create();
GroupPtr gr1 = Group::create();
beginEditCP(root);
root->setCore( gr1 );
root->addChild( t1n );
root->addChild( dlight );
endEditCP(root);
// Load the file
NodePtr file = NullFC;
if ( argc > 1 )
file = SceneFileHandler::the().read(argv[1]);
if ( file == NullFC )
{
std::cerr << "Couldn't load file, ignoring" << std::endl;
file = makeTorus( .5, 2, 16, 16 );
}
file->updateVolume();
Vec3f min,max;
file->getVolume().getBounds( min, max );
std::cout << "Volume: from " << min << " to " << max << std::endl;
beginEditCP(dlight);
dlight->addChild( file );
endEditCP(dlight);
std::cerr << "Tree: " << std::endl;
// root->dump();
// Camera
cam = PerspectiveCamera::create();
cam->setBeacon( b1n );
cam->setFov( deg2rad( 90 ) );
cam->setNear( 0.1 );
cam->setFar( 10000 );
// Background
SolidBackgroundPtr bkgnd = SolidBackground::create();
// Foreground
GrabForegroundPtr fgnd = GrabForeground::create();
image = Image::create();
beginEditCP(image);
image->set(Image::OSG_RGB_PF, 1);
endEditCP(image);
fgnd->setImage(image);
// Viewport
vp = Viewport::create();
vp->setCamera( cam );
vp->setBackground( bkgnd );
vp->editMFForegrounds()->push_back( fgnd );
vp->setRoot( root );
vp->setSize( 0,0, 1,1 );
// Window
std::cout << "GLUT winid: " << winid << std::endl;
GLUTWindowPtr gwin;
GLint glvp[4];
glGetIntegerv( GL_VIEWPORT, glvp );
gwin = GLUTWindow::create();
gwin->setId(winid);
gwin->setSize( glvp[2], glvp[3] );
win = gwin;
win->addPort( vp );
win->init();
// Action
ract = DrawAction::create();
// tball
Vec3f pos( 0, 0, max[2] + ( max[2] - min[2] ) * 1.5 );
tball.setMode( Trackball::OSGObject );
tball.setStartPosition( pos, true );
tball.setSum( true );
tball.setTranslationMode( Trackball::OSGFree );
// run...
glutMainLoop();
return 0;
}
virtual void initialize(void)
{
// Check necessary stuff
if(_win == NullFC)
{
FWARNING(("SceneManager::initialize: window not set, "
"ignoring!\n"));
return;
}
// the rendering action
_ownAction = RenderAction::create();
_action = _ownAction;
// the camera and light beacon
NodePtr cartN = Node::create();
_cart = Transform::create();
beginEditCP(cartN);
cartN->setCore(_cart);
endEditCP(cartN);
// the headlight
_internalRoot = Node::create();
_headlight = DirectionalLight::create();
addRefCP(_internalRoot);
beginEditCP(_internalRoot);
_internalRoot->setCore(_headlight);
_internalRoot->addChild(cartN);
endEditCP(_internalRoot);
beginEditCP(_headlight);
_headlight->setAmbient (.3, .3, .3, 1);
_headlight->setDiffuse ( 1, 1, 1, 1);
_headlight->setSpecular ( 1, 1, 1, 1);
_headlight->setDirection( 0, 0, 1);
_headlight->setBeacon (cartN);
endEditCP(_headlight);
// the camera
_camera = PerspectiveCamera::create();
addRefCP(_camera);
beginEditCP(PerspectiveCameraPtr::dcast(_camera));
PerspectiveCameraPtr::dcast(_camera)->setBeacon(cartN);
PerspectiveCameraPtr::dcast(_camera)->setFov (deg2rad(60.f));
PerspectiveCameraPtr::dcast(_camera)->setNear (0.1f);
PerspectiveCameraPtr::dcast(_camera)->setFar (10000.f);
endEditCP(PerspectiveCameraPtr::dcast(_camera));
// need a viewport?
if(_win->getPort().size() == 0)
{
SolidBackgroundPtr bg = SolidBackground::create();
beginEditCP(bg);
bg->setColor(Color3f(0, 0, 0));
endEditCP(bg);
ViewportPtr vp = Viewport::create();
beginEditCP(vp);
vp->setCamera (_camera);
vp->setRoot (_internalRoot);
vp->setSize (0,0, 1,1);
vp->setBackground (bg);
endEditCP(vp);
beginEditCP(_win);
_win->addPort(vp);
endEditCP(_win);
}
}
int main (int argc, char **argv)
{
osgInit(argc,argv);
// GLUT init
glutInit(&argc, argv);
glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
int winid = glutCreateWindow("OpenSG");
glutKeyboardFunc(key);
glutVisibilityFunc(vis);
glutReshapeFunc(reshape);
glutDisplayFunc(display);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutIdleFunc(display);
glEnable( GL_NORMALIZE );
glEnable( GL_DEPTH_TEST );
// OSG
// create the graph
// beacon for camera and light
NodePtr b1n = Node::create();
GroupPtr b1 = Group::create();
beginEditCP(b1n);
b1n->setCore( b1 );
endEditCP(b1n);
// transformation
NodePtr t1n = Node::create();
TransformPtr t1 = Transform::create();
beginEditCP(t1n);
t1n->setCore( t1 );
t1n->addChild( b1n );
endEditCP(t1n);
cam_trans = t1;
// light
NodePtr dlight = Node::create();
headlight = DirectionalLight::create();
beginEditCP(dlight);
dlight->setCore( headlight );
endEditCP(dlight);
beginEditCP(headlight);
headlight->setAmbient( .3, .3, .3, 1 );
headlight->setDiffuse( 1, 1, 1, 1 );
headlight->setSpecular( 1, 1, 1, 1 );
headlight->setDirection(0,0,1);
headlight->setBeacon( b1n);
endEditCP(headlight);
// root
root = Node::create();
GroupPtr gr1 = Group::create();
beginEditCP(root);
root->setCore( gr1 );
root->addChild( t1n );
root->addChild( dlight );
endEditCP(root);
// Create the scene
NodePtr sroot = Node::create();
beginEditCP(dlight);
dlight->addChild(sroot);
endEditCP(dlight);
GroupPtr gr = Group::create();
beginEditCP(sroot);
sroot->setCore(gr);
endEditCP(sroot);
// a transform to move it around
NodePtr tnode = Node::create();
tr = Transform::create();
beginEditCP(tnode);
tnode->setCore( tr );
endEditCP(tnode);
beginEditCP(sroot);
sroot->addChild(tnode);
endEditCP(sroot);
// the billboard
NodePtr bnode = Node::create();
bill = Billboard::create();
beginEditCP(bnode);
bnode->setCore( bill );
endEditCP(bnode);
beginEditCP(tnode);
tnode->addChild(bnode);
endEditCP(tnode);
// a geometry to billboard
NodePtr geo = makeTorus( .2, 1, 16, 3);
beginEditCP(bnode);
bnode->addChild( geo );
endEditCP(bnode);
// a geometry to lead the render action somewhere else
geo = makePlane( 2, 2, 2, 2 );
beginEditCP(sroot);
sroot->addChild( geo );
endEditCP(sroot);
dlight->updateVolume();
Vec3f min,max;
dlight->getVolume().getBounds( min, max );
std::cout << "Volume: from " << min << " to " << max << std::endl;
//std::cerr << "Tree: " << std::endl;
//root->dump();
// Camera
PerspectiveCameraPtr cam = PerspectiveCamera::create();
cam->setBeacon( b1n );
cam->setFov( deg2rad( 60 ) );
cam->setNear( .1 );
cam->setFar( 20. );
// Background
GradientBackgroundPtr bkgnd = GradientBackground::create();
bkgnd->addLine( Color3f( 0,0,0 ), 0 );
bkgnd->addLine( Color3f( .5,.5,0 ), 0.5 );
bkgnd->addLine( Color3f( .7,.7,1 ), 0.5 );
bkgnd->addLine( Color3f( 0,0,1 ), 1 );
// Viewport
ViewportPtr vp = 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;
GLUTWindowPtr gwin;
GLint glvp[4];
glGetIntegerv( GL_VIEWPORT, glvp );
gwin = GLUTWindow::create();
gwin->setId(winid);
gwin->setSize( glvp[2], glvp[3] );
win = gwin;
win->addPort( vp );
// Actions
dact = DrawAction::create();
ract = RenderAction::create();
// tball
Vec3f pos(0,
0,
max[2] + 1.5 * (max[2] - min[2]));
tball.setMode( Trackball::OSGObject );
tball.setStartPosition( pos, true );
tball.setSum( true );
tball.setTranslationMode( Trackball::OSGFree );
tball.setTranslationScale(10.);
// run...
glutMainLoop();
return 0;
}
void ApplicationBuilder::attachApplication(void)
{
Inherited::attachApplication();
beginEditCP(ApplicationBuilderPtr(this) , ApplicationBuilder::EditingProjectFieldMask);
setEditingProject(MainApplication::the()->getProject());
endEditCP(ApplicationBuilderPtr(this) , ApplicationBuilder::EditingProjectFieldMask);
//Camera Beacon
Matrix TransformMatrix;
TransformPtr CameraBeaconTransform = Transform::create();
beginEditCP(CameraBeaconTransform, Transform::MatrixFieldMask);
CameraBeaconTransform->setMatrix(TransformMatrix);
endEditCP(CameraBeaconTransform, Transform::MatrixFieldMask);
NodePtr CameraBeaconNode = Node::create();
beginEditCP(CameraBeaconNode, Node::CoreFieldMask);
CameraBeaconNode->setCore(CameraBeaconTransform);
endEditCP(CameraBeaconNode, Node::CoreFieldMask);
// Make Main Scene Node empty
NodePtr DefaultRootNode = osg::Node::create();
beginEditCP(DefaultRootNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
DefaultRootNode->setCore(osg::Group::create());
DefaultRootNode->addChild(CameraBeaconNode);
endEditCP(DefaultRootNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
//Camera
PerspectiveCameraPtr DefaultCamera = PerspectiveCamera::create();
beginEditCP(DefaultCamera);
DefaultCamera->setBeacon(CameraBeaconNode);
DefaultCamera->setFov (deg2rad(60.f));
DefaultCamera->setNear (0.1f);
DefaultCamera->setFar (10000.f);
endEditCP(DefaultCamera);
//Background
SolidBackgroundPtr DefaultBackground = SolidBackground::create();
beginEditCP(DefaultBackground, SolidBackground::ColorFieldMask);
DefaultBackground->setColor(Color3f(0.0f,0.0f,0.0f));
endEditCP(DefaultBackground, SolidBackground::ColorFieldMask);
//Icon Manager
_IconManager = DefaultIconManager::create();
//User Interface
ForegroundPtr UserInterfaceForeground = createInterface();
beginEditCP(_TheBuilderInterface->getDrawingSurface(), UIDrawingSurface::EventProducerFieldMask);
_TheBuilderInterface->getDrawingSurface()->setEventProducer(MainApplication::the()->getMainWindowEventProducer());
endEditCP(_TheBuilderInterface->getDrawingSurface(), UIDrawingSurface::EventProducerFieldMask);
//Viewport
if(MainApplication::the()->getMainWindowEventProducer()->getWindow() != NullFC && MainApplication::the()->getMainWindowEventProducer()->getWindow()->getPort().size() == 0)
{
ViewportPtr DefaultViewport = Viewport::create();
beginEditCP(DefaultViewport);
DefaultViewport->setCamera (DefaultCamera);
DefaultViewport->setRoot (DefaultRootNode);
DefaultViewport->setSize (0.0f,0.0f, 1.0f,1.0f);
DefaultViewport->setBackground (DefaultBackground);
DefaultViewport->getForegrounds().push_back (UserInterfaceForeground);
endEditCP(DefaultViewport);
beginEditCP(MainApplication::the()->getMainWindowEventProducer()->getWindow(), Window::PortFieldMask);
MainApplication::the()->getMainWindowEventProducer()->getWindow()->addPort(DefaultViewport);
endEditCP(MainApplication::the()->getMainWindowEventProducer()->getWindow(), Window::PortFieldMask);
}
}
void MultiDisplayWindow::serverRender(WindowPtr serverWindow,
UInt32 id,
DrawActionBase *action )
{
TileCameraDecoratorPtr deco;
ViewportPtr serverPort;
ViewportPtr clientPort;
StereoBufferViewportPtr clientStereoPort;
UInt32 sv,cv;
Int32 l,r,t,b;
Int32 cleft,cright,ctop,cbottom;
// sync, otherwise viewports will be out of date
if(!getHServers())
{
setHServers(getServers().size());
}
if(!getVServers())
{
setVServers(1);
}
UInt32 row =id/getHServers();
UInt32 column=id%getHServers();
// calculate width and height from local width and height
UInt32 width = serverWindow->getWidth() ;
UInt32 height = serverWindow->getHeight();
if(getWidth()==0)
{
setWidth( width*getHServers() );
}
if(getHeight()==0)
{
setHeight( height*getVServers() );
}
Int32 left = column * width - column * getXOverlap();
Int32 bottom = row * height - row * getYOverlap();
Int32 right = left + width - 1;
Int32 top = bottom + height - 1;
Real64 scaleCWidth =
((width - getXOverlap()) * (getHServers() - 1) + width) /
(float)getWidth();
Real64 scaleCHeight =
((height - getYOverlap())* (getVServers() - 1) + height)/
(float)getHeight();
bool isVirtualPort = false;
// duplicate viewports
for(cv = 0, sv = 0; cv < getPort().size(); ++cv)
{
clientPort = getPort()[cv];
#if 0
isVirtualPort = clientPort->getType().isDerivedFrom(FBOViewport::getClassType());
if(isVirtualPort)
{
// TODO -- seems wrong to render this on all servers, though rendering
// then transmitting the texture doesn't seem like a good idea either.
if(serverWindow->getPort().size() <= sv)
{
serverPort = ViewportPtr::dcast(clientPort->shallowCopy());
beginEditCP(serverWindow);
serverWindow->addPort(serverPort);
endEditCP(serverWindow);
}
else
{
serverPort = serverWindow->getPort()[sv];
if(serverWindow->getPort()[sv]->getType() !=
clientPort->getType())
{
// there is a viewport with the wrong type
subRefCP(serverWindow->getPort()[sv]);
serverPort = ViewportPtr::dcast(clientPort->shallowCopy());
beginEditCP(serverWindow);
{
serverWindow->getPort()[sv] = serverPort;
}
endEditCP(serverWindow);
}
}
// update changed viewport fields
updateViewport(serverPort,clientPort);
}
else
#endif
{
clientStereoPort =
dynamic_cast<StereoBufferViewportPtr>(clientPort);
cleft = (Int32)(clientPort->getPixelLeft() * scaleCWidth) ;
cbottom = (Int32)(clientPort->getPixelBottom() * scaleCHeight) ;
cright = (Int32)((clientPort->getPixelRight()+1) * scaleCWidth) -1;
ctop = (Int32)((clientPort->getPixelTop()+1) * scaleCHeight)-1;
if(cright < left ||
cleft > right ||
ctop < bottom ||
cbottom > top )
{
// invisible on this server screen
continue;
}
// calculate overlapping viewport
l = osgMax(cleft ,left ) - left;
b = osgMax(cbottom,bottom) - bottom;
r = osgMin(cright ,right ) - left;
t = osgMin(ctop ,top ) - bottom;
if(serverWindow->getPort().size() <= sv)
{
serverPort =
dynamic_cast<ViewportPtr>(clientPort->shallowCopy());
deco = TileCameraDecorator::create();
serverWindow->addPort(serverPort);
serverPort->setCamera(deco);
}
else
{
serverPort = serverWindow->getPort()[sv];
deco = dynamic_cast<TileCameraDecoratorPtr>(
serverPort->getCamera());
if(serverWindow->getPort()[sv]->getType() !=
clientPort->getType())
{
// there is a viewport with the wrong type
serverPort =
dynamic_cast<ViewportPtr>(clientPort->shallowCopy());
serverWindow->replacePort(sv,
serverPort);//[sv] = serverPort;
serverPort->setCamera(deco);
}
else
{
deco = dynamic_cast<TileCameraDecoratorPtr>(
serverPort->getCamera());
}
}
// update changed viewport fields
updateViewport(serverPort,clientPort);
// set viewport size
serverPort->setSize(Real32(l),Real32(b),Real32(r),Real32(t));
// use pixel even if pixel = 1
if(serverPort->getLeft() == 1.0)
serverPort->setLeft(1.0001);
if(serverPort->getRight() == 1.0)
serverPort->setRight(1.0001);
if(serverPort->getTop() == 1.0)
serverPort->setTop(1.0001);
if(serverPort->getBottom() == 1.0)
serverPort->setBottom(1.0001);
// calculate tile parameters
deco->setFullWidth ( cright-cleft );
deco->setFullHeight( ctop-cbottom );
deco->setSize( ( l+left-cleft ) / (float)( cright-cleft ),
( b+bottom-cbottom ) / (float)( ctop-cbottom ),
( r+left-cleft ) / (float)( cright-cleft ),
( t+bottom-cbottom ) / (float)( ctop-cbottom ) );
deco->setDecoratee( clientPort->getCamera() );
}
sv++;
}
// remove unused ports
while(serverWindow->getPort().size()>sv)
{
serverWindow->subPort(sv);
}
Inherited::serverRender(serverWindow,id,action);
}
int main(int argc, char **argv)
{
for(int i = 0; i < argc; i++)
{
std::cout << "Param " << i << ":" << argv[i] << std::endl;
}
OSG::osgInit(argc, argv);
const char *inFileName = "tie.bin";
if(argc > 1)
inFileName = argv[1];
std::ifstream in(inFileName, std::ios::binary);
if(!in)
{
std::cerr <<
"ERROR: Cannot open file " <<
inFileName <<
"" <<
std::endl;
return -1;
}
OSG::BINLoader loader(in);
loader.read();
in.close();
std::cout <<
"MAIN: " <<
getContainerId(loader.getRootNode()) <<
" is root" <<
std::endl;
// GLUT init
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | 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_NORMALIZE);
glDisable(GL_LIGHTING);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glClearColor(0.5, 0.5, 0.5, 1.);
// OSG
// OSGSceneFileHandler::the().print();
// FhsFile::touch();
// create the graph
// beacon for camera and light
NodePtr b1n = Node::create();
GroupPtr b1 = Group::create();
beginEditCP(b1n);
b1n->setCore(b1);
endEditCP(b1n);
// transformation
NodePtr t1n = Node::create();
TransformPtr t1 = Transform::create();
beginEditCP(t1n);
t1n->setCore(t1);
t1n->addChild(b1n);
endEditCP(t1n);
cam_trans = t1;
// light
NodePtr dlight = Node::create();
headlight = DirectionalLight::create();
beginEditCP(dlight);
dlight->setCore(headlight);
endEditCP(dlight);
beginEditCP(headlight);
headlight->setAmbient(.3, .3, .3, 1);
headlight->setDiffuse(1, 1, 1, 1);
headlight->setSpecular(1, 1, 1, 1);
headlight->setDirection(0, 0, 1);
headlight->setBeacon(b1n);
endEditCP(headlight);
// root
root = Node::create();
GroupPtr gr1 = Group::create();
beginEditCP(root);
root->setCore(gr1);
root->addChild(t1n);
root->addChild(dlight);
endEditCP(root);
// Load the file
NodePtr fileRoot = Node::create();
// OSGActivateColMatPtr colMat = OSGActivateColMat::create();
GroupPtr gr = Group::create();
beginEditCP(fileRoot);
// fileRoot->setCore(colMat);
fileRoot->setCore(gr);
endEditCP(fileRoot);
beginEditCP(dlight);
dlight->addChild(fileRoot);
endEditCP(dlight);
// for(UInt32 numFiles = 1; numFiles < argc; numFiles++)
// {
// file = SceneFileHandler::the().read(argv[1]);
file = loader.getRootNode();
beginEditCP(fileRoot);
fileRoot->addChild(file);
fileRoot->invalidateVolume();
endEditCP(fileRoot);
// }
dlight->updateVolume();
Vec3f min, max;
dlight->getVolume().getBounds(min, max);
std::cout << "Volume: from " << min << " to " << max << std::endl;
//std::cerr << "Tree: " << std::endl;
//root->dump();
// Camera
PerspectiveCameraPtr cam = PerspectiveCamera::create();
cam->setBeacon(b1n);
cam->setFov(deg2rad(60));
cam->setNear(1.);
cam->setFar(100000.);
// Background
GradientBackgroundPtr bkgnd = GradientBackground::create();
bkgnd->addLine(Color3f(0, 0, 0), 0);
bkgnd->addLine(Color3f(.5, .5, 0), 0.5);
bkgnd->addLine(Color3f(.7, .7, 1), 0.5);
bkgnd->addLine(Color3f(0, 0, 1), 1);
// Viewport
ViewportPtr vp = 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;
GLUTWindowPtr gwin;
GLint glvp[4];
glGetIntegerv(GL_VIEWPORT, glvp);
gwin = GLUTWindow::create();
gwin->setId(winid);
gwin->setSize(glvp[2], glvp[3]);
win = gwin;
win->addPort(vp);
// Actions
dact = DrawAction::create();
ract = RenderAction::create();
// tball
/*
Vec3f pos(min[0] + 0.5 * (max[0] - min[0]),
min[1] + 0.5 * (max[1] - min[1]),
max[2] + 1.5 * (max[2] - min[2]));
*/
Vec3f pos(0, 0, max[2] + 1.5 * (max[2] - min[2]));
tball.setMode(Trackball::OSGObject);
tball.setStartPosition(pos, true);
tball.setSum(true);
tball.setTranslationMode(Trackball::OSGFree);
tball.setTranslationScale(10000.);
// run...
glutMainLoop();
return 0;
}
ComponentPtr createGLPanel(void)
{
//Create the nessicary parts for a viewport
//Camera Beacon
Matrix TransformMatrix;
TransformMatrix.setTranslate(0.0f,0.0f, 0.0f);
TransformPtr CameraBeaconTransform = Transform::create();
beginEditCP(CameraBeaconTransform, Transform::MatrixFieldMask);
CameraBeaconTransform->setMatrix(TransformMatrix);
endEditCP(CameraBeaconTransform, Transform::MatrixFieldMask);
NodePtr CameraBeaconNode = Node::create();
beginEditCP(CameraBeaconNode, Node::CoreFieldMask);
CameraBeaconNode->setCore(CameraBeaconTransform);
endEditCP(CameraBeaconNode, Node::CoreFieldMask);
//Light Beacon
Matrix LightTransformMatrix;
LightTransformMatrix.setTranslate(0.0f,0.0f, 0.0f);
TransformPtr LightBeaconTransform = Transform::create();
beginEditCP(LightBeaconTransform, Transform::MatrixFieldMask);
LightBeaconTransform->setMatrix(TransformMatrix);
endEditCP(LightBeaconTransform, Transform::MatrixFieldMask);
NodePtr LightBeaconNode = Node::create();
beginEditCP(LightBeaconNode, Node::CoreFieldMask);
LightBeaconNode->setCore(CameraBeaconTransform);
endEditCP(LightBeaconNode, Node::CoreFieldMask);
//Light Node
DirectionalLightPtr TheDirectionLight = DirectionalLight::create();
beginEditCP(TheDirectionLight, DirectionalLight::DirectionFieldMask);
TheDirectionLight->setDirection(0.0f,1.0f,0.0f);
endEditCP(TheDirectionLight, DirectionalLight::DirectionFieldMask);
NodePtr LightNode = Node::create();
beginEditCP(LightNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
LightNode->setCore(TheDirectionLight);
LightNode->addChild(createScene());
endEditCP(LightNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
// Make Torus Node (creates Torus in background of scene)
NodePtr GeometryNode = makeTorus(.5, 2, 32, 32);
// Make Main Scene Node and add the Torus
NodePtr DefaultRootNode = osg::Node::create();
beginEditCP(DefaultRootNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
DefaultRootNode->setCore(osg::Group::create());
DefaultRootNode->addChild(CameraBeaconNode);
DefaultRootNode->addChild(LightBeaconNode);
DefaultRootNode->addChild(LightNode);
endEditCP(DefaultRootNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
//Camera
PerspectiveCameraPtr DefaultCamera = PerspectiveCamera::create();
beginEditCP(DefaultCamera);
DefaultCamera->setBeacon(CameraBeaconNode);
DefaultCamera->setFov (deg2rad(60.f));
DefaultCamera->setNear (0.1f);
DefaultCamera->setFar (100.f);
endEditCP(DefaultCamera);
//Background
GradientBackgroundPtr DefaultBackground = GradientBackground::create();
beginEditCP(DefaultBackground, GradientBackground::ColorFieldMask | GradientBackground::PositionFieldMask);
DefaultBackground->addLine(Color3f(0.0f,0.0f,0.0f), 0.0f);
DefaultBackground->addLine(Color3f(0.0f,0.0f,1.0f), 1.0f);
endEditCP(DefaultBackground, GradientBackground::ColorFieldMask | GradientBackground::PositionFieldMask);
//Viewport
ViewportPtr DefaultViewport = Viewport::create();
beginEditCP(DefaultViewport);
DefaultViewport->setCamera (DefaultCamera);
DefaultViewport->setRoot (DefaultRootNode);
DefaultViewport->setSize (0.0f,0.0f, 1.0f,1.0f);
DefaultViewport->setBackground (DefaultBackground);
endEditCP(DefaultViewport);
//GL Viewport Component
GLViewportPtr TheGLViewport = GLViewport::create();
beginEditCP(TheGLViewport, GLViewport::PortFieldMask | GLViewport::PreferredSizeFieldMask | GLViewport::BordersFieldMask);
TheGLViewport->setPort(DefaultViewport);
TheGLViewport->setPreferredSize(Vec2f(1024.0f,768.0f));
endEditCP(TheGLViewport, GLViewport::PortFieldMask | GLViewport::PreferredSizeFieldMask | GLViewport::BordersFieldMask);
TheGLViewport->showAll();
return TheGLViewport;
}
int main( int argc, char **argv )
{
Int32 i,
retVal;
// OSG init
osgInit(argc, argv);
basetime = getSystemTime();
gThreadManager = ThreadManager::the();
SceneFileHandler::the().print();
// create the graph
// beacon for camera and light
NodePtr b1n = Node::create();
GroupPtr b1 = Group::create();
beginEditCP(b1n);
b1n->setCore( b1 );
endEditCP(b1n);
// transformation
NodePtr t1n = Node::create();
TransformPtr t1 = Transform::create();
beginEditCP(t1n);
t1n->setCore( t1 );
t1n->addChild( b1n );
endEditCP(t1n);
cam_trans = t1;
// light
NodePtr dlight = Node::create();
DirectionalLightPtr dl = DirectionalLight::create();
beginEditCP(dlight);
dlight->setCore( dl );
endEditCP(dlight);
beginEditCP(dl);
dl->setAmbient( .3, .3, .3, 1 );
dl->setDiffuse( 1, 1, 1, 1 );
dl->setDirection(0,0,1);
dl->setBeacon( b1n);
endEditCP(dl);
// root
root = Node::create();
GroupPtr gr1 = Group::create();
beginEditCP(root);
root->setCore( gr1 );
root->addChild( t1n );
root->addChild( dlight );
endEditCP(root);
// Load the file
NodePtr file = NullFC;
if ( argc > 1 )
file = SceneFileHandler::the().read(argv[1]);
if ( file == NullFC )
{
std::cerr << "Couldn't load file, ignoring" << std::endl;
file = makePlane( 2,2,2,2 );
}
file->updateVolume();
Vec3f min,max;
file->getVolume().getBounds( min, max );
std::cout << "Volume: from " << min << " to " << max << std::endl;
beginEditCP(dlight);
dlight->addChild( file );
endEditCP(dlight);
std::cerr << "Tree: " << std::endl;
root->dump();
// Camera
PerspectiveCameraPtr cam = PerspectiveCamera::create();
cam->setBeacon( b1n );
cam->setFov( deg2rad( 60 ) );
cam->setNear( 0.1 );
cam->setFar( 10000 );
// Background
GradientBackgroundPtr bkgnd = GradientBackground::create();
bkgnd->addLine( Color3f( 0,0,0 ), 0 );
bkgnd->addLine( Color3f( 0,0,1 ), 0 );
// Action
// QT init
QApplication::setColorSpec( QApplication::CustomColor );
a = new QApplication( argc, argv );
if ( !QGLFormat::hasOpenGL() )
{
qWarning( "This system has no OpenGL support. Exiting." );
return -1;
}
Vec3f pos( 0, 0, max[2] + ( max[2] - min[2] ) * 1.5 );
tball.setMode( Trackball::OSGObject );
tball.setStartPosition( pos, true );
tball.setSum( true );
tball.setTranslationMode( Trackball::OSGFree );
// Create Windows
QGLFormat::setDefaultFormat(QGLFormat(QGL::DirectRendering |
QGL::DoubleBuffer |
QGL::DepthBuffer |
QGL::Rgba ));
for ( i = 0; i < NUM_THREADS; i++ )
{
glWidget[i] = new MyOSGQGLWidget();
// Viewport
vp = Viewport::create();
vp->setCamera( cam );
vp->setBackground( bkgnd );
vp->setRoot( root );
vp->setSize( 0,0, 1,1 );
glWidget[i]->_osgWin = QTWindow::create();
glWidget[i]->_osgWin->setGlWidget( glWidget[i] );
glWidget[i]->_osgWin->addPort( vp );
glWidget[i]->_osgWin->init();
if ( i == 0 )
{
a->setMainWidget( glWidget[0] );
}
glWidget[i]->show();
}
for (i = 0; i < NUM_THREADS; i++)
{
drawThread[i] =
dynamic_cast<Thread *>(gThreadManager->getThread(NULL));
if ( drawThread[i] != NULL )
{
drawThreadID[i] = i;
drawThread[i]->runFunction( drawThreadProc, 0, (void *) &(drawThreadID[i]) );
}
}
drawBarrier = gThreadManager->getBarrier( "drawBarrier" );
// glWidget[0]->paintGL();
retVal = a->exec(); // execute QT main loop
// stop th ethreads
for ( i=0; i<NUM_THREADS; i++ )
glWidget[i]->_stop = true;
drawBarrier->enter( NUM_THREADS + 1 );
for ( i=0; i<NUM_THREADS; i++ )
Thread::join( drawThread[i] );
return (retVal);
}
int main (int argc, char **argv)
{
osgInit(argc,argv);
FieldContainerPtr pProto = Geometry::getClassType().getPrototype();
GeometryPtr pGeoProto = GeometryPtr::dcast(pProto);
if(pGeoProto != NullFC)
{
pGeoProto->setDlistCache(false);
}
// GLUT init
glutInit(&argc, argv);
glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE | GLUT_STENCIL);
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 );
glEnable(GL_NORMALIZE);
// OSG
SceneFileHandler::the().print();
// create the graph
// beacon for camera and light
NodePtr b1n = Node::create();
GroupPtr b1 = Group::create();
beginEditCP(b1n);
b1n->setCore( b1 );
endEditCP(b1n);
// transformation
NodePtr t1n = Node::create();
TransformPtr t1 = Transform::create();
beginEditCP(t1n);
t1n->setCore( t1 );
t1n->addChild( b1n );
endEditCP(t1n);
cam_trans = t1;
// light
//#define OSG_HLIGHT
NodePtr dlight = Node::create();
#ifdef OSG_HLIGHT
DirectionalLightPtr dl = DirectionalLight::create();
#else
GroupPtr dl = Group::create();
#endif
beginEditCP(dlight);
dlight->setCore( dl );
endEditCP(dlight);
#ifdef OSG_HLIGHT
beginEditCP(dl);
dl->setAmbient( .2, .2, .2, 1 );
dl->setDiffuse( .8, .8, .8, 1 );
dl->setDirection(0,0,1);
dl->setBeacon( b1n);
endEditCP(dl);
#endif
// root
root = Node::create();
GroupPtr gr1 = Group::create();
beginEditCP(root);
root->setCore( gr1 );
root->addChild( t1n );
root->addChild( dlight );
endEditCP(root);
// Load the file
NodePtr file = NullFC;
/*
if ( argc > 1 )
file = SceneFileHandler::the().read(argv[1]);
if ( file == NullFC )
{
cerr << "Couldn't load file, ignoring" << endl;
file = makeTorus( .5, 2, 16, 16 );
}
*/
VRMLLoader *pFile = new VRMLLoader;
pFile->scanFile(argv[1], 0);
VRMLToOSGAction aVRMLToOSG;
FieldContainerPtr pFC = NullFC;
VRMLBindings::NodeBinderPtr pNodeBinder = NULL;
fprintf(stderr, "Resnode %p\n", pFile->getFileTree());
aVRMLToOSG.setNameNodeMap(pFile->getNameNodeMap());
aVRMLToOSG.setDataTransferMode(VRMLToOSGAction::SwapData);
aVRMLToOSG.apply(pFile->getFileTree());
/*
pNodeBinder = (pFile->getFileTree())->getBinder();
if(pNodeBinder != NULL)
{
pFC = pNodeBinder->getFCPtr();
if(pFC != NullFC)
{
file = NodePtr::dcast(pFC);
}
else
{
fprintf(stderr, "FCPtr NULL\n");
}
}
else
{
fprintf(stderr, "Binder NULL\n");
}
*/
file = aVRMLToOSG.getRoot();
if(file == NullFC)
return 0;
file->updateVolume();
Vec3f min,max;
file->getVolume().getBounds( min, max );
cout << "Volume: from " << min << " to " << max << endl;
beginEditCP(dlight);
dlight->addChild( file );
endEditCP(dlight);
cerr << "Tree: " << endl;
// root->dump();
// Camera
cam = PerspectiveCamera::create();
cam->setBeacon( b1n );
cam->setFov( deg2rad( 90 ) );
cam->setNear( 0.1 );
cam->setFar( 10000 );
// Background
SolidBackgroundPtr bkgnd = SolidBackground::create();
// Viewport
vp = Viewport::create();
vp->setCamera( cam );
vp->setBackground( bkgnd );
vp->setRoot( root );
vp->setSize( 0,0, 1,1 );
// Window
cout << "GLUT winid: " << winid << endl;
GLUTWindowPtr gwin;
GLint glvp[4];
glGetIntegerv( GL_VIEWPORT, glvp );
gwin = GLUTWindow::create();
gwin->setId(winid);
gwin->setSize( glvp[2], glvp[3] );
win = gwin;
win->addPort( vp );
win->init();
// Action
ract = DrawAction::create();
// tball
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;
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( Trackball::OSGObject );
tball.setStartPosition( pos, true );
tball.setSum( true );
tball.setTranslationMode( Trackball::OSGFree );
tball.setTranslationScale(scale);
tball.setRotationCenter(tCenter);
// run...
#ifdef PAR_SCHEDULER
Thread::getCurrent()->getChangeList()->applyTo(1);
VSC::VSCScheduler::the()->run();
#endif
glutMainLoop();
return 0;
}
int main (int argc, char **argv)
{
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 );
// OSG
SceneFileHandler::the().print();
// create the graph
// beacon for camera and light
NodePtr b1n = Node::create();
GroupPtr b1 = Group::create();
beginEditCP(b1n);
b1n->setCore( b1 );
endEditCP(b1n);
// transformation
NodePtr t1n = Node::create();
TransformPtr t1 = Transform::create();
beginEditCP(t1n);
t1n->setCore( t1 );
t1n->addChild( b1n );
endEditCP(t1n);
cam_trans = t1;
// light
NodePtr dlight = Node::create();
DirectionalLightPtr dl = DirectionalLight::create();
beginEditCP(dlight);
dlight->setCore( dl );
endEditCP(dlight);
beginEditCP(dl);
dl->setAmbient( .3, .3, .3, 1 );
dl->setDiffuse( 1, 1, 1, 1 );
dl->setDirection(0,0,1);
dl->setBeacon( b1n);
endEditCP(dl);
// root
root = Node::create();
GroupPtr gr1 = Group::create();
beginEditCP(root);
root->setCore( gr1 );
root->addChild( t1n );
root->addChild( dlight );
endEditCP(root);
// Load the file
NodePtr file = NullFC;
NodePtr file1 = NullFC;
if ( argc > 1 )
file1 = SceneFileHandler::the().read(argv[1]);
if ( file1 == NullFC )
{
std::cerr << "Couldn't load file, ignoring" << std::endl;
file1 = makeTorus( .5, 2, 16, 16 );
}
file1->updateVolume();
// file->dump();
// subRefCP(file);
// return 0;
Vec3f min,max;
file1->getVolume().getBounds( min, max );
std::cout << "Volume: from " << min << " to " << max << std::endl;
file = Node::create();
MaterialGroupPtr testMat = MaterialGroup::create();
SimpleMaterialPtr defaultMaterial = SimpleMaterial::create();
beginEditCP(defaultMaterial);
defaultMaterial->setDiffuse(Color3f(1,.0,.0));
defaultMaterial->setAmbient(Color3f(0.1,0.1,0.1));
defaultMaterial->setSpecular(Color3f(1,1,1));
defaultMaterial->setShininess(20);
endEditCP (defaultMaterial);
testMat->setMaterial(defaultMaterial);
beginEditCP(file);
{
// file->setCore(testMat);
file->setCore(Group::create());
file->addChild(file1);
}
endEditCP (file);
scene_trans = Transform::create();
NodePtr sceneTrN = Node::create();
beginEditCP(sceneTrN);
{
sceneTrN->setCore(scene_trans);
sceneTrN->addChild(file);
sceneTrN->addChild(makeTorus( .5, 2, 16, 16 ));
}
endEditCP(sceneTrN);
beginEditCP(dlight);
dlight->addChild(sceneTrN);
endEditCP(dlight);
std::cerr << "Tree: " << std::endl;
// root->dump();
// Camera
cam = PerspectiveCamera::create();
cam->setBeacon( b1n );
cam->setFov( deg2rad( 90 ) );
cam->setNear( 0.1 );
cam->setFar( 100000 );
// Background
SolidBackgroundPtr bkgnd = SolidBackground::create();
beginEditCP(bkgnd, SolidBackground::ColorFieldMask);
bkgnd->setColor(Color3f(1,1,1));
endEditCP(bkgnd, SolidBackground::ColorFieldMask);
// Viewport
vp = 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;
GLUTWindowPtr gwin;
GLint glvp[4];
glGetIntegerv( GL_VIEWPORT, glvp );
gwin = GLUTWindow::create();
gwin->setId(winid);
gwin->setSize( glvp[2], glvp[3] );
win = gwin;
win->addPort( vp );
win->init();
// Action
ract = DrawAction::create();
renact = RenderAction::create();
// tball
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;
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( Trackball::OSGObject );
tball.setStartPosition( pos, true );
tball.setSum( true );
tball.setTranslationMode( Trackball::OSGFree );
tball.setTranslationScale(scale);
tball.setRotationCenter(tCenter);
// run...
glutMainLoop();
return 0;
}
int main (int argc, char **argv)
{
osgInit( argc, argv );
glutInit( &argc, argv );
glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE );
int winID = glutCreateWindow("OpenSG");
glutKeyboardFunc(key);
glutVisibilityFunc(vis);
glutReshapeFunc(resize);
glutDisplayFunc(display);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutIdleFunc(display);
glEnable( GL_DEPTH_TEST );
glEnable( GL_LIGHTING );
glEnable( GL_LIGHT0 );
glClearColor( .1, .6, .2, 1 );
//glCullFace( GL_BACK );
//glEnable( GL_CULL_FACE );
//BEACON
NodePtr beaconNode = Node::create();
GroupPtr beaconCore = Group::create();
beginEditCP( beaconNode );
beaconNode->setCore( beaconCore );
endEditCP( beaconNode );
//TRANSFORM
NodePtr transNode = Node::create();
TransformPtr transCore = Transform::create();
beginEditCP( transNode );
transNode->setCore( transCore );
transNode->addChild( beaconNode );
endEditCP( transNode );
cam_trans = transCore;
//OBJECT0: Plane
objects[0] = makeBox( 3,3,2, 2,2,1 );
calcFaceNormals( GeometryPtr::dcast(objects[0]->getCore()) );
normals[0] = calcFaceNormalsGeo( GeometryPtr::dcast(objects[0]->getCore()), 0.5 );
//OBJECT1: Sphere
objects[1] = makeSphere( 2, 2 );
calcFaceNormals( GeometryPtr::dcast(objects[1]->getCore()) );
normals[1] = calcFaceNormalsGeo( GeometryPtr::dcast(objects[1]->getCore()), 0.5 );
//OBJECT2: Cone
objects[2] = makeConicalFrustum( 1.5, 0.75, 2, 8, true, true, true );
calcFaceNormals( GeometryPtr::dcast(objects[2]->getCore()) );
normals[2] = calcFaceNormalsGeo( GeometryPtr::dcast(objects[2]->getCore()), 0.5 );
//OBJECT3: Custom Single Indexed Geometry
objects[3] = Node::create();
GeometryPtr obj3Core= Geometry::create();
GeoIndicesUI32Ptr obj3Index = GeoIndicesUI32::create();
GeoPositions3f::PtrType obj3Pnts = GeoPositions3f::create();
GeoColors3f::PtrType obj3Colors = GeoColors3f::create();
GeoPTypesPtr obj3Types = GeoPTypesUI8::create();
GeoPLengthsPtr obj3Lengths = GeoPLengthsUI32::create();
beginEditCP( obj3Pnts );
obj3Pnts->addValue( Pnt3f(0, 0,0) );
obj3Pnts->addValue( Pnt3f(1,-1,0) );
obj3Pnts->addValue( Pnt3f(1, 1,0) );
obj3Pnts->addValue( Pnt3f(1, 1,0) );
obj3Pnts->addValue( Pnt3f(1,-1,0) );
obj3Pnts->addValue( Pnt3f(3,-1.3,0) );
obj3Pnts->addValue( Pnt3f(3, 1.3,0) );
obj3Pnts->addValue( Pnt3f(3, 1.3,0) );
obj3Pnts->addValue( Pnt3f(3,-1.3,0) );
obj3Pnts->addValue( Pnt3f(4, 0,0) );
endEditCP( obj3Pnts );
beginEditCP( obj3Types );
//obj3Types->addValue( GL_TRIANGLES );
//obj3Types->addValue( GL_QUADS );
//obj3Types->addValue( GL_TRIANGLES );
obj3Types->addValue( GL_POLYGON );
endEditCP( obj3Types );
beginEditCP( obj3Lengths );
//obj3Lengths->addValue( 3 );
//obj3Lengths->addValue( 4 );
//obj3Lengths->addValue( 3 );
obj3Lengths->addValue( 6 );
endEditCP( obj3Lengths );
beginEditCP( obj3Colors );
for( UInt32 i=0; i<obj3Pnts->getSize(); ++i )
{
obj3Colors->addValue( Color3f(.7,.7,.7) );
}
endEditCP( obj3Colors );
beginEditCP( obj3Index );
//for( UInt32 i=0; i<obj3Pnts->getSize(); ++i )
//{
// obj3Index->addValue( i );
//}
obj3Index->addValue( 0 );
obj3Index->addValue( 1 );
obj3Index->addValue( 5 );
obj3Index->addValue( 9 );
obj3Index->addValue( 6 );
obj3Index->addValue( 2 );
endEditCP( obj3Index );
beginEditCP( obj3Core );
obj3Core->setIndices( obj3Index );
obj3Core->setPositions( obj3Pnts );
obj3Core->setTypes( obj3Types );
obj3Core->setLengths( obj3Lengths );
obj3Core->setColors( obj3Colors );
endEditCP( obj3Core );
beginEditCP( objects[3] );
objects[3]->setCore( obj3Core );
endEditCP( objects[3] );
calcFaceNormals( GeometryPtr::dcast(objects[3]->getCore()) );
normals[3] = calcFaceNormalsGeo( GeometryPtr::dcast(objects[3]->getCore()), 0.5 );
//ROOT
root = Node::create();
GroupPtr rootCore = Group::create();
beginEditCP(root);
root->setCore(rootCore);
root->addChild(transNode);
root->addChild(objects[0]);
root->addChild(normals[0]);
activeObj = root->findChild( objects[0] );
activeNorm = root->findChild( normals[0] );
endEditCP(root);
camera = PerspectiveCamera::create();
camera->setBeacon( beaconNode );
camera->setFov( 90 );
camera->setNear( 0.1 );
camera->setFar( 10000 );
SolidBackgroundPtr background = SolidBackground::create();
viewp = Viewport::create();
viewp->setCamera( camera );
viewp->setBackground( background );
viewp->setRoot( root );
viewp->setSize( 0,0, 1,1 );
GLint glVP[4];
glGetIntegerv( GL_VIEWPORT, glVP );
GLUTWindowPtr gwin = GLUTWindow::create();
gwin->setId(winID);
gwin->setSize(glVP[2], glVP[3]);
window = gwin;
window->addPort( viewp );
window->init();
drAct = DrawAction::create();
Vec3f pos( 0, 0, 3 );
tball.setMode( Trackball::OSGObject );
tball.setStartPosition( pos, true );
tball.setSum( true );
tball.setTranslationMode( Trackball::OSGFree );
glutMainLoop();
return 0;
}
virtual void redraw( void ) {
static bool first=true;
static RenderNode rn;
int i;
double tbalance;
GeoLoadManager::ResultT region;
if (_internalRoot == NullFC)
{
initialize();
showAll();
}
_cart->getSFMatrix()->setValue(_navigator.getMatrix());
updateHighlight();
_win->activate();
_win->frameInit();
if(first)
{
loadManager=new GeoLoadManager(useFaceDistribution);
first=false;
rn.determinePerformance(_win);
}
if(_win->getPort().size() < (serverCount+1))
{
ViewportPtr vp,ovp=_win->getPort(0);
addRefCP(ovp);
addRefCP(ovp);
TileCameraDecoratorPtr deco;
for(int i=_win->getPort().size()-1;i<serverCount;i++)
{
cout << "Add new" << endl;
loadManager->addRenderNode(rn,i);
if(simulateRendering)
{
beginEditCP(_win);
deco=TileCameraDecorator::create();
beginEditCP(deco);
deco->setFullWidth ( _win->getWidth() );
deco->setFullHeight( _win->getHeight() );
deco->setDecoratee( ovp->getCamera() );
vp=Viewport::create();
beginEditCP(vp);
vp->setRoot ( ovp->getRoot() );
/*
SkyBackgroundPtr sky = SkyBackground::create();
beginEditCP(sky);
sky->setSphereRes(16);
sky->getMFSkyColor()->addValue(Color3f(0, 0, .2));
sky->getMFSkyAngle()->addValue(Pi / 2);
sky->getMFSkyColor()->addValue(Color3f(.6, .6, 1));
sky->getMFGroundColor()->addValue(Color3f(0, .3, 1));
sky->getMFGroundAngle()->addValue(Pi / 2);
sky->getMFGroundColor()->addValue(Color3f(1, .3, 0));
endEditCP(sky);
vp->setBackground( sky );
*/
vp->setBackground( ovp->getBackground() );
vp->getMFForegrounds()->setValues( ovp->getForegrounds() );
vp->setCamera(deco);
_win->addPort(vp);
endEditCP(_win);
endEditCP(vp);
endEditCP(deco);
}
}
}
tbalance = -getSystemTime();
loadManager->update(_win->getPort()[0]->getRoot());
loadManager->balance(_win->getPort()[0],false,region);
tbalance += getSystemTime();
if(simulateRendering)
{
ViewportPtr vp;
TileCameraDecoratorPtr deco;
for(i=0;i<region.size();i+=4)
{
#if 1
cout << "Region: " << i << " ";
cout << region[i+0] << " ";
cout << region[i+1] << " ";
cout << region[i+2] << " ";
cout << region[i+3] << endl;
if(region[i+0] >= region[i+2]) {
cout << "!!!" << endl;
region[i+2]++;
}
if(region[i+1] >= region[i+3]) {
cout << "!!!" << endl;
region[i+3]++;
}
#endif
vp=_win->getPort()[i/4+1];
deco=TileCameraDecoratorPtr::dcast(vp->getCamera());
beginEditCP(deco);
beginEditCP(vp);
vp->setSize(region[i+0],
region[i+1],
region[i+2],
region[i+3]);
deco->setSize(region[i+0]/(float)_win->getWidth(),
region[i+1]/(float)_win->getHeight(),
region[i+2]/(float)_win->getWidth(),
region[i+3]/(float)_win->getHeight());
endEditCP(deco);
endEditCP(vp);
}
}
Time t,tmin,tmax;
for(i=0;i<_win->getPort().size();++i)
{
t=-getSystemTime();
_action->setWindow( _win.getCPtr() );
_win->getPort(i)->render( _action );
glFlush();
t+=getSystemTime();
if(i==0)
continue;
if(i==1)
{
tmin=tmax=t;
}
else
{
if(t<tmin) tmin=t;
if(t>tmax) tmax=t;
}
}
if(!cache)
printf("speed %5d %10.6f %10.6f %10.6f\n",_win->getPort().size()-1,
tmin,
tmax,
tbalance);
glPushAttrib(GL_ALL_ATTRIB_BITS);
glDisable(GL_SCISSOR_TEST);
glViewport(0,0,
_win->getWidth(),
_win->getHeight());
if(viewVolume)
loadManager->drawVolumes(_win);
glPushMatrix();
glLoadIdentity();
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(0,_win->getWidth(),
0,_win->getHeight());
glDisable(GL_DEPTH_TEST);
glEnable(GL_COLOR_MATERIAL);
for(i=0;i<region.size();i+=4)
{
#if 0
cout << "Region: ";
cout << region[i+0] << " ";
cout << region[i+1] << " ";
cout << region[i+2] << " ";
cout << region[i+3] << endl;
#endif
glBegin(GL_LINE_LOOP);
glColor3f(1, 1, 0);
glVertex3f(region[i+0],region[i+1],0);
glVertex3f(region[i+2],region[i+1],0);
glVertex3f(region[i+2],region[i+3],0);
glVertex3f(region[i+0],region[i+3],0);
glEnd();
}
glDisable(GL_COLOR_MATERIAL);
glEnable(GL_DEPTH_TEST);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glPopAttrib();
if(doSave)
{
Int32 w,h;
w=_win->getPort(0)->getPixelWidth();
h=_win->getPort(0)->getPixelHeight();
Image image(Image::OSG_RGB_PF,
w,h,1,
1,1,0.0,
NULL,true);
ImageFileType *imgTransType=ImageFileHandler::the().getFileType("JPEG");
char filename[256];
if(imgTransType==NULL)
{
cerr << "Unknown image trans type" << endl;
return;
}
sprintf(filename,"%s_%d.jpg",dumpImage,dumpImageNr++);
// read buffer data into image
glPixelStorei(GL_PACK_ALIGNMENT,1);
glReadPixels(0,0,w,h,
GL_RGB,GL_UNSIGNED_BYTE,
image.getData());
imgTransType->write(image,filename);
}
_win->swap();
_win->frameExit();
}