// 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 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 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;
}
void init(int argc, char *argv[])
{
OSG::osgInit(argc, argv);
int glutWinId = setupGLUT(&argc, argv);
// the connection between GLUT and OpenSG
OSG::GLUTWindowUnrecPtr gwin= OSG::GLUTWindow::create();
gwin->setGlutId(glutWinId);
gwin->init();
// load the scene
root = OSG::ChunkOverrideGroup::create();
rootN = OSG::makeNodeFor(root);
if(argc < 2)
{
FWARNING(("No file given!\n"));
FWARNING(("Supported file formats:\n"));
OSG::SceneFileHandler::the()->print();
sceneN = OSG::makeTorus(.5, 2, 16, 16);
}
else
{
/*
All scene file loading is handled via the SceneFileHandler.
*/
sceneN = OSG::SceneFileHandler::the()->read(argv[1]);
}
OSG::TransformUnrecPtr xform = OSG::Transform::create();
OSG::NodeUnrecPtr xformN = OSG::makeNodeFor(xform);
// xform->editMatrix().setTranslate(OSG::Vec3f(100.f, 0.f, 0.f));
// xform->editMatrix().setRotate(OSG::Quaternion(OSG::Vec3f(0.f, 1.f, 0.f), 0.3f * OSG::Pi));
OSG::NodeUnrecPtr boxN = OSG::makeBox(1.f, 1.f, 5.f, 1, 1, 1);
xformN->addChild(sceneN);
rootN ->addChild(xformN);
rootN ->addChild(boxN );
OSG::commitChanges();
// collect geometries in the scene
collectGeometry(rootN);
// construct skin shader
vpSkin = OSG::ShaderProgram::createVertexShader ();
vpSkin->setProgram(vpCode);
fpSkin = OSG::ShaderProgram::createFragmentShader();
fpSkin->setProgram(fpCode);
shSkin = OSG::ShaderProgramChunk::create();
shSkin->addShader(vpSkin);
shSkin->addShader(fpSkin);
matSkin = OSG::ChunkMaterial::create();
matSkin->addChunk(shSkin);
// process animations
processAnim(sceneN);
// create the SimpleSceneManager helper
mgr = OSG::SimpleSceneManager::create();
// tell the manager what to manage
mgr->setWindow(gwin );
mgr->setRoot (rootN);
// show the whole scene
mgr->showAll();
}
// 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;
}
