void initFloor(void)
{
OSG::GeometryUnrecPtr floor = OSG::makePlaneGeo(2000.f, 2000.f, 10, 10);
OSG::NodeUnrecPtr floorN = OSG::makeNodeFor(floor);
OSG::TransformUnrecPtr xform = OSG::Transform::create();
OSG::NodeUnrecPtr xformN = OSG::makeNodeFor(xform);
OSG::ImageUnrecPtr img = OSG::ImageFileHandler::the()->read("sand1Tile.png");
OSG::TextureObjChunkUnrecPtr tex = OSG::TextureObjChunk::create();
tex->setImage(img);
OSG::ChunkMaterial *chunkMat = dynamic_cast<OSG::ChunkMaterial *>(floor->getMaterial());
if(chunkMat != NULL)
{
chunkMat->addChunk(tex);
}
OSG::Quaternion quat;
quat.setValueAsAxisDeg(OSG::Vec3f(1.f, 0.f, 0.f), -90.f);
xform->editMatrix().setRotate(quat);
xformN->addChild(floorN);
g->rootN->addChild(xformN);
}
// 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.1f, 0.1f, 0.1f, 1.0f));
matc->setDiffuse(OSG::Color4f(0.3f, 0.3f, 0.3f, 1.0f));
matc->setSpecular(OSG::Color4f(0.8f, 0.8f, 0.8f, 1.0f));
matc->setShininess(100);
matc->setLit(true);
OSG::ShaderProgramChunkUnrecPtr shl = OSG::ShaderProgramChunk::create();
OSG::ShaderProgramUnrecPtr shl_vp =
OSG::ShaderProgram::createVertexShader();
shl_vp->setProgram(_vp_program);
shl->addShader(shl_vp);
OSG::ShaderProgramUnrecPtr shl_fp =
OSG::ShaderProgram::createFragmentShader();
shl_fp->setProgram(_fp_program);
shl->addShader(shl_fp);
shl_vp->addProceduralVariable ("Light0Active", &light0Active);
shl_vp->addProceduralVariable ("Light1Active", &light1Active);
shl_vp->addNodeProceduralVariable("Light2Active", &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 = OSG::SimpleSceneManager::create();
// 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 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;
}
// 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();
// Read the image for the normal texture
OSG::ImageUnrecPtr earth_map_img = OSG::Image::create();
if(!earth_map_img->read("Earth.jpg"))
{
fprintf(stderr, "Couldn't read texture 'Earth.jpg'\n");
return 1;
}
OSG::TextureObjChunkUnrecPtr tex_earth = OSG::TextureObjChunk::create();
OSG::TextureEnvChunkUnrecPtr tex_earth_env = OSG::TextureEnvChunk::create();
tex_earth->setImage(earth_map_img);
tex_earth->setMinFilter(GL_LINEAR_MIPMAP_LINEAR);
tex_earth->setMagFilter(GL_LINEAR);
tex_earth->setWrapS(GL_REPEAT);
tex_earth->setWrapT(GL_REPEAT);
tex_earth_env->setEnvMode(GL_MODULATE);
// Read the image for the normal texture
OSG::ImageUnrecPtr earth_night_map_img = OSG::Image::create();
if(!earth_night_map_img->read("EarthNight.jpg"))
{
fprintf(stderr, "Couldn't read texture 'EarthNight.jpg'\n");
return 1;
}
OSG::TextureObjChunkUnrecPtr tex_earth_night =
OSG::TextureObjChunk::create();
OSG::TextureEnvChunkUnrecPtr tex_earth_night_env =
OSG::TextureEnvChunk::create();
tex_earth_night->setImage(earth_night_map_img);
tex_earth_night->setMinFilter(GL_LINEAR_MIPMAP_LINEAR);
tex_earth_night->setMagFilter(GL_LINEAR);
tex_earth_night->setWrapS(GL_REPEAT);
tex_earth_night->setWrapT(GL_REPEAT);
tex_earth_night_env->setEnvMode(GL_MODULATE);
// Read the image for the normal texture
OSG::ImageUnrecPtr earth_clouds_map_img = OSG::Image::create();
if(!earth_clouds_map_img->read("EarthClouds.jpg"))
{
fprintf(stderr, "Couldn't read texture 'EarthClouds.jpg'\n");
return 1;
}
OSG::TextureObjChunkUnrecPtr tex_earth_clouds =
OSG::TextureObjChunk::create();
OSG::TextureEnvChunkUnrecPtr tex_earth_clouds_env =
OSG::TextureEnvChunk::create();
tex_earth_clouds->setImage(earth_clouds_map_img);
tex_earth_clouds->setMinFilter(GL_LINEAR_MIPMAP_LINEAR);
tex_earth_clouds->setMagFilter(GL_LINEAR);
tex_earth_clouds->setWrapS(GL_REPEAT);
tex_earth_clouds->setWrapT(GL_REPEAT);
tex_earth_clouds_env->setEnvMode(GL_MODULATE);
_shl = OSG::ShaderProgramChunk::create();
_shl_vp = OSG::ShaderProgram::create();
_shl_fp = OSG::ShaderProgram::create();
if(!_shl_vp->readProgram("Earth.vp"))
fprintf(stderr, "Couldn't read vertex program 'Earth.vp'\n");
if(!_shl_fp->readProgram("Earth.fp"))
fprintf(stderr, "Couldn't read fragment program 'Earth.fp'\n");
_shl_vp->setShaderType(GL_VERTEX_SHADER);
_shl_fp->setShaderType(GL_FRAGMENT_SHADER);
_shl->addVertexShader (_shl_vp);
_shl->addFragmentShader(_shl_fp);
_shl_fp->addUniformVariable("EarthDay", 0);
_shl_fp->addUniformVariable("EarthNight", 1);
_shl_fp->addUniformVariable("EarthCloudGloss", 2);
_shl_vp->addUniformVariable("season", 0.0f);
_shl_vp->addUniformVariable("cos_time_0_2PI", -0.406652f);
_shl_vp->addUniformVariable("sin_time_0_2PI", -0.913583f);
// _shl->setUniformParameter("foo", -0.913583f);
cmat->addChunk(_shl);
cmat->addChunk(tex_earth);
cmat->addChunk(tex_earth_env);
cmat->addChunk(tex_earth_night);
cmat->addChunk(tex_earth_night_env);
cmat->addChunk(tex_earth_clouds);
cmat->addChunk(tex_earth_clouds_env);
// create root node
_scene = OSG::Node::create();
OSG::GeometryUnrecPtr geo = OSG::makeLatLongSphereGeo (100, 100, 1.0);
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;
}
OSG::NodeTransitPtr setupAnim(void)
{
OSG::NodeTransitPtr returnValue = OSG::Node::create();
returnValue->setCore(OSG::Group::create());
static const OSG::Real32 aOffsets[6][3] =
{
{ -5.5, 0.0, 0.0 },
{ 5.5, 0.0, 0.0 },
{ 0.0, -5.5, 0.0 },
{ 0.0, 5.5, 0.0 },
{ 0.0, 0.0, -5.5 },
{ 0.0, 0.0, 5.5 }
};
static const OSG::Real32 aDiffuse[6][3] =
{
{ 1.f, 0.f, 0.f },
{ 0.f, 1.f, 0.f },
{ 0.f, 0.f, 1.f },
{ 1.f, 1.f, 0.f },
{ 1.f, 0.f, 1.f },
{ 0.f, 1.f, 1.f }
};
for(OSG::UInt32 i = 0; i < 6; ++i)
{
OSG::NodeUnrecPtr pTN = OSG::Node::create();
pAnimTrs[i] = OSG::ComponentTransform::create();
OSG::GeometryUnrecPtr pGeo = OSG::makeBoxGeo(1.f, 1.f, 1.f,
2, 2, 2);
OSG::NodeUnrecPtr pGeoNode = OSG::Node::create();
pGeoNode->setCore(pGeo);
OSG::SimpleMaterialUnrecPtr pMat = OSG::SimpleMaterial::create();
pMat->setDiffuse(OSG::Color3f(aDiffuse[i][0],
aDiffuse[i][1],
aDiffuse[i][2]));
pMat->setAmbient(OSG::Color3f(aDiffuse[i][0],
aDiffuse[i][1],
aDiffuse[i][2]));
pGeo->setMaterial(pMat);
pAnimTrs[i]->editTranslation().setValues(aOffsets[i][0],
aOffsets[i][1],
aOffsets[i][2]);
pTN->setCore (pAnimTrs[i]);
pTN->addChild(pGeoNode );
returnValue->addChild(pTN);
}
return returnValue;
}
// 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 = new OSG::SimpleSceneManager;
// 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;
}
TEST_FIXTURE(FileFixture, TextureChunkIO)
{
OSG::NodeUnrecPtr n = OSG::Node::create();
OSG::GeometryUnrecPtr geo = OSG::makeBoxGeo(2.0, 2.0, 2.0, 1, 1, 1);
OSG::ChunkMaterialUnrecPtr mat = OSG::ChunkMaterial::create();
OSG::ImageUnrecPtr img = OSG::Image::create();
img->set(OSG::Image::OSG_RGBA_PF, 2, 2);
img->editData()[0 * 2 * 4 + 0 * 4 + 0] = 255;
img->editData()[0 * 2 * 4 + 0 * 4 + 1] = 0;
img->editData()[0 * 2 * 4 + 0 * 4 + 2] = 0;
img->editData()[0 * 2 * 4 + 0 * 4 + 3] = 255;
img->editData()[0 * 2 * 4 + 1 * 4 + 0] = 255;
img->editData()[0 * 2 * 4 + 1 * 4 + 1] = 255;
img->editData()[0 * 2 * 4 + 1 * 4 + 2] = 0;
img->editData()[0 * 2 * 4 + 1 * 4 + 3] = 255;
img->editData()[1 * 2 * 4 + 0 * 4 + 0] = 0;
img->editData()[1 * 2 * 4 + 0 * 4 + 1] = 0;
img->editData()[1 * 2 * 4 + 0 * 4 + 2] = 255;
img->editData()[1 * 2 * 4 + 0 * 4 + 3] = 255;
img->editData()[1 * 2 * 4 + 1 * 4 + 0] = 0;
img->editData()[1 * 2 * 4 + 1 * 4 + 1] = 255;
img->editData()[1 * 2 * 4 + 1 * 4 + 2] = 255;
img->editData()[1 * 2 * 4 + 1 * 4 + 3] = 255;
OSG::TextureChunkUnrecPtr tex = OSG::TextureChunk::create();
tex->setImage(img);
mat->addChunk(tex);
geo->setMaterial(mat);
n->setCore(geo);
OSG::SceneFileHandler::the()->write(n, test_file.native_file_string().c_str());
OSG::NodeUnrecPtr n2 =
OSG::SceneFileHandler::the()->read(test_file.native_file_string().c_str());
CHECK(n2 != NULL);
CHECK(n2->getCore() != NULL);
OSG::GeometryUnrecPtr geo2 =
dynamic_cast<OSG::Geometry *>(n2->getCore());
CHECK(geo2 != NULL);
CHECK(geo2->getMaterial() != NULL);
OSG::ChunkMaterialUnrecPtr mat2 =
dynamic_cast<OSG::ChunkMaterial *>(geo2->getMaterial());
CHECK(mat2 != NULL);
CHECK(mat2->getChunk(0) != NULL);
const OSG::TextureChunk *tex2 =
dynamic_cast<const OSG::TextureChunk *>(mat2->getChunk(0));
const OSG::TextureObjChunk *texObj =
dynamic_cast<const OSG::TextureObjChunk *>(mat2->getChunk(0));
const OSG::TextureEnvChunk *texEnv =
dynamic_cast<const OSG::TextureEnvChunk *>(mat2->getChunk(1));
CHECK(tex2 == NULL);
CHECK(texObj != NULL);
CHECK(texEnv != NULL);
CHECK(texObj->getImage() != NULL);
OSG::Image *img2 = texObj->getImage();
CHECK(img2 != NULL);
CHECK_EQUAL(255, img2->getData()[0 * 2 * 4 + 0 * 4 + 0]);
CHECK_EQUAL( 0, img2->getData()[0 * 2 * 4 + 0 * 4 + 1]);
CHECK_EQUAL( 0, img2->getData()[0 * 2 * 4 + 0 * 4 + 2]);
CHECK_EQUAL(255, img2->getData()[0 * 2 * 4 + 0 * 4 + 3]);
CHECK_EQUAL(255, img2->getData()[0 * 2 * 4 + 1 * 4 + 0]);
CHECK_EQUAL(255, img2->getData()[0 * 2 * 4 + 1 * 4 + 1]);
CHECK_EQUAL( 0, img2->getData()[0 * 2 * 4 + 1 * 4 + 2]);
CHECK_EQUAL(255, img2->getData()[0 * 2 * 4 + 1 * 4 + 3]);
CHECK_EQUAL( 0, img2->getData()[1 * 2 * 4 + 0 * 4 + 0]);
CHECK_EQUAL( 0, img2->getData()[1 * 2 * 4 + 0 * 4 + 1]);
CHECK_EQUAL(255, img2->getData()[1 * 2 * 4 + 0 * 4 + 2]);
CHECK_EQUAL(255, img2->getData()[1 * 2 * 4 + 0 * 4 + 3]);
CHECK_EQUAL( 0, img2->getData()[1 * 2 * 4 + 1 * 4 + 0]);
CHECK_EQUAL(255, img2->getData()[1 * 2 * 4 + 1 * 4 + 1]);
CHECK_EQUAL(255, img2->getData()[1 * 2 * 4 + 1 * 4 + 2]);
CHECK_EQUAL(255, img2->getData()[1 * 2 * 4 + 1 * 4 + 3]);
}
// 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;
}
// Initialize GLUT & OpenSG and set up the scene
int doMain(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::ShaderProgramChunkUnrecPtr shl = OSG::ShaderProgramChunk::create();
OSG::ShaderProgramUnrecPtr shl_vp =
OSG::ShaderProgram::createVertexShader();
shl_vp->setProgram(_vp_program);
shl_vp->setProgramAttribute(OSG::ShaderConstants::TexCoordsIndex, "TexCoord0");
shl_vp->setProgramAttribute(OSG::ShaderConstants::NormalsIndex, "Normal" );
shl_vp->setProgramAttribute(OSG::ShaderConstants::PositionsIndex, "Position");
shl->addShader(shl_vp);
OSG::ShaderProgramUnrecPtr shl_fp =
OSG::ShaderProgram::createFragmentShader();
shl_fp->setProgram(_fp_program);
shl->addShader(shl_fp);
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 = new OSG::SimpleSceneManager;
// tell the manager what to manage
_mgr->setWindow(gwin );
_mgr->setRoot(_scene);
// show the whole scene
_mgr->showAll();
return 0;
}
// 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;
}
void initPlaneSetup(void)
{
// beacon for camera and light
OSG::GroupNodeRefPtr beacon = OSG::GroupNodeRefPtr::create();
// transformation
OSG::TransformNodeRefPtr cam_transPlane =
OSG::TransformNodeRefPtr::create();
cam_transPlane.node()->addChild(beacon);
// light
OSG::DirectionalLightNodeRefPtr dl =
OSG::DirectionalLightNodeRefPtr::create();
dl->setAmbient (.3f, .3f, .3f, 1);
dl->setDiffuse ( 1, 1, 1, 1);
dl->setDirection( 0, 0, 1 );
dl->setBeacon (beacon );
// planeRoot
planeRoot = OSG::GroupNodeRefPtr::create();
planeRoot.node()->addChild(cam_transPlane);
planeRoot.node()->addChild(animRoot);
planeRoot.node()->addChild(dl);
// Create plane to project the staged render
OSG::NodeUnrecPtr plane_node = OSG::makePlane(10, 10, 5, 5);
// Setup the shared texture and texture environment
// - Create an empty image so texture can allocate size and memory
OSG::ImageUnrecPtr pImg = OSG::Image::create();
pImg->set(OSG::Image::OSG_RGB_PF, 512, 512);
tx1o->setImage (pImg );
tx1o->setMinFilter(GL_LINEAR );
tx1o->setMagFilter(GL_LINEAR );
tx1o->setWrapS (GL_REPEAT );
tx1o->setWrapT (GL_REPEAT );
tx1e->setEnvMode (GL_REPLACE);
#ifdef USE_DEPTH_TEXTURE
OSG::ImageUnrecPtr dImg = OSG::Image::create();
dImg->set(Image::OSG_L_PF, 512, 512);
txDepth->setImage (dImg);
txDepth->setMinFilter(GL_NEAREST );
txDepth->setMagFilter(GL_LINEAR );
txDepth->setWrapS (GL_CLAMP_TO_EDGE );
txDepth->setWrapT (GL_CLAMP_TO_EDGE );
txDepth->setExternalFormat(GL_DEPTH_COMPONENT);
txDepth->setInternalFormat(GL_DEPTH_COMPONENT32);
#endif
// Material for plane
// - Create a material that will reference the texture and render
// it on the plane
OSG::SimpleMaterialUnrecPtr mat = OSG::SimpleMaterial::create();
mat->setDiffuse(OSG::Color3f(1,1,1));
mat->setLit (false );
#ifdef USE_DEPTH_TEXTURE
mat->addChunk (txDepth );
#else
mat->addChunk (tx1o );
#endif
mat->addChunk (tx1e );
OSG::GeometryUnrecPtr pGeo =
dynamic_cast<OSG::Geometry *>(plane_node->getCore());
pGeo->setMaterial(mat);
// Finish connecting graph
OSG::TransformNodeRefPtr scene_trans = OSG::TransformNodeRefPtr::create();
scene_trans.node()->addChild(plane_node );
dl.node()->addChild(scene_trans);
}