int init(int argc, char **argv)
{
OSG::osgInit(argc,argv);
// GLUT init
glutInit(&argc, argv);
glutInitDisplayMode( GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE);
int winid = glutCreateWindow("OpenSG");
glutKeyboardFunc(key);
glutVisibilityFunc(vis);
glutReshapeFunc(reshape);
glutDisplayFunc(display);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutIdleFunc(display);
// glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
// glEnable( GL_DEPTH_TEST );
// glEnable( GL_LIGHTING );
// glEnable( GL_LIGHT0 );
// glFrontFace(GL_CW);
glEnable(GL_CULL_FACE);
// OSG
OSG::SceneFileHandler::the()->print();
// create the graph
// beacon for camera and light
OSG::NodeUnrecPtr b1n = OSG::Node::create();
OSG::GroupUnrecPtr b1 = OSG::Group::create();
b1n->setCore( b1 );
// transformation
OSG::NodeUnrecPtr t1n = OSG::Node::create();
OSG::TransformUnrecPtr t1 = OSG::Transform::create();
t1n->setCore( t1 );
t1n->addChild( b1n );
cam_trans = t1;
// light
OSG::NodeUnrecPtr dlight = OSG::Node::create();
OSG::DirectionalLightUnrecPtr dl = OSG::DirectionalLight::create();
dlight->setCore( dl );
// dlight->setCore( Group::create() );
dl->setAmbient( .0, .0, .0, 1 );
dl->setDiffuse( .8f, .8f, .8f, 1.f );
dl->setDirection(0,0,1);
dl->setBeacon( b1n);
// root
root = OSG::Node::create();
OSG::GroupUnrecPtr gr1 = OSG::Group::create();
root->setCore( gr1 );
root->addChild( t1n );
root->addChild( dlight );
// Load the file
OSG::NodeUnrecPtr file = NULL;
if(argc > 1)
file = OSG::SceneFileHandler::the()->read(argv[1], NULL);
if ( file == NULL )
{
std::cerr << "Couldn't load file, ignoring" << std::endl;
file = OSG::makeSphere(4, 2.0);
}
#if 0
OSG::GeometryPtr pGeo = cast_dynamic<OSG::GeometryPtr>(file->getCore());
if(pGeo == NULL && file->getNChildren() != 0)
{
pGeo = cast_dynamic<OSG::GeometryPtr>(file->getChild(0)->getCore());
}
if(pGeo == NULL)
{
fprintf(stderr, "no geo\n");
}
#endif
// OSG::GraphOpRefPtr op = OSG::GraphOpFactory::the()->create("Stripe");
// op->traverse(file);
// createOptimizedPrimitives(pGeo);
// createSharedIndex(pGeo);
OSG::Thread::getCurrentChangeList()->commitChanges();
// file->dump();
file->updateVolume();
#if 0
const char *outFileName = "/tmp/foo1.osg";
OSG::IndentFileOutStream outFileStream(outFileName);
if( !outFileStream )
{
std::cerr << "Can not open output stream to file: "
<< outFileName << std::endl;
return -1;
}
std::cerr << "STARTING PRINTOUT:" << std::endl;
OSGWriter writer( outFileStream, 4 );
writer.write( file );
outFileStream.close();
OSG::SceneFileHandler::the()->write(file, "/tmp/foo.osb");
#endif
// return 0;
OSG::Vec3f min,max;
file->getVolume().getBounds( min, max );
std::cout << "Volume: from " << min << " to " << max << std::endl;
OSG::MultiCoreUnrecPtr pMCore = OSG::MultiCore::create();
pCOver = OSG::ChunkOverrideGroup::create();
scene_trans = OSG::Transform::create();
pMCore->addCore(scene_trans);
pMCore->addCore(pCOver );
OSG::NodeUnrecPtr sceneTrN = OSG::Node::create();
sceneTrN->setCore(pMCore);
sceneTrN->addChild(file);
dlight->addChild(sceneTrN);
std::cerr << "Tree: " << std::endl;
// root->dump();
// Camera
cam = OSG::PerspectiveCamera::create();
cam->setBeacon( b1n );
cam->setFov( OSG::osgDegree2Rad( 90 ) );
cam->setNear( 0.1f );
cam->setFar( 100000 );
// Background
OSG::SolidBackgroundUnrecPtr bkgnd = OSG::SolidBackground::create();
bkgnd->setColor(OSG::Color3f(1,0,0));
// Viewport
vp = OSG::Viewport::create();
vp->setCamera( cam );
vp->setBackground( bkgnd );
vp->setRoot( root );
vp->setSize( 0,0, 1,1 );
#if 0
OSG::UInt8 imgdata[] =
{
64,64,64, 128,128,128, 192,192,192, 255,255,255
};
#endif
pImg = OSG::Image::create();
pImg->set(OSG::Image::OSG_RGB_PF, 128, 128); //, 1, 1, 1, 0.0, imgdata);
tx1o = OSG::TextureObjChunk::create();
tx1e = OSG::TextureEnvChunk::create();
tx1o->setImage (pImg );
tx1o->setMinFilter(GL_LINEAR );
tx1o->setMagFilter(GL_LINEAR );
tx1o->setWrapS (GL_CLAMP );
tx1o->setWrapT (GL_CLAMP );
tx1e->setEnvMode (GL_REPLACE);
OSG::SimpleMaterialUnrecPtr mat = OSG::SimpleMaterial::create();
mat->setDiffuse(OSG::Color3f(1,1,1));
mat->setLit (false );
mat->addChunk (tx1o );
mat->addChunk (tx1e );
OSG::PolygonForegroundUnrecPtr pFG = OSG::PolygonForeground::create();
pFG->setMaterial(mat);
OSG::MFPnt2f *pPos = pFG->editMFPositions();
OSG::MFVec3f *pTex = pFG->editMFTexCoords();
pPos->push_back(OSG::Pnt2f(0.0f, 0.0f));
pPos->push_back(OSG::Pnt2f(0.3f, 0.0f));
pPos->push_back(OSG::Pnt2f(0.3f, 0.3f));
pPos->push_back(OSG::Pnt2f(0.0f, 0.3f));
pTex->push_back(OSG::Vec3f(0.0f, 1.0f, 0.0f));
pTex->push_back(OSG::Vec3f(1.0f, 1.0f, 0.0f));
pTex->push_back(OSG::Vec3f(1.0f, 0.0f, 0.0f));
pTex->push_back(OSG::Vec3f(0.0f, 0.0f, 0.0f));
vp->addForeground(pFG);
OSG::SimpleMaterialUnrecPtr matFgCheck = OSG::SimpleMaterial::create();
matFgCheck->setDiffuse(OSG::Color3f(0,1,0));
matFgCheck->setLit (false );
OSG::PolygonForegroundUnrecPtr pFGCheck = OSG::PolygonForeground::create();
pFGCheck->setMaterial(matFgCheck);
pPos = pFGCheck->editMFPositions();
pPos->push_back(OSG::Pnt2f(0.6f, 0.0f));
pPos->push_back(OSG::Pnt2f(0.9f, 0.0f));
pPos->push_back(OSG::Pnt2f(0.9f, 0.3f));
pPos->push_back(OSG::Pnt2f(0.6f, 0.3f));
vp->addForeground(pFG);
vp->addForeground(pFGCheck);
// vp->dump();
// Background
OSG::SolidBackgroundUnrecPtr bkgndFBO = OSG::SolidBackground::create();
bkgndFBO->setColor(OSG::Color3f(1.0,0.5,0.5));
// Viewport
vpFBO = OSG::FBOViewport::create();
vpFBO->setCamera (cam );
vpFBO->setBackground(bkgndFBO );
vpFBO->setRoot (root );
vpFBO->setSize (0, 0, 1, 1);
vpFBO->addForeground(pFGCheck);
OSG::FrameBufferObjectUnrecPtr pFBO = OSG::FrameBufferObject::create();
pTexBuffer = OSG::TextureBuffer::create();
OSG::RenderBufferUnrecPtr pDepthBuffer = OSG::RenderBuffer ::create();
pDepthBuffer->setInternalFormat(GL_DEPTH_COMPONENT24 );
pTexBuffer->setTexture(tx1o);
pFBO->setSize(128, 128);
pFBO->setColorAttachment(pTexBuffer, 0);
pFBO->setDepthAttachment(pDepthBuffer );
pFBO->editMFDrawBuffers()->clear();
pFBO->editMFDrawBuffers()->push_back(GL_COLOR_ATTACHMENT0_EXT);
vpFBO->setFrameBufferObject(pFBO);
// Window
std::cout << "GLUT winid: " << winid << std::endl;
GLint glvp[4];
glGetIntegerv( GL_VIEWPORT, glvp );
gwin = OSG::GLUTWindow::create();
gwin->setGlutId(winid);
gwin->setSize( glvp[2], glvp[3] );
win = gwin;
win->addPort(vpFBO );
win->addPort(vp );
win->init();
// Action
rentravact = OSG::RenderAction::create();
// renact->setFrustumCulling(false);
// tball
OSG::Vec3f pos;
pos.setValues(min[0] + ((max[0] - min[0]) * 0.5),
min[1] + ((max[1] - min[1]) * 0.5),
max[2] + ( max[2] - min[2] ) * 1.5 );
float scale = (max[2] - min[2] + max[1] - min[1] + max[0] - min[0]) / 6;
OSG::Pnt3f tCenter(min[0] + (max[0] - min[0]) / 2,
min[1] + (max[1] - min[1]) / 2,
min[2] + (max[2] - min[2]) / 2);
fprintf(stderr, "Startpos : %f %f %f\n", pos[0], pos[1], pos[2]);
tball.setMode( OSG::Trackball::OSGObject );
tball.setStartPosition( pos, true );
tball.setSum( true );
tball.setTranslationMode( OSG::Trackball::OSGFree );
tball.setTranslationScale(scale);
tball.setRotationCenter(tCenter);
// run...
pPoly = OSG::PolygonChunk::create();
pCOver->subChunk(pPoly);
return 0;
}
// Initialize GLUT & OpenSG and set up the scene
int doMain(int argc, char **argv)
{
// OSG init
OSG::osgInit(argc,argv);
// GLUT init
int winid = setupGLUT(&argc, argv);
// the connection between GLUT and OpenSG
OSG::GLUTWindowUnrecPtr gwin = OSG::GLUTWindow::create();
gwin->setGlutId(winid);
gwin->setSize( 800, 800 );
gwin->init();
// create root node
_scene = OSG::makeCoredNode<OSG::Group>();
OSG::GeometryUnrecPtr geo = OSG::makeBoxGeo(0.5, 0.5, 0.5, 1, 1, 1);
// share the chunk
OSG::SimpleSHLChunkUnrecPtr shl = OSG::SimpleSHLChunk::create();
shl->setVertexProgram(_vp_program);
shl->setFragmentProgram(_fp_program);
// These parameters are the same for all geometries so we
// keep them in here.
shl->addUniformVariable("Scale", OSG::Vec2f(20.0f, 20.0f));
shl->addUniformVariable("Threshold", OSG::Vec2f(0.7f, 0.7f));
OSG::Int32 size = 4;
// start color
OSG::Vec3f sc(0.0, 0.0, 0.0);
// end color
OSG::Vec3f ec(1.0, 1.0, 1.0);
OSG::Real32 sr = (ec[0] - sc[0]) / OSG::Real32((size*2));
OSG::Real32 sg = (ec[1] - sc[1]) / OSG::Real32((size*2));
OSG::Real32 sb = (ec[2] - sc[2]) / OSG::Real32((size*2));
OSG::Vec3f color(sc);
OSG::Int32 x = - size;
OSG::Int32 y = - size;
OSG::Int32 z = - size;
OSG::UInt32 iterations = size*2 * size*2 * size*2;
printf("Creating %u cubes ...\n", iterations);
for(OSG::UInt32 i=0; i<iterations; ++i)
{
OSG::ChunkMaterialUnrecPtr cmat = OSG::ChunkMaterial::create();
// ok use one SHLChunk and n SHLParameterChunks
// Assing a different "SurfaceColor" parameter to each geometry.
OSG::SimpleSHLVariableChunkUnrecPtr shlparameter =
OSG::SimpleSHLVariableChunk::create();
// shlparameter->setSHLChunk(shl);
shlparameter->addUniformVariable("SurfaceColor", color);
_shlparameter = shlparameter;
cmat->addChunk(shl);
cmat->addChunk(shlparameter);
OSG::TransformUnrecPtr trans;
OSG::NodeUnrecPtr trans_node =
OSG::makeCoredNode<OSG::Transform>(&trans);
trans->editMatrix().setTranslate(OSG::Real32(x),
OSG::Real32(y),
OSG::Real32(z));
OSG::MaterialGroupUnrecPtr mg;
OSG::NodeUnrecPtr mg_node = OSG::makeCoredNode<OSG::MaterialGroup>(&mg);
mg->setMaterial(cmat);
OSG::NodeUnrecPtr geonode = OSG::Node::create();
geonode->setCore(geo);
mg_node->addChild(geonode);
trans_node->addChild(mg_node);
// add to scene
_scene->addChild(trans_node);
// ----
++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 = OSG::SimpleSceneManager::create();
// tell the manager what to manage
_mgr->setWindow(gwin );
_mgr->setRoot(_scene);
// show the whole scene
_mgr->showAll();
// create a gradient background.
OSG::GradientBackgroundUnrecPtr gback = OSG::GradientBackground::create();
gback->clearLines();
gback->addLine(OSG::Color3f(0.7f, 0.7f, 0.8f), 0);
gback->addLine(OSG::Color3f(0.0f, 0.1f, 0.3f), 1);
OSG::Window *win = _mgr->getWindow();
for(unsigned int i=0; i<win->getMFPort()->size(); ++i)
{
OSG::Viewport *vp = win->getPort(i);
vp->setBackground(gback);
}
return 0;
}
// Initialize GLUT & OpenSG and set up the scene
int doMain(int argc, char **argv)
{
printf("Press key '1', '2', or '3' to toggle the light sources.\n");
// OSG init
OSG::osgInit(argc,argv);
// GLUT init
int winid = setupGLUT(&argc, argv);
// the connection between GLUT and OpenSG
OSG::GLUTWindowUnrecPtr gwin = OSG::GLUTWindow::create();
gwin->setGlutId(winid);
gwin->setSize( 800, 800 );
gwin->init();
// Create the shader material
OSG::ChunkMaterialUnrecPtr cmat = OSG::ChunkMaterial::create();
OSG::MaterialChunkUnrecPtr matc = OSG::MaterialChunk::create();
matc->setAmbient(OSG::Color4f(0.1, 0.1, 0.1, 1.0));
matc->setDiffuse(OSG::Color4f(0.3, 0.3, 0.3, 1.0));
matc->setSpecular(OSG::Color4f(0.8, 0.8, 0.8, 1.0));
matc->setShininess(100);
matc->setLit(true);
OSG::SHLChunkUnrecPtr shl = OSG::SHLChunk::create();
shl->setVertexProgram(_vp_program);
shl->setFragmentProgram(_fp_program);
shl->addParameterCallback("OSGL0SpecialParameter", light0Active);
shl->addParameterCallback("OSGL1SpecialParameter", light1Active);
shl->addParameterCallback("OSGL2SpecialParameter", light2Active);
cmat->addChunk(matc);
cmat->addChunk(shl);
// create root node
_scene = OSG::Node::create();
// create two light sources.
OSG::TransformUnrecPtr point1_trans;
OSG::NodeUnrecPtr point1 = OSG::makeCoredNode<OSG::PointLight>(&_point1_core);
point1_beacon = OSG::makeCoredNode<OSG::Transform >(&point1_trans);
point1_trans->editMatrix().setTranslate(-10.0, 5.0, 5.0);
_point1_core->setAmbient(0.0f, 0.0f, 0.0f , 1.0f);
_point1_core->setDiffuse(1.0f, 0.0f, 0.0f, 1.0f);
_point1_core->setSpecular(1.0f, 1.0f, 1.0f, 1.0f);
_point1_core->setBeacon(point1_beacon);
_point1_core->setOn(true);
OSG::TransformUnrecPtr point2_trans;
OSG::NodeUnrecPtr point2 = OSG::makeCoredNode<OSG::PointLight>(&_point2_core);
point2_beacon = OSG::makeCoredNode<OSG::Transform >(&point2_trans);
point2_trans->editMatrix().setTranslate(10.0, 5.0, 5.0);
_point2_core->setAmbient(0.0f, 0.0f, 0.0f, 1.0f);
_point2_core->setDiffuse(0.0f, 1.0f, 0.0f, 1.0f);
_point2_core->setSpecular(1.0f, 1.0f, 1.0f, 1.0f);
_point2_core->setBeacon(point2_beacon);
_point2_core->setOn(true);
point1->addChild(point2);
OSG::TransformUnrecPtr point3_trans;
OSG::NodeUnrecPtr point3 = OSG::makeCoredNode<OSG::PointLight>(&_point3_core);
point3_beacon = OSG::makeCoredNode<OSG::Transform >(&point3_trans);
point3_trans->editMatrix().setTranslate(0.0, -12.0, 5.0);
_point3_core->setAmbient(0.0f, 0.0f, 0.0f, 1.0f);
_point3_core->setDiffuse(0.5f, 0.0f, 1.0f, 1.0f);
_point3_core->setSpecular(1.0f, 1.0f, 1.0f, 1.0f);
_point3_core->setBeacon(point3_beacon);
_point3_core->setOn(true);
point2->addChild(point3);
// create a sphere.
OSG::GeometryUnrecPtr geo = OSG::makeLatLongSphereGeo (100, 100, 1.0);
geo->setMaterial(cmat);
OSG::NodeUnrecPtr sphere = OSG::makeNodeFor(geo);
point3->addChild(sphere);
_scene->setCore(OSG::Group::create());
_scene->addChild(point1);
// create the SimpleSceneManager helper
_mgr = new OSG::SimpleSceneManager;
// tell the manager what to manage
_mgr->setWindow(gwin );
_mgr->setRoot(_scene);
_mgr->turnHeadlightOff();
// show the whole scene
_mgr->showAll();
// enable local lights.
OSG::RenderAction *ract = dynamic_cast<OSG::RenderAction *>(_mgr->getRenderAction());
// ract->setLocalLights(true);
return 0;
}
// Initialize GLUT & OpenSG and set up the scene
int doMain(int argc, char **argv)
{
// OSG init
OSG::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 = OSG::GLUTWindow::create();
_gwin->setGlutId(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 = "blinn_bump_reflect.vinstruct.cgfx";
if(argc > 1)
{
effectFile = argv[1];
}
_cgfxmat = OSG::CgFXMaterial::create();
_cgfxmat->setEffectFile(effectFile);
// this multipass technique leads to a render bug,
// I have no idea what's wrong :-(
//_cgfxmat->setTechnique(1);
OSG::ChunkMaterialUnrecPtr mat2 = OSG::ChunkMaterial::create();
OSG::MaterialChunkUnrecPtr matc = OSG::MaterialChunk::create();
matc->setDiffuse(OSG::Color4f(1, 0, 0, 1));
mat2->addChunk(matc);
//mat2->addChunk(texc);
// create root node
_scene = OSG::Node::create();
OSG::GeometryUnrecPtr geo1 = OSG::makeLatLongSphereGeo(50, 50, 2.0f);
OSG::calcVertexTangents(geo1,
0,
OSG::Geometry::TexCoords6Index,
OSG::Geometry::TexCoords7Index);
geo1->setMaterial(_cgfxmat);
OSG::NodeUnrecPtr sphere1 = OSG::Node::create();
sphere1->setCore(geo1);
OSG::TransformUnrecPtr trans1 = OSG::Transform::create();
trans1->editMatrix().setTranslate(-2 , 0, 0);
OSG::NodeUnrecPtr transn1 = OSG::Node::create();
transn1->setCore(trans1);
transn1->addChild(sphere1);
//
OSG::GeometryUnrecPtr geo2 = OSG::makeLatLongSphereGeo(50, 50, 1.0f);
geo2->setMaterial(mat2);
OSG::NodeUnrecPtr sphere2 = OSG::Node::create();
sphere2->setCore(geo2);
OSG::TransformUnrecPtr trans2 = OSG::Transform::create();
trans2->editMatrix().setTranslate(2 , 0, 0);
OSG::NodeUnrecPtr transn2 = OSG::Node::create();
transn2->setCore(trans2);
transn2->addChild(sphere2);
_scene->setCore (OSG::Group::create());
_scene->addChild(transn1 );
_scene->addChild(transn2 );
// create the SimpleSceneManager
_mgr = new OSG::SimpleSceneManager;
// tell the manager what to manage
_mgr->setWindow(_gwin);
_mgr->setRoot(_scene);
// show the whole scene
_mgr->showAll();
// create a gradient background.
OSG::GradientBackgroundUnrecPtr gback = OSG::GradientBackground::create();
gback->clearLines();
gback->addLine(OSG::Color3f(0.7, 0.7, 0.8), 0);
gback->addLine(OSG::Color3f(0.0, 0.1, 0.3), 1);
OSG::Window *win = _mgr->getWindow();
for(OSG::UInt32 i = 0; i < win->getMFPort()->size(); ++i)
{
OSG::Viewport *vp = win->getPort(i);
vp->setBackground(gback);
}
return 0;
}
int doMain (int argc, char **argv)
{
OSG::osgInit(argc,argv);
// GLUT init
glutInit(&argc, argv);
glutInitDisplayMode( GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE);
glutInitWindowSize(800, 800);
int winid = glutCreateWindow("OpenSG");
glutKeyboardFunc(key);
glutVisibilityFunc(vis);
glutReshapeFunc(reshape);
glutDisplayFunc(display);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutIdleFunc(display);
// OSG
OSG::SceneFileHandler::the()->print();
// create the graph
// beacon for camera and light
OSG::NodeUnrecPtr b1n = OSG::Node::create();
OSG::GroupUnrecPtr b1 = OSG::Group::create();
fprintf(stderr, "Create b1n %p %d %d \n",
b1n.get(),
b1n->getRefCount(),
b1n->getWeakRefCount());
b1n->setCore( b1 );
// transformation
OSG::NodeUnrecPtr t1n = OSG::Node::create();
OSG::TransformUnrecPtr t1 = OSG::Transform::create();
t1n->setCore (t1 );
t1n->addChild(b1n);
fprintf(stderr, "Create t1n %p %d %d \n",
t1n.get(),
t1n->getRefCount(),
t1n->getWeakRefCount());
cam_trans = t1;
// light
OSG::NodeUnrecPtr dlight = OSG::Node::create();
OSG::DirectionalLightUnrecPtr dl = OSG::DirectionalLight::create();
{
dlight->setCore(dl);
dl->setAmbient( .3f, .3f, .3f, 1 );
dl->setDiffuse( .8f, .8f, .8f, .8f );
dl->setDirection(0,0,1);
dl->setBeacon( b1n);
}
fprintf(stderr, "Create dlight %p %d %d \n",
dlight.get(),
dlight->getRefCount(),
dlight->getWeakRefCount());
hdrroot = OSG::Node::create();
hdrroot->editVolume().setInfinite();
hdrroot->editVolume().setStatic ();
hdrroot->setCore(OSG::Group::create());
// root
root = OSG::Node:: create();
OSG::GroupUnrecPtr gr1 = OSG::Group::create();
root->setCore(gr1);
hdrroot->addChild(root);
root->addChild(t1n );
root->addChild(dlight);
fprintf(stderr, "Create root %p %d %d \n",
root.get(),
root->getRefCount(),
root->getWeakRefCount());
// Load the file
OSG::NodeUnrecPtr file = NULL;
if(argc > 1)
{
file = OSG::SceneFileHandler::the()->read(argv[1], NULL);
}
if(file == NULL)
{
std::cerr << "Couldn't load file, ignoring" << std::endl;
// file = makeBox(2.f, 2.f, 2.f, 2, 2, 2);
file = OSG::makeSphere(4, 2.0);
}
OSG::NodeUnrecPtr pCubeRoot = OSG::Node::create();
OSG::CubeMapGeneratorUnrecPtr pCubeGen = OSG::CubeMapGenerator::create();
pCubeRoot->addChild(file);
pCubeRoot->setCore(pCubeGen);
// pCubeRoot->setCore(Group::create());
OSG::NodeUnrecPtr pCubeSceneRoot = OSG::Node::create();
OSG::VisitSubTreeUnrecPtr pCubeVisit = OSG::VisitSubTree::create();
pCubeSceneRoot->setCore(pCubeVisit);
pCubeVisit->setSubTreeRoot(root);
pCubeGen->setRoot (pCubeSceneRoot);
pCubeGen->setTextureFormat(GL_RGB32F_ARB );
pCubeGen->setSize (512,
512 );
pCubeGen->setTexUnit (3);
// Cubemap Background
OSG::SolidBackgroundUnrecPtr cubeBkgnd = OSG::SolidBackground::create();
{
cubeBkgnd->setColor(OSG::Color3f(0.5f, 0.3f, 0.3f));
}
pCubeGen->setBackground(cubeBkgnd);
OSG::NodeUnrecPtr pAnimRoot = setupAnim();
scene_trans = OSG::Transform::create();
OSG::NodeUnrecPtr sceneTrN = OSG::Node::create();
scene_trans->editMatrix()[3][2] = -50.f;
sceneTrN->setCore (scene_trans);
sceneTrN->addChild(pCubeRoot );
sceneTrN->addChild(pAnimRoot );
OSG::Thread::getCurrentChangeList()->commitChanges();
OSG::Vec3f min,max;
sceneTrN->updateVolume();
sceneTrN->getVolume().getBounds(min, max);
std::cout << "Volume: from " << min << " to " << max << std::endl;
dlight->addChild(sceneTrN);
// Camera
cam = OSG::PerspectiveCamera::create();
{
cam->setBeacon( b1n );
cam->setFov( OSG::osgDegree2Rad( 90 ) );
cam->setNear( 0.1f );
cam->setFar( 100000 );
}
// Background
OSG::SolidBackgroundUnrecPtr bkgnd = OSG::SolidBackground::create();
{
bkgnd->setColor(OSG::Color3f(0.3f, 0.3f, 0.3f));
}
// Viewport
vp = OSG::Viewport::create();
{
vp->setCamera( cam );
vp->setBackground( bkgnd );
vp->setRoot( hdrroot );
// vp->setRoot( root );
vp->setSize( 0,0, 1,1 );
}
// Window
OSG::GLUTWindowUnrecPtr gwin;
GLint glvp[4];
glGetIntegerv(GL_VIEWPORT, glvp);
gwin = OSG::GLUTWindow::create();
{
gwin->setGlutId(winid);
gwin->setSize( glvp[2], glvp[3] );
win = gwin;
win->addPort( vp );
win->init();
}
// Action
rentravact = OSG::RenderAction::create();
rentravact->setVolumeDrawing(true);
// rentravact->setFrustumCulling(false);
// tball
OSG::Vec3f pos;
pos.setValues(min[0] + ((max[0] - min[0]) * 0.5),
min[1] + ((max[1] - min[1]) * 0.5),
max[2] + ( max[2] - min[2] ) * 1.5 );
float scale = (max[2] - min[2] + max[1] - min[1] + max[0] - min[0]) / 6;
OSG::Pnt3f tCenter(min[0] + (max[0] - min[0]) / 2,
min[1] + (max[1] - min[1]) / 2,
min[2] + (max[2] - min[2]) / 2);
fprintf(stderr, "Startpos : %f %f %f\n", pos[0], pos[1], pos[2]);
tball.setMode (OSG::Trackball::OSGObject);
tball.setStartPosition (pos, true );
tball.setSum (true );
tball.setTranslationMode (OSG::Trackball::OSGFree );
tball.setTranslationScale(scale );
tball.setRotationCenter (tCenter );
fprintf(stderr, "Create b1n %p %d %d \n",
b1n.get(),
b1n->getRefCount(),
b1n->getWeakRefCount());
fprintf(stderr, "Create t1n %p %d %d \n",
t1n.get(),
t1n->getRefCount(),
t1n->getWeakRefCount());
fprintf(stderr, "Create dlight %p %d %d \n",
dlight.get(),
dlight->getRefCount(),
dlight->getWeakRefCount());
fprintf(stderr, "Create hdrroot %p %d %d \n",
hdrroot.get(),
hdrroot->getRefCount(),
hdrroot->getWeakRefCount());
fprintf(stderr, "Create root %p %d %d \n",
root.get(),
root->getRefCount(),
root->getWeakRefCount());
return 0;
}
int init(int argc, char **argv)
{
OSG::osgInit(argc,argv);
// GLUT init
glutInit(&argc, argv);
glutInitDisplayMode( GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE);
int winid = glutCreateWindow("OpenSG");
glutKeyboardFunc(key);
glutVisibilityFunc(vis);
glutReshapeFunc(reshape);
glutDisplayFunc(display);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutIdleFunc(display);
// OSG
OSG::SceneFileHandler::the()->print();
// create the graph
// beacon for camera and light
OSG::NodeUnrecPtr b1n = OSG::Node::create();
OSG::GroupUnrecPtr b1 = OSG::Group::create();
b1n->setCore(b1);
// transformation
OSG::NodeUnrecPtr t1n = OSG::Node::create();
OSG::TransformUnrecPtr t1 = OSG::Transform::create();
t1n->setCore (t1 );
t1n->addChild(b1n);
cam_trans = t1;
// light
OSG::NodeUnrecPtr dlight = OSG::Node::create();
OSG::DirectionalLightUnrecPtr dl = OSG::DirectionalLight::create();
dlight->setCore(dl);
dl->setAmbient (0.0, 0.0, 0.0, 1.0);
dl->setDiffuse (0.8, 0.8, 0.8, 1.0);
dl->setDirection(0.0, 0.0, 1.0 );
dl->setBeacon (b1n );
// root
OSG::NodeUnrecPtr root = OSG::Node::create();
OSG::GroupUnrecPtr gr1 = OSG::Group::create();
root->setCore (gr1 );
root->addChild(t1n );
root->addChild(dlight);
// Load the file
OSG::NodeUnrecPtr file = NULL;
if(argc > 1)
{
file = OSG::SceneFileHandler::the()->read(argv[1], NULL);
}
if(file == NULL)
{
std::cerr << "Couldn't load file, ignoring" << std::endl;
//file = OSG::makeSphere(4, 2.0);
file = OSG::Node::create();
OSG::AlgorithmStageUnrecPtr pStage = OSG::AlgorithmStage::create();
file->setCore(pStage);
pAlgo = OSG::GPUVolRTV2::create();
pStage->setAlgorithm(pAlgo);
// fix/freeze the node volume
file->editVolume().setStatic(true);
file->editVolume().setBounds( 0.f, 0.f, 0.f,
1.f, 1.f, 1.f);
}
OSG::commitChanges();
file->updateVolume();
OSG::Vec3f min,max;
file->getVolume().getBounds( min, max );
std::cout << "Volume: from " << min << " to " << max << std::endl;
OSG::MultiCoreUnrecPtr pMCore = OSG::MultiCore::create();
pCOver = OSG::ChunkOverrideGroup::create();
OSG::TransformRecPtr scene_trans = OSG::Transform::create();
pMCore->addCore(scene_trans);
pMCore->addCore(pCOver );
pPoly = OSG::PolygonChunk::create();
OSG::NodeUnrecPtr sceneTrN = OSG::Node::create();
sceneTrN->setCore (pMCore);
sceneTrN->addChild(file );
dlight->addChild(sceneTrN);
// Camera
OSG::PerspectiveCameraRecPtr cam = OSG::PerspectiveCamera::create();
cam->setBeacon(b1n );
cam->setFov (OSG::osgDegree2Rad(60));
cam->setNear (0.1 );
cam->setFar (400 );
// Background
OSG::SolidBackgroundUnrecPtr bkgnd = OSG::SolidBackground::create();
bkgnd->setColor(OSG::Color3f(0,0,0));
// Viewport
OSG::ViewportRecPtr vp = OSG::Viewport::create();
vp->setCamera (cam );
vp->setBackground(bkgnd );
vp->setRoot (root );
vp->setSize (0, 0, 1, 1);
// Window
std::cout << "GLUT winid: " << winid << std::endl;
GLint glvp[4];
glGetIntegerv(GL_VIEWPORT, glvp);
OSG::GLUTWindowUnrecPtr gwin = OSG::GLUTWindow::create();
gwin->setGlutId(winid);
gwin->setSize( glvp[2], glvp[3] );
win = gwin;
win->addPort(vp);
win->init();
// Action
rentravact = OSG::RenderAction::create();
// renact->setFrustumCulling(false);
// tball
OSG::Vec3f pos;
pos.setValues(min[0] + ((max[0] - min[0]) * 0.5),
min[1] + ((max[1] - min[1]) * 0.5),
max[2] + ( max[2] - min[2] ) * 1.5 );
float scale = (max[2] - min[2] + max[1] - min[1] + max[0] - min[0]) / 6;
OSG::Pnt3f tCenter(min[0] + (max[0] - min[0]) / 2,
min[1] + (max[1] - min[1]) / 2,
min[2] + (max[2] - min[2]) / 2);
fprintf(stderr, "Startpos : %f %f %f\n", pos[0], pos[1], pos[2]);
tball.setMode (OSG::Trackball::OSGObject);
tball.setStartPosition (pos, true );
tball.setSum (true );
tball.setTranslationMode (OSG::Trackball::OSGFree );
tball.setTranslationScale(scale );
tball.setRotationCenter (tCenter );
// run...
return 0;
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
printf("Usage: testCGShader [normal map filename]\n");
const char *normal_map_img_name = "opensg_logoDOT3.png";
OSG::Color4f tmp;
if( argc > 1 )
normal_map_img_name = argv[1];
// OSG init
OSG::osgInit(argc,argv);
// GLUT init
int winid = setupGLUT(&argc, argv);
// the connection between GLUT and OpenSG
OSG::GLUTWindowUnrecPtr gwin = OSG::GLUTWindow::create();
gwin->setGlutId(winid);
gwin->setSize( 800, 800 );
gwin->init();
// Create the shader material
// Read the image for the normal texture
OSG::ImageUnrecPtr normal_map_img = OSG::Image::create();
if(!normal_map_img->read(normal_map_img_name))
{
fprintf(stderr, "Couldn't read normalmap texture '%s'!\n", normal_map_img_name);
return 1;
}
OSG::ChunkMaterialUnrecPtr cmat = OSG::ChunkMaterial::create();
OSG::MaterialChunkUnrecPtr matc = OSG::MaterialChunk::create();
matc->setAmbient(OSG::Color4f(0.1, 0.1, 0.1, 1.0));
matc->setDiffuse(OSG::Color4f(0.3, 0.3, 0.3, 1.0));
matc->setSpecular(OSG::Color4f(0.8, 0.8, 0.8, 1.0));
matc->setShininess(100);
matc->setLit(true);
OSG::SHLChunkUnrecPtr shl = OSG::SHLChunk::create();
shl->setVertexProgram(_vp_program);
shl->setFragmentProgram(_fp_program);
OSG::TextureObjChunkUnrecPtr tex_normal_map = OSG::TextureObjChunk::create();
OSG::TextureEnvChunkUnrecPtr tex_normal_map_env = OSG::TextureEnvChunk::create();
tex_normal_map->setImage(normal_map_img);
tex_normal_map->setMinFilter(GL_LINEAR_MIPMAP_LINEAR);
tex_normal_map->setMagFilter(GL_LINEAR);
tex_normal_map->setWrapS(GL_REPEAT);
tex_normal_map->setWrapT(GL_REPEAT);
tex_normal_map_env->setEnvMode(GL_MODULATE);
//cmat->addChunk(matc);
cmat->addChunk(shl);
cmat->addChunk(tex_normal_map);
cmat->addChunk(tex_normal_map_env);
// create root node
_scene = OSG::Node::create();
// create geometry
//GeometryPtr geo = makeLatLongSphereGeo (100, 100, 1.0);
OSG::GeometryUnrecPtr geo = OSG::makePlaneGeo(1.0, 1.0, 100, 100);
geo->setMaterial(cmat);
OSG::NodeUnrecPtr torus = OSG::Node::create();
torus->setCore(geo);
// add torus to scene
OSG::GroupUnrecPtr group = OSG::Group::create();
_scene->setCore(group);
_scene->addChild(torus);
// create the SimpleSceneManager helper
_mgr = OSG::SimpleSceneManager::create();
// tell the manager what to manage
_mgr->setWindow(gwin );
_mgr->setRoot(_scene);
/*
// create point headlight
_mgr->turnHeadlightOff();
NodePtr headlight = _mgr->getHighlight();
PointLightPtr light = PointLight::create();
beginEditCP(light);
light->setAmbient (.3, .3, .3, 1);
light->setDiffuse ( 1, 1, 1, 1);
light->setSpecular ( 1, 1, 1, 1);
light->setBeacon (_mgr->getCamera()->getBeacon());
endEditCP(light);
beginEditCP(_scene);
_scene->setCore(light);
endEditCP(_scene);
*/
// show the whole scene
_mgr->showAll();
// GLUT main loop
glutMainLoop();
return 0;
}
// Initialize GLUT & OpenSG and set up the scene
int doMain(int argc, char **argv)
{
// OSG init
OSG::osgInit(argc,argv);
// GLUT init
int winid = setupGLUT(&argc, argv);
// the connection between GLUT and OpenSG
OSG::GLUTWindowUnrecPtr gwin = OSG::GLUTWindow::create();
gwin->setGlutId(winid);
gwin->setSize( 800, 800 );
gwin->init();
// Create the shader material
OSG::ChunkMaterialUnrecPtr cmat = OSG::ChunkMaterial::create();
OSG::SHLChunkUnrecPtr shl = OSG::SHLChunk::create();
shl->setProgramParameter(GL_GEOMETRY_INPUT_TYPE_EXT,
GL_TRIANGLES);
shl->setProgramParameter(GL_GEOMETRY_OUTPUT_TYPE_EXT,
GL_TRIANGLE_STRIP);
shl->setProgramParameter(GL_GEOMETRY_VERTICES_OUT_EXT, 6);
shl->setVertexProgram(_vertex_shader);
shl->setFragmentProgram(_fragment_shader);
shl->setGeometryProgram(_geometry_shader);
cmat->addChunk(shl);
// create root node
_scene = OSG::Node::create();
// create torus
OSG::GeometryUnrecPtr geo = OSG::makeTorusGeo(.8, 1.8, 128, 128);
geo->setMaterial(cmat);
OSG::NodeUnrecPtr torus = OSG::Node::create();
torus->setCore(geo);
// add torus to scene
OSG::GroupUnrecPtr group = OSG::Group::create();
_scene->setCore(group);
_scene->addChild(torus);
// create the SimpleSceneManager helper
_mgr = OSG::SimpleSceneManager::create();
// tell the manager what to manage
_mgr->setWindow(gwin );
_mgr->setRoot(_scene);
// show the whole scene
_mgr->showAll();
return 0;
}
VCGLUTNativeWindow::VCGLUTNativeWindow(const VCNativeWindowDesc& desc)
: VCNativeWindow(desc)
, _winID(-1)
{
assert(_glutInitialized);
unsigned dispMode = GLUT_RGBA | GLUT_DEPTH | GLUT_STENCIL | GLUT_ALPHA | GLUT_DOUBLE;
if (_desc._sampleCount > 1)
dispMode |= GLUT_MULTISAMPLE;
if (_desc._stereoBuffer)
dispMode |= GLUT_STEREO;
glutInitDisplayMode (dispMode);
// create window
if (_desc._fullscreen)
{
//if (pipeStr.empty() == false) {
// glutGameModeString(pipeStr.c_str());
// if (glutGameModeGet(GLUT_GAME_MODE_POSSIBLE)) {
// FNOTICE (("Enter glut game mode\n"));
// _winID = glutEnterGameMode();
// }
// else {
// FFATAL (("pipe >%s< mode not supported, start default fullscreen\n",
// pipeStr.c_str() ));
// _winID = glutCreateWindow(title.c_str());
// glutFullScreen();
// }
//}
//else {
_winID = glutCreateWindow(_desc._title.c_str());
glutFullScreen();
//}
}
else
{
_winID = glutCreateWindow(_desc._title.c_str());
}
if(!_desc._visible)
glutHideWindow();
//#if defined(GLUT_MACOSX_IMPLEMENTATION) && (GLUT_MACOSX_IMPLEMENTATION >= 2)
// glutWMCloseFunc(wmClose);
//#endif
OSG::GLUTWindowUnrecPtr glutWinPtr = OSG::GLUTWindow::create();
glutWinPtr->setGlutId(_winID);
//glutTimerFunc (0, runTimerFrame, 0);
//glutVisibilityFunc(visibility);
glutDisplayFunc(display);
glutIdleFunc(idle);
glutReshapeFunc(reshape);
//glutKeyboardFunc(keyDown);
//glutKeyboardUpFunc(keyUp);
glutMotionFunc(motion);
//glutPassiveMotionFunc(motion);
glutMouseFunc(mouse);
//glutSpecialFunc(specialKeyDown);
//glutSpecialUpFunc(specialKeyUp);
//glutMenuStateFunc(menuState);
// switch off key repetition on keypress (i.e. constant keyup/keydown toggle for pressed keys)
//glutIgnoreKeyRepeat (1);
if (_desc._drawCursor == false)
glutSetCursor(GLUT_CURSOR_NONE);
if (_desc._fullscreen == false)
{
int width = _desc._size.x();
int height = _desc._size.y();
if ((width >= 0) && (height >= 0))
glutReshapeWindow(width, height);
}
int x = _desc._position.x();
int y = _desc._position.y();
if ((x >= 0) && (y >= 0))
glutPositionWindow(x, y);
FDEBUG (("Create window (ID: %d)\n", _winID));
_osgWindow = glutWinPtr;
// init is will be called by VCWindow
// _osgWindow->init();
_windowBag[_winID] = this;
}
// Initialize GLUT & OpenSG and set up the scene
int doMain(int argc, char **argv)
{
printf("Press key '9' or '0' to toggle light sources.\n");
printf("Set the shadow mode with key '1' ... '8'\n");
printf("Change MapSize with keys 'y' = 512, 'x' = 1024, 'c' = 2048\n");
printf("NOTE: Real point lights only supported for ShadowMode 1...6!\n");
// OSG init
OSG::osgInit(argc, argv);
// GLUT init
int winid = setupGLUT(&argc, argv);
gwin = OSG::GLUTWindow::create();
//Erstellen der ben�tigten Komponenten--------------------------------------
rootNode = OSG::makeCoredNode<OSG::Group>();
OSG::NodeUnrecPtr scene = OSG::makeCoredNode<OSG::Group>();
/*
// create lights
//Directional Light 1
OSG::NodeUnrecPtr light1 = OSG::makeCoredNode<OSG::DirectionalLight>(&_light1_core);
OSG::NodeUnrecPtr light1_beacon = OSG::makeCoredNode<OSG::Transform>(&_light1_trans);
_light1_trans->editMatrix().setTranslate(0.0, 0.0, 0.0);
_light1_core->setDirection(0.8,0.8,0.5);
_light1_core->setAmbient(0.15,0.15,0.15,1);
_light1_core->setDiffuse(0.5,0.5,0.5,1);
_light1_core->setSpecular(0.0,0.0,0.0,1);
_light1_core->setBeacon(light1_beacon);
_light1_core->setShadowIntensity(0.7);
_light1_core->setOn(true);
*/
// Point Light 1
OSG::NodeUnrecPtr light1 = OSG::makeCoredNode<OSG::PointLight>(&_light1_core);
OSG::NodeUnrecPtr light1_beacon = OSG::makeCoredNode<OSG::Transform >(&_light1_trans);
_light1_trans->editMatrix().setTranslate(50.0, 50.0, 10.0);
_light1_core->setAmbient(0.15f, 0.15f, 0.15f, 1);
_light1_core->setDiffuse(0.5f, 0.5f, 0.5f, 1);
_light1_core->setSpecular(0.0f, 0.0f, 0.0f, 1);
_light1_core->setBeacon(light1_beacon);
_light1_core->setOn(true);
_light1_core->setShadowIntensity(0.8f);
// Spot Light 2
OSG::NodeUnrecPtr light2 = OSG::makeCoredNode<OSG::SpotLight>(&_light2_core);
OSG::NodeUnrecPtr light2_beacon = OSG::makeCoredNode<OSG::Transform>(&_light2_trans);
//_light2_trans->editMatrix().setTranslate(75.0, 0.0, 25.0);
_light2_trans->editMatrix().setTranslate(250.0, -250.0, 300.0);
_light2_core->setAmbient(0.15,0.15,0.15,1);
_light2_core->setDiffuse(0.5,0.5,0.5,1);
_light2_core->setSpecular(0.0,0.0,0.0,1);
_light2_core->setSpotCutOffDeg(40.0);
_light2_core->setSpotDirection(-0.85,0.85,-1.0);
_light2_core->setBeacon(light2_beacon);
_light2_core->setShadowIntensity(0.7);
_light2_core->setOn(true);
/*
// Point Light 2
OSG::NodeUnrecPtr light2 = OSG::makeCoredNode<OSG::PointLight>(&_light2_core);
OSG::NodeUnrecPtr light2_beacon = OSG::makeCoredNode<OSG::Transform> (&_light2_trans);
_light2_trans->editMatrix().setTranslate(40.0, 0.0, 40.0);
_light2_core->setAmbient(0.15f, 0.15f, 0.15f, 1);
_light2_core->setDiffuse(0.5f, 0.5f, 0.5f, 1);
_light2_core->setSpecular(0.0f, 0.0f, 0.0f, 1);
_light2_core->setBeacon(light2_beacon);
_light2_core->setOn(false);
_light2_core->setShadowIntensity(0.7f);
*/
light1->addChild(light2);
light2->addChild(scene);
//Eigene Kamera erstellen
Pcamera = OSG::PerspectiveCamera::create();
cam_beacon = OSG::makeCoredNode<OSG::Transform>(&cam_trans);
cam_trans->editMatrix().setTranslate(0.0, 0.0, 25.0);
Pcamera->setBeacon(cam_beacon);
Pcamera->setFov(OSG::osgDegree2Rad(60));
Pcamera->setNear(1.0);
Pcamera->setFar(1000);
// create scene
// bottom
OSG::NodeUnrecPtr plane = OSG::makePlane(300.0, 300.0, 256, 256);
OSG::ImageUnrecPtr plane_img = OSG::Image::create();
plane_img->read("gras.jpg");
OSG::TextureObjChunkUnrecPtr plane_tex_obj = OSG::TextureObjChunk::create();
OSG::TextureEnvChunkUnrecPtr plane_tex_env = OSG::TextureEnvChunk::create();
plane_tex_obj->setImage(plane_img);
plane_tex_obj->setMinFilter(GL_LINEAR);
plane_tex_obj->setMagFilter(GL_LINEAR);
plane_tex_obj->setWrapS(GL_REPEAT);
plane_tex_obj->setWrapT(GL_REPEAT);
plane_tex_env->setEnvMode(GL_MODULATE);
OSG::SimpleMaterialUnrecPtr plane_mat = OSG::SimpleMaterial::create();
plane_mat->setAmbient(OSG::Color3f(0.3f, 0.3f, 0.3f));
plane_mat->setDiffuse(OSG::Color3f(1.0f, 1.0f, 1.0f));
plane_mat->addChunk(plane_tex_obj);
plane_mat->addChunk(plane_tex_env);
OSG::Geometry *plane_geo = dynamic_cast<OSG::Geometry *>(plane->getCore());
plane_geo->setMaterial(plane_mat);
//load Tree Objects
OSG::NodeUnrecPtr tree1_trans_node = OSG::makeCoredNode<OSG::Transform>
(&_tree1_trans);
OSG::NodeUnrecPtr tree2_trans_node = OSG::makeCoredNode<OSG::Transform>
(&_tree2_trans);
OSG::NodeUnrecPtr tree3_trans_node = OSG::makeCoredNode<OSG::Transform>
(&_tree3_trans);
OSG::NodeUnrecPtr tree4_trans_node = OSG::makeCoredNode<OSG::Transform>
(&_tree4_trans);
OSG::NodeUnrecPtr tree5_trans_node = OSG::makeCoredNode<OSG::Transform>
(&_tree5_trans);
OSG::NodeUnrecPtr tree6_trans_node = OSG::makeCoredNode<OSG::Transform>
(&_tree6_trans);
OSG::NodeUnrecPtr tree7_trans_node = OSG::makeCoredNode<OSG::Transform>
(&_tree7_trans);
OSG::NodeUnrecPtr tree8_trans_node = OSG::makeCoredNode<OSG::Transform>
(&_tree8_trans);
OSG::NodeUnrecPtr tree9_trans_node = OSG::makeCoredNode<OSG::Transform>
(&_tree9_trans);
_tree1_trans->editMatrix().setTranslate(-80.0, -80.0, 0.0);
_tree1_trans->editMatrix().setScale(OSG::Vec3f(12.0, 12.0, 10.0));
_tree2_trans->editMatrix().setTranslate(0.0, -80.0, 0.0);
_tree2_trans->editMatrix().setScale(OSG::Vec3f(12.0, 12.0, 10.0));
_tree3_trans->editMatrix().setTranslate(80.0, -80.0, 0.0);
_tree3_trans->editMatrix().setScale(OSG::Vec3f(12.0, 12.0, 10.0));
_tree4_trans->editMatrix().setTranslate(-80.0, 0.0, 0.0);
_tree4_trans->editMatrix().setScale(OSG::Vec3f(12.0, 12.0, 10.0));
_tree5_trans->editMatrix().setTranslate(0.0, 0.0, 0.0);
_tree5_trans->editMatrix().setScale(OSG::Vec3f(12.0, 12.0, 10.0));
_tree6_trans->editMatrix().setTranslate(80.0, 0.0, 0.0);
_tree6_trans->editMatrix().setScale(OSG::Vec3f(12.0, 12.0, 10.0));
_tree7_trans->editMatrix().setTranslate(-80.0, 80.0, 0.0);
_tree7_trans->editMatrix().setScale(OSG::Vec3f(12.0, 12.0, 10.0));
_tree8_trans->editMatrix().setTranslate(0.0, 80.0, 0.0);
_tree8_trans->editMatrix().setScale(OSG::Vec3f(12.0, 12.0, 10.0));
_tree9_trans->editMatrix().setTranslate(80.0, 80.0, 0.0);
_tree9_trans->editMatrix().setScale(OSG::Vec3f(12.0, 12.0, 10.0));
OSG::NodeUnrecPtr tree1 = OSG::SceneFileHandler::the()->read("tree1.3ds");
// NodeUnrecPtr tree1 = makeSphere(2, 2.0);
tree1_trans_node->addChild(tree1);
tree2_trans_node->addChild(cloneTree(tree1));
tree3_trans_node->addChild(cloneTree(tree1));
tree4_trans_node->addChild(cloneTree(tree1));
tree5_trans_node->addChild(cloneTree(tree1));
tree6_trans_node->addChild(cloneTree(tree1));
tree7_trans_node->addChild(cloneTree(tree1));
tree8_trans_node->addChild(cloneTree(tree1));
tree9_trans_node->addChild(cloneTree(tree1));
OSG::NodeUnrecPtr trees = OSG::makeCoredNode<OSG::Group>();
trees->addChild(tree1_trans_node);
trees->addChild(tree2_trans_node);
trees->addChild(tree3_trans_node);
trees->addChild(tree4_trans_node);
trees->addChild(tree5_trans_node);
trees->addChild(tree6_trans_node);
trees->addChild(tree7_trans_node);
trees->addChild(tree8_trans_node);
trees->addChild(tree9_trans_node);
/*//load Airplane Object
NodePtr obj1_trans_node = makeCoredNode<Transform>(&_obj1_trans);
_obj1_trans->editMatrix().setTranslate(0.0, 0.0, 10.0);
_obj1_trans->editMatrix().setScale(Vec3f(0.15,0.15,0.15));
NodePtr object1 = SceneFileHandler::the().read("triplane.3ds");
obj1_trans_node->addChild(object1);
*/
//Load a Quad as Pointlight
OSG::GeometryUnrecPtr boxGeo = OSG::makeBoxGeo(15, 15, 15, 1, 1, 1);
OSG::NodeUnrecPtr boxNode = OSG::Node::create();
boxNode->setCore(boxGeo);
OSG::SimpleMaterialUnrecPtr box_mat = OSG::SimpleMaterial::create();
box_mat->setAmbient(OSG::Color3f(0.95f, 1.0f, 0.2f));
box_mat->setDiffuse(OSG::Color3f(0.95f, 1.0f, 0.2f));
boxGeo->setMaterial(box_mat);
OSG::NodeUnrecPtr obj1_trans_node = OSG::makeCoredNode<OSG::Transform>
(&_obj1_trans);
obj1_trans_node->addChild(boxNode);
//load Dino Objects
OSG::NodeUnrecPtr dino1_trans_node = OSG::makeCoredNode<OSG::Transform>
(&_dino1_trans);
OSG::NodeUnrecPtr dino2_trans_node = OSG::makeCoredNode<OSG::Transform>
(&_dino2_trans);
OSG::NodeUnrecPtr dino3_trans_node = OSG::makeCoredNode<OSG::Transform>
(&_dino3_trans);
OSG::NodeUnrecPtr dino4_trans_node = OSG::makeCoredNode<OSG::Transform>
(&_dino4_trans);
_dino1_trans->editMatrix().setTranslate(-20.0, -20.0, 10.0);
_dino1_trans->editMatrix().setScale(OSG::Vec3f(5.0, 5.0, 5.0));
_dino2_trans->editMatrix().setTranslate(-20.0, -20.0, 6.0);
_dino2_trans->editMatrix().setScale(OSG::Vec3f(3.0, 3.0, 3.0));
_dino3_trans->editMatrix().setTranslate(-20.0, -20.0, 6.0);
_dino3_trans->editMatrix().setScale(OSG::Vec3f(3.0, 3.0, 3.0));
_dino4_trans->editMatrix().setTranslate(-20.0, -20.0, 6.0);
_dino4_trans->editMatrix().setScale(OSG::Vec3f(3.0, 3.0, 3.0));
OSG::NodeUnrecPtr dino1 = OSG::SceneFileHandler::the()->read("dinopet.3ds");
// NodeUnrecPtr dino1 = makeBox(2., 2., 2., 4, 4, 4);
dino1_trans_node->addChild(dino1);
dino2_trans_node->addChild(cloneTree(dino1));
dino3_trans_node->addChild(cloneTree(dino1));
dino4_trans_node->addChild(cloneTree(dino1));
OSG::NodeUnrecPtr dinos = OSG::makeCoredNode<OSG::Group>();
dinos->addChild(dino1_trans_node);
dinos->addChild(dino2_trans_node);
dinos->addChild(dino3_trans_node);
dinos->addChild(dino4_trans_node);
//load Stone Objects
OSG::TransformUnrecPtr _stone_trans1, _stone_trans2, _stone_trans3,
_stone_trans4, _stone_trans5, _stone_trans6,
_stone_trans7, _stone_trans8,
_stone_trans9;
OSG::NodeUnrecPtr stone_trans_node1 = OSG::makeCoredNode<OSG::Transform>
(&_stone_trans1);
OSG::NodeUnrecPtr stone_trans_node2 = OSG::makeCoredNode<OSG::Transform>
(&_stone_trans2);
OSG::NodeUnrecPtr stone_trans_node3 = OSG::makeCoredNode<OSG::Transform>
(&_stone_trans3);
OSG::NodeUnrecPtr stone_trans_node4 = OSG::makeCoredNode<OSG::Transform>
(&_stone_trans4);
OSG::NodeUnrecPtr stone_trans_node5 = OSG::makeCoredNode<OSG::Transform>
(&_stone_trans5);
OSG::NodeUnrecPtr stone_trans_node6 = OSG::makeCoredNode<OSG::Transform>
(&_stone_trans6);
OSG::NodeUnrecPtr stone_trans_node7 = OSG::makeCoredNode<OSG::Transform>
(&_stone_trans7);
OSG::NodeUnrecPtr stone_trans_node8 = OSG::makeCoredNode<OSG::Transform>
(&_stone_trans8);
OSG::NodeUnrecPtr stone_trans_node9 = OSG::makeCoredNode<OSG::Transform>
(&_stone_trans9);
_stone_trans1->editMatrix().setTranslate(-70, -70, 0);
_stone_trans2->editMatrix().setTranslate(10, -70, 0);
_stone_trans3->editMatrix().setTranslate(90, -70, 0);
_stone_trans4->editMatrix().setTranslate(-70, 10, 0);
_stone_trans5->editMatrix().setTranslate(10, 10, 0);
_stone_trans6->editMatrix().setTranslate(90, 10, 0);
_stone_trans7->editMatrix().setTranslate(-70, 90, 0);
_stone_trans8->editMatrix().setTranslate(10, 90, 0);
_stone_trans9->editMatrix().setTranslate(90, 90, 0);
OSG::NodeUnrecPtr stone1 = OSG::makeSphere(1, 7.0);
OSG::NodeUnrecPtr stone2 = OSG::makeSphere(1, 7.0);
OSG::NodeUnrecPtr stone3 = OSG::makeSphere(1, 7.0);
OSG::NodeUnrecPtr stone4 = OSG::makeSphere(1, 7.0);
OSG::NodeUnrecPtr stone5 = OSG::makeSphere(1, 7.0);
OSG::NodeUnrecPtr stone6 = OSG::makeSphere(1, 7.0);
OSG::NodeUnrecPtr stone7 = OSG::makeSphere(1, 7.0);
OSG::NodeUnrecPtr stone8 = OSG::makeSphere(1, 7.0);
OSG::NodeUnrecPtr stone9 = OSG::makeSphere(1, 7.0);
OSG::ImageUnrecPtr plane_img2 = OSG::Image::create();
plane_img2->read("stone.jpg");
OSG::TextureObjChunkUnrecPtr plane_tex2_obj = OSG::TextureObjChunk::create();
OSG::TextureEnvChunkUnrecPtr plane_tex2_env = OSG::TextureEnvChunk::create();
plane_tex2_obj->setImage(plane_img2);
plane_tex2_obj->setMinFilter(GL_LINEAR);
plane_tex2_obj->setMagFilter(GL_LINEAR);
plane_tex2_obj->setWrapS(GL_REPEAT);
plane_tex2_obj->setWrapT(GL_REPEAT);
plane_tex2_env->setEnvMode(GL_MODULATE);
OSG::SimpleMaterialUnrecPtr plane_mat2 = OSG::SimpleMaterial::create();
plane_mat2->setAmbient(OSG::Color3f(0.3f, 0.3f, 0.3f));
plane_mat2->setDiffuse(OSG::Color3f(1.0f, 1.0f, 1.0f));
plane_mat2->addChunk(plane_tex2_obj);
plane_mat2->addChunk(plane_tex2_env);
OSG::Geometry *plane_geo3 = dynamic_cast<OSG::Geometry *>(stone1->getCore());
plane_geo3->setMaterial(plane_mat2);
plane_geo3 = dynamic_cast<OSG::Geometry *>(stone2->getCore());
plane_geo3->setMaterial(plane_mat2);
plane_geo3 = dynamic_cast<OSG::Geometry *>(stone3->getCore());
plane_geo3->setMaterial(plane_mat2);
plane_geo3 = dynamic_cast<OSG::Geometry *>(stone4->getCore());
plane_geo3->setMaterial(plane_mat2);
plane_geo3 = dynamic_cast<OSG::Geometry *>(stone5->getCore());
plane_geo3->setMaterial(plane_mat2);
plane_geo3 = dynamic_cast<OSG::Geometry *>(stone6->getCore());
plane_geo3->setMaterial(plane_mat2);
plane_geo3 = dynamic_cast<OSG::Geometry *>(stone7->getCore());
plane_geo3->setMaterial(plane_mat2);
plane_geo3 = dynamic_cast<OSG::Geometry *>(stone8->getCore());
plane_geo3->setMaterial(plane_mat2);
plane_geo3 = dynamic_cast<OSG::Geometry *>(stone9->getCore());
plane_geo3->setMaterial(plane_mat2);
stone_trans_node1->addChild(stone1);
stone_trans_node2->addChild(stone2);
stone_trans_node3->addChild(stone3);
stone_trans_node4->addChild(stone4);
stone_trans_node5->addChild(stone5);
stone_trans_node6->addChild(stone6);
stone_trans_node7->addChild(stone7);
stone_trans_node8->addChild(stone8);
stone_trans_node9->addChild(stone9);
OSG::NodeUnrecPtr stones = OSG::makeCoredNode<OSG::Group>();
stones->addChild(stone_trans_node1);
stones->addChild(stone_trans_node2);
stones->addChild(stone_trans_node3);
stones->addChild(stone_trans_node4);
stones->addChild(stone_trans_node5);
stones->addChild(stone_trans_node6);
stones->addChild(stone_trans_node7);
stones->addChild(stone_trans_node8);
stones->addChild(stone_trans_node9);
scene->addChild(plane);
scene->addChild(obj1_trans_node);
scene->addChild(trees);
scene->addChild(stones);
scene->addChild(dinos);
svp = OSG::ShadowStage::create();
OSG::GradientBackgroundUnrecPtr gbg = OSG::GradientBackground::create();
OSG::SolidBackgroundUnrecPtr sbg = OSG::SolidBackground::create();
gbg->addLine(OSG::Color3f(0.7f, 0.7f, 0.8f), 0);
gbg->addLine(OSG::Color3f(0.0f, 0.1f, 0.3f), 1);
rootNode->setCore(svp);
rootNode->addChild(light1);
rootNode->addChild(light1_beacon);
rootNode->addChild(light2_beacon);
rootNode->addChild(cam_beacon);
// Shadow viewport
#ifdef SHADOW_CHECK
svp->setBackground(gbg);
svp->setRoot(rootNode);
svp->setSize(0, 0, 1, 1);
#endif
//svp->setOffFactor(4.0);
//svp->setOffBias(8.0);
//used to set global shadow intensity, ignores shadow intensity from light sources if != 0.0
//svp->setGlobalShadowIntensity(0.8);
svp->setMapSize(1024);
//ShadowSmoothness used for PCF_SHADOW_MAP and VARIANCE_SHADOW_MAP, defines Filter Width. Range can be 0.0 ... 1.0.
//ShadowSmoothness also used to define the light size for PCSS_SHADOW_MAP
svp->setShadowSmoothness(0.5);
// add light sources here
//svp->editMFLightNodes ()->push_back(light1);
//svp->editMFLightNodes ()->push_back(light2);
svp->editMFExcludeNodes()->push_back(obj1_trans_node);
svp->setAutoSearchForLights(true);
//one active light at startup
_light2_core->setOn(true);
_light2_core->setAmbient(0.3f, 0.3f, 0.3f, 1);
_light2_core->setDiffuse(0.8f, 0.8f, 0.8f, 1);
_light1_core->setOn(false);
_light1_core->setAmbient(0.3, 0.3, 0.3, 1);
_light1_core->setDiffuse(0.8, 0.8, 0.8, 1);
gwin->setGlutId(winid);
#ifdef SHADOW_CHECK
gwin->addPort(svp);
#endif
gwin->init();
OSG::Vec3f min, max;
rootNode->updateVolume();
rootNode->getVolume().getBounds(min, max);
// create the SimpleSceneManager helper
mgr = OSG::SimpleSceneManager::create();
mgr->setWindow(gwin);
mgr->setCamera(Pcamera);
mgr->setRoot(rootNode);
_navigator.setMode(OSG::Navigator::TRACKBALL);
#ifdef SHADOW_CHECK
_navigator.setViewport(svp);
#endif
_navigator.setCameraTransformation(cam_beacon);
OSG::Vec3f up(0,1,0);
OSG::Pnt3f at(0,0,0);
OSG::Pnt3f from(0.0f,-100.1f,20.0f);
_navigator.set(from, at, up);
_navigator.setMotionFactor(0.5f);
#ifdef SHADOW_CHECK
svp->setCamera(Pcamera);
#endif
//activate Framecounter
startFpsCounter();
// dynamic_cast<RenderAction *>(mgr->getAction())->setLocalLights(true);
mgr->turnHeadlightOff();
mgr->showAll();
mgr->getCamera()->setNear( 1.0f);
mgr->getCamera()->setFar (1000000.f );
_navigator.setViewport(gwin->getPort(0));
return 0;
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
printf("Usage: testCGShader <filename.vp> <filename.fp>\n");
if( argc < 3 )
return 0;
// OSG init
OSG::osgInit(argc,argv);
// GLUT init
int winid = setupGLUT(&argc, argv);
// the connection between GLUT and OpenSG
OSG::GLUTWindowUnrecPtr gwin = OSG::GLUTWindow::create();
gwin->setGlutId(winid);
gwin->setSize( 800, 800 );
gwin->init();
// Create the shader material
OSG::ChunkMaterialUnrecPtr cmat = OSG::ChunkMaterial::create();
OSG::MaterialChunkUnrecPtr matc = OSG::MaterialChunk::create();
matc->setAmbient(OSG::Color4f(0.1, 0.1, 0.1, 1.0));
matc->setDiffuse(OSG::Color4f(0.3, 0.3, 0.3, 1.0));
matc->setSpecular(OSG::Color4f(0.8, 0.8, 0.8, 1.0));
matc->setShininess(100);
matc->setLit(true);
OSG::SHLChunkUnrecPtr shl = OSG::SHLChunk::create();
shl->readVertexProgram(argv[1]);
shl->readFragmentProgram(argv[2]);
cmat->addChunk(shl);
// create root node
_scene = OSG::Node::create();
// create torus
OSG::GeometryUnrecPtr geo = OSG::makeTorusGeo(.8, 1.8, 128, 128);
geo->setMaterial(cmat);
OSG::NodeUnrecPtr torus = OSG::Node::create();
torus->setCore(geo);
// add torus to scene
OSG::GroupUnrecPtr group = OSG::Group::create();
_scene->setCore(group);
_scene->addChild(torus);
// create the SimpleSceneManager helper
_mgr = OSG::SimpleSceneManager::create();
// tell the manager what to manage
_mgr->setWindow(gwin );
_mgr->setRoot(_scene);
/*
// create point headlight
_mgr->turnHeadlightOff();
NodePtr headlight = _mgr->getHighlight();
PointLightPtr light = PointLight::create();
beginEditCP(light);
light->setAmbient (.3, .3, .3, 1);
light->setDiffuse ( 1, 1, 1, 1);
light->setSpecular ( 1, 1, 1, 1);
light->setBeacon (_mgr->getCamera()->getBeacon());
endEditCP(light);
beginEditCP(_scene);
_scene->setCore(light);
endEditCP(_scene);
*/
// show the whole scene
_mgr->showAll();
// GLUT main loop
glutMainLoop();
return 0;
}
