void SkyBackgroundPluginForm::on_enableCheckBox_toggled( bool checked )
{
vrOSGWidget *gl = vrOSGWidget::getMGLW(-1);
ViewportPtr vredViewport = gl->getViewport();
beginEditCP(vredViewport);
if (checked && skyBackground != NullFC)
vredViewport->setBackground(skyBackground);
else if (oldBackground != NullFC)
vredViewport->setBackground(oldBackground);
endEditCP(vredViewport);
enableCheckBox->setChecked(checked); // for scripting
}
void OpenSGWidget::initializeGL()
{
pwin->init();
// create a gradient background.
GradientBackgroundPtr gback = GradientBackground::create();
beginEditCP(gback, GradientBackground::LineFieldMask);
gback->clearLines();
gback->addLine(Color3f(0.7, 0.7, 0.8), 0);
gback->addLine(Color3f(0.0, 0.1, 0.3), 1);
endEditCP(gback, GradientBackground::LineFieldMask);
beginEditCP(pwin);
for(int i=0;i<pwin->getPort().size();++i)
{
ViewportPtr vp = pwin->getPort()[i];
beginEditCP(vp);
vp->setBackground(gback);
endEditCP(vp);
}
endEditCP(pwin);
_initialized = true;
}
void SkyBackgroundPluginForm::setupSkyBackground( const QDir dir, const bool zUp )
{
try
{
skyBackground = NullFC;
bool imageLoaded[6] = {false, false, false, false, false, false};
const QFileInfoList* fileList = dir.entryInfoList();
QFileInfoListIterator it(*fileList);
QFileInfo* fileInfo;
while ((fileInfo = it.current()) != 0)
{
QString qstr = fileInfo->absFilePath();
const char *filename = qstr.latin1();
if (((qstr.find("north") >= 0) || (qstr.find("front") >= 0)) && !imageLoaded[0])
{
beginEditCP(images[5]);
if (images[5]->read(filename))
{
beginEditCP(textures[5]);
textures[5]->setImage(images[5]);
endEditCP(textures[5]);
vrLog::info("Sky Background: Front/North image loaded.");
imageLoaded[0] = true;
}
endEditCP(images[5]);
}
if (((qstr.find("south") >= 0) || (qstr.find("back") >= 0)) && !imageLoaded[1])
{
beginEditCP(images[4]);
if (images[4]->read(filename))
{
if (zUp)
vrImage::rotateImage180Degrees(images[4]);
beginEditCP(textures[4]);
textures[4]->setImage(images[4]);
endEditCP(textures[4]);
vrLog::info("Sky Background: Back/South image loaded.");
imageLoaded[1] = true;
}
endEditCP(images[4]);
}
if (((qstr.find("down") >= 0) || (qstr.find("bottom") >= 0)) && !imageLoaded[2])
{
beginEditCP(images[3]);
if (images[3]->read(filename))
{
beginEditCP(textures[3]);
textures[3]->setImage(images[3]);
endEditCP(textures[3]);
vrLog::info("Sky Background: Bottom/Down image loaded.");
imageLoaded[2] = true;
}
endEditCP(images[3]);
}
if (((qstr.find("up") >= 0) || (qstr.find("top") >= 0)) && !imageLoaded[3])
{
beginEditCP(images[2]);
if (images[2]->read(filename))
{
if (zUp)
vrImage::rotateImage180Degrees(images[2]);
beginEditCP(textures[2]);
textures[2]->setImage(images[2]);
endEditCP(textures[2]);
vrLog::info("Sky Background: Top/Up image loaded.");
imageLoaded[3] = true;
}
endEditCP(images[2]);
}
if (((qstr.find("east") >= 0) || (qstr.find("right") >= 0)) && !imageLoaded[4])
{
beginEditCP(images[1]);
if (images[1]->read(filename))
{
if (zUp)
vrImage::rotate90Left(images[1]);
beginEditCP(textures[1]);
textures[1]->setImage(images[1]);
endEditCP(textures[1]);
vrLog::info("Sky Background: Right/East image loaded.");
imageLoaded[4] = true;
}
endEditCP(images[1]);
}
if (((qstr.find("west") >= 0) || (qstr.find("left") >= 0)) && !imageLoaded[5])
{
beginEditCP(images[0]);
if (images[0]->read(filename))
{
if (zUp)
vrImage::rotate90Right(images[0]);
beginEditCP(textures[0]);
textures[0]->setImage(images[0]);
endEditCP(textures[0]);
vrLog::info("Sky Background: Left/West image loaded.");
imageLoaded[5] = true;
}
endEditCP(images[0]);
}
++it;
}
skyBackground = SkyBackground::create();
beginEditCP(skyBackground);
if (!zUp)
{
skyBackground->setFrontTexture(textures[5]);
skyBackground->setBackTexture(textures[4]);
skyBackground->setBottomTexture(textures[3]);
skyBackground->setTopTexture(textures[2]);
skyBackground->setRightTexture(textures[1]);
skyBackground->setLeftTexture(textures[0]);
}
else
{
skyBackground->setFrontTexture(textures[3]);
skyBackground->setBackTexture(textures[2]);
skyBackground->setBottomTexture(textures[4]);
skyBackground->setTopTexture(textures[5]);
skyBackground->setRightTexture(textures[1]);
skyBackground->setLeftTexture(textures[0]);
}
endEditCP(skyBackground);
vrOSGWidget *gl = vrOSGWidget::getMGLW(-1);
ViewportPtr vredViewport = gl->getViewport();
//oldBackground = vredViewport->getBackground();
beginEditCP(vredViewport);
vredViewport->setBackground(skyBackground);
endEditCP(vredViewport);
directoryLineEdit->setText(dir.absPath());
// read light settings
if (SetLightingCheckBox->isChecked())
{
string lightName = LightNameLineEdit->text().ascii();
if (!QFile::exists(dir.absPath() + "/LightSettings.xml"))
vrLog::warning("Light Settings not found.");
else
{
QFile* file = new QFile(dir.absPath() + "/LightSettings.xml");
if (file->open(IO_ReadOnly))
{
LightSettingsHandler handler;
QXmlSimpleReader reader;
reader.setContentHandler(&handler);
reader.setErrorHandler(&handler);
QXmlInputSource source(file);
reader.parse(source);
file->close();
handler.direction.normalize();
vector<NodePtr> lights;
vrLights::getLights(lights);
bool lightSet = false;
for (vector<NodePtr>::const_iterator it = lights.begin();
it != lights.end(); ++it)
{
LightPtr light = LightPtr::dcast((*it)->getCore());
if (light != NullFC)
{
NodePtr node = *it;
string name = getName(node);
if (name.find(lightName) != string::npos)
{
setLightSettings(light, handler);
lightSet = true;
}
}
}
if (!lightSet)
{
NodePtr rootNode = vrScenegraph::getRoot();
TransformPtr beaconTransform = Transform::create();
NodePtr beaconNode = Node::create();
beginEditCP(beaconNode);
beaconNode->setCore(beaconTransform);
endEditCP(beaconNode);
PointLightPtr light = PointLight::create();
beginEditCP(light);
light->setAttenuation(1,0,0);
light->setBeacon(beaconNode);
endEditCP(light);
NodePtr lightNode = Node::create();
beginEditCP(lightNode);
lightNode->setCore(light);
endEditCP(lightNode);
OSG::setName(lightNode, lightName);
beginEditCP(rootNode);
rootNode->addChild(lightNode);
rootNode->addChild(beaconNode);
endEditCP(rootNode);
setLightSettings(light, handler);
vrScenegraph::update(true);
}
}
}
}
}
catch (std::exception const& e)
{
cout << "type: " << typeid(e).name() << endl;
cout << "message: " << e.what() << endl << endl;
}
}
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);
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;
}
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);
}
}
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);
}
}
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)
{
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;
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// GLUT init
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
int winid = glutCreateWindow("OpenSG CGFX Shader");
// the connection between GLUT and OpenSG
_gwin = GLUTWindow::create();
_gwin->setId(winid);
_gwin->setSize( 800, 800 );
_gwin->init();
// init callbacks
glutSetWindow(winid);
glutReshapeFunc(reshape);
glutDisplayFunc(display);
glutIdleFunc(display);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutKeyboardFunc(keyboard);
const char *effectFile = "BumpGlossedShiny.fx";
if(argc > 1)
{
effectFile = argv[1];
}
_cgfxmat = CGFXMaterial::create();
beginEditCP(_cgfxmat);
_cgfxmat->setEffectFile(effectFile);
// this multipass technique leads to a render bug, I have no idea what's wrong :-(
//_cgfxmat->setTechnique(1);
endEditCP(_cgfxmat);
ChunkMaterialPtr mat2 = ChunkMaterial::create();
MaterialChunkPtr matc = MaterialChunk::create();
beginEditCP(matc);
matc->setDiffuse(Color4f(1, 0, 0, 1));
endEditCP(matc);
beginEditCP(mat2);
mat2->addChunk(matc);
//mat2->addChunk(texc);
endEditCP(mat2);
// create root node
_scene = Node::create();
GeometryPtr geo1 = makeLatLongSphereGeo(50, 50, 1.0f);
OSG::calcVertexTangents(geo1, 0, Geometry::TexCoords1FieldId, Geometry::TexCoords2FieldId);
beginEditCP( geo1, Geometry::MaterialFieldMask);
geo1->setMaterial(_cgfxmat);
endEditCP(geo1, Geometry::MaterialFieldMask);
NodePtr sphere1 = Node::create();
beginEditCP(sphere1, Node::CoreFieldMask);
sphere1->setCore(geo1);
endEditCP(sphere1, Node::CoreFieldMask);
TransformPtr trans1 = Transform::create();
beginEditCP(trans1);
trans1->getMatrix().setTranslate(-2 , 0, 0);
endEditCP(trans1);
NodePtr transn1 = Node::create();
beginEditCP(transn1);
transn1->setCore(trans1);
transn1->addChild(sphere1);
beginEditCP(transn1);
//
GeometryPtr geo2 = makeLatLongSphereGeo(50, 50, 1.0f);
beginEditCP( geo2, Geometry::MaterialFieldMask);
geo2->setMaterial(mat2);
endEditCP(geo2, Geometry::MaterialFieldMask);
NodePtr sphere2 = Node::create();
beginEditCP(sphere2, Node::CoreFieldMask);
sphere2->setCore(geo2);
endEditCP(sphere2, Node::CoreFieldMask);
TransformPtr trans2 = Transform::create();
beginEditCP(trans2);
trans2->getMatrix().setTranslate(2 , 0, 0);
endEditCP(trans2);
NodePtr transn2 = Node::create();
beginEditCP(transn2);
transn2->setCore(trans2);
transn2->addChild(sphere2);
beginEditCP(transn2);
beginEditCP(_scene);
_scene->setCore(Group::create());
_scene->addChild(transn1);
_scene->addChild(transn2);
endEditCP(_scene);
// create the SimpleSceneManager
_mgr = new SimpleSceneManager;
// tell the manager what to manage
_mgr->setWindow(_gwin);
_mgr->setRoot(_scene);
// show the whole scene
_mgr->showAll();
// create a gradient background.
GradientBackgroundPtr gback = GradientBackground::create();
beginEditCP(gback, GradientBackground::LineFieldMask);
gback->clearLines();
gback->addLine(Color3f(0.7, 0.7, 0.8), 0);
gback->addLine(Color3f(0.0, 0.1, 0.3), 1);
endEditCP(gback, GradientBackground::LineFieldMask);
WindowPtr win = _mgr->getWindow();
beginEditCP(win);
for(int i=0;i<win->getPort().size();++i)
{
ViewportPtr vp = win->getPort()[i];
beginEditCP(vp);
vp->setBackground(gback);
endEditCP(vp);
}
endEditCP(win);
// GLUT main loop
glutMainLoop();
return 0;
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// GLUT init
int winid = setupGLUT(&argc, argv);
// the connection between GLUT and OpenSG
GLUTWindowPtr gwin = GLUTWindow::create();
beginEditCP(gwin);
gwin->setId(winid);
gwin->setSize( 800, 800 );
gwin->init();
endEditCP(gwin);
// create root node
_scene = makeCoredNode<Group>();
GeometryPtr geo = makeBoxGeo(0.5, 0.5, 0.5, 1, 1, 1);
// share the chunk
CGChunkPtr cg = CGChunk::create();
beginEditCP(cg);
cg->setVertexProfile(CG_PROFILE_ARBVP1);
cg->setVertexProgram(_vp_program);
cg->setFragmentProfile(CG_PROFILE_ARBFP1);
cg->setFragmentProgram(_fp_program);
endEditCP(cg);
Int32 size = 4;
// start color
Vec3f sc(0.0, 0.0, 0.0);
// end color
Vec3f ec(1.0, 1.0, 1.0);
Real32 sr = (ec[0] - sc[0]) / Real32((size*2));
Real32 sg = (ec[1] - sc[1]) / Real32((size*2));
Real32 sb = (ec[2] - sc[2]) / Real32((size*2));
Vec3f color(sc);
Int32 x = - size;
Int32 y = - size;
Int32 z = - size;
UInt32 iterations = size*2 * size*2 * size*2;
printf("Creating %u cubes ...\n", iterations);
for(UInt32 i=0;i<iterations;++i)
{
ChunkMaterialPtr cmat = ChunkMaterial::create();
// ok use one CGChunk and n CGParameterChunks
CGParameterChunkPtr cgparameter = CGParameterChunk::create();
beginEditCP(cgparameter);
cgparameter->setCGChunk(cg);
cgparameter->setUniformParameter("SurfaceColor", color);
endEditCP(cgparameter);
_cgparameter = cgparameter;
beginEditCP(cmat);
cmat->addChunk(cg);
cmat->addChunk(cgparameter);
endEditCP(cmat);
TransformPtr trans;
NodePtr trans_node = makeCoredNode<Transform>(&trans);
beginEditCP(trans);
trans->getMatrix().setTranslate(Real32(x), Real32(y), Real32(z));
endEditCP(trans);
MaterialGroupPtr mg;
NodePtr mg_node = makeCoredNode<MaterialGroup>(&mg);
beginEditCP(mg, MaterialGroup::MaterialFieldMask);
mg->setMaterial(cmat);
endEditCP(mg, MaterialGroup::MaterialFieldMask);
NodePtr geonode = Node::create();
beginEditCP(geonode, Node::CoreFieldMask);
geonode->setCore(geo);
endEditCP(geonode, Node::CoreFieldMask);
beginEditCP(mg_node);
mg_node->addChild(geonode);
endEditCP(mg_node);
beginEditCP(trans_node);
trans_node->addChild(mg_node);
endEditCP(trans_node);
// add to scene
beginEditCP(_scene);
_scene->addChild(trans_node);
endEditCP(_scene);
// ----
++x;
color[0] += sr;
if(x == size)
{
x = - size;
++y;
color[0] = sc[0];
color[1] += sg;
if(y == size)
{
y = - size;
++z;
color[1] = sc[1];
color[2] += sb;
}
}
}
// create the SimpleSceneManager helper
_mgr = new SimpleSceneManager;
// tell the manager what to manage
_mgr->setWindow(gwin );
_mgr->setRoot(_scene);
// show the whole scene
_mgr->showAll();
// create a gradient background.
GradientBackgroundPtr gback = GradientBackground::create();
beginEditCP(gback, GradientBackground::LineFieldMask);
gback->clearLines();
gback->addLine(Color3f(0.7, 0.7, 0.8), 0);
gback->addLine(Color3f(0.0, 0.1, 0.3), 1);
endEditCP(gback, GradientBackground::LineFieldMask);
WindowPtr win = _mgr->getWindow();
beginEditCP(win);
for(int i=0;i<win->getPort().size();++i)
{
ViewportPtr vp = win->getPort()[i];
beginEditCP(vp);
vp->setBackground(gback);
endEditCP(vp);
}
endEditCP(win);
// GLUT main loop
glutMainLoop();
return 0;
}
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_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;
}
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;
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
glutInit(&argc, argv);
osgInit(argc, argv);
std::string fontfile("testfont.ttf");
std::string testtext("Test Text");
UInt32 drawmode;
if(argc > 1)
testtext = argv[1];
if(argc > 2)
fontfile = argv[2];
if(argc < 4 || sscanf(argv[3], "%d", &drawmode) != 1 )
drawmode = FTGLFont::Outline;
// GLUT
int winid = setupGLUT(&argc, argv);
GLUTWindowPtr gwin= GLUTWindow::create();
gwin->setId(winid);
gwin->init();
// Create the Cubes node
NodePtr scene = makeCoredNode<Group>();
beginEditCP(scene);
scene->addChild( makeBox(200,200,200, 1,1,1) );
// scene->addChild( SceneFileHandler::the().read("tie.wrl") );
endEditCP(scene);
// Create the text
FTGLFontPtr font = FTGLFont::create();
beginEditCP(font);
font->setName(fontfile);
font->setDrawType(drawmode);
font->setSize(40);
font->setRes(72);
font->setDepth(20);
endEditCP(font);
FTGLTextPtr text;
NodePtr tnode = makeCoredNode<FTGLText>(&text);
beginEditCP(text);
text->setFont(font);
text->setText(testtext);
text->setPosition(Pnt3f(0,300,0));
text->setMaterial(getDefaultMaterial());
endEditCP(text);
beginEditCP(scene);
scene->addChild(tnode);
endEditCP(scene);
// create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// tell the manager what to manage
mgr->setWindow(gwin );
mgr->setRoot (scene);
// show the whole scene
mgr->showAll();
// copy to second window
int winid2 = setupGLUT(&argc, argv);
gwin2= GLUTWindow::create();
gwin2->setId(winid2);
gwin2->init();
ViewportPtr ovp = gwin->getPort()[0];
ViewportPtr vp = Viewport::create();
beginEditCP(vp);
vp->setLeft(0);
vp->setRight(400);
vp->setBottom(0);
vp->setTop(400);
vp->setCamera(ovp->getCamera());
vp->setRoot(ovp->getRoot());
vp->setBackground(ovp->getBackground());
vp->setParent(gwin2);
endEditCP(vp);
beginEditCP(gwin2);
gwin2->getPort().push_back(vp);
endEditCP(gwin2);
// GLUT main loop
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;
}
