int main (int argc, char **argv)
{
osgInit(argc,argv);
// GLUT init
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
int id=glutCreateWindow("OpenSG");
glutReshapeFunc(reshape);
glutDisplayFunc(display);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutKeyboardFunc(keyboard);
GLUTWindowPtr gwin=GLUTWindow::create();
gwin->setId(id);
gwin->init();
// create the scene
NodePtr scene = Node::create();
beginEditCP(scene);
scene->setCore(Group::create());
endEditCP(scene);
// create the SimpleSceneManager helper
_mgr = new SimpleSceneManager;
// tell the manager what to manage
_mgr->setWindow(gwin );
_mgr->setRoot (scene);
// create the geometry.
NodePtr plane = makePlane( 1, 1, 2, 2 );
NodePtr torus = makeTorus( .2, 1, 16, 8 );
GeometryPtr plane_geo, torus_geo;
plane_geo = GeometryPtr::dcast(plane->getCore());
torus_geo = GeometryPtr::dcast(torus->getCore());
PolygonChunkPtr pchunk = PolygonChunk::create();
beginEditCP(pchunk);
pchunk->setFrontMode(GL_LINE);
pchunk->setBackMode(GL_LINE);
pchunk->setOffsetFactor(-1.0);
pchunk->setOffsetLine(true);
endEditCP(pchunk);
// create materials for the plane.
SimpleMaterialPtr pm1 = SimpleMaterial::create();
beginEditCP(pm1);
pm1->setDiffuse( Color3f( 0,1,0 ) );
pm1->setAmbient( Color3f( 0,1,0 ) );
pm1->setSpecular( Color3f( 0,0,0 ) );
endEditCP(pm1);
SimpleMaterialPtr pm2 = SimpleMaterial::create();
beginEditCP(pm2);
pm2->setDiffuse( Color3f( 1,0,0 ) );
pm2->setAmbient( Color3f( 1,0,0 ) );
pm2->setSpecular( Color3f( 0,0,0 ) );
pm2->addChunk(pchunk);
endEditCP(pm2);
MultiPassMaterialPtr mppm = MultiPassMaterial::create();
beginEditCP(mppm);
mppm->addMaterial(pm1);
mppm->addMaterial(pm2);
endEditCP(mppm);
plane_geo->setMaterial(mppm);
// create materials for the torus.
SimpleMaterialPtr tm1 = SimpleMaterial::create();
beginEditCP(tm1);
tm1->setDiffuse( Color3f( 0,0,1 ) );
tm1->setAmbient( Color3f( 0,0,1 ) );
tm1->setTransparency(0.6);
endEditCP(tm1);
SimpleMaterialPtr tm2 = SimpleMaterial::create();
beginEditCP(tm2);
tm2->setDiffuse( Color3f( 1,0,0 ) );
tm2->setAmbient( Color3f( 1,0,0 ) );
tm2->setSpecular( Color3f( 0,0,0 ) );
tm2->addChunk(pchunk);
endEditCP(tm2);
MultiPassMaterialPtr mptm = MultiPassMaterial::create();
beginEditCP(mptm);
mptm->addMaterial(tm1);
mptm->addMaterial(tm2);
endEditCP(mptm);
torus_geo->setMaterial( mptm );
beginEditCP(scene);
scene->addChild(plane);
scene->addChild(torus);
endEditCP(scene);
// show the whole scene
_mgr->showAll();
// GLUT main loop
glutMainLoop();
return 0;
}
ChunkMaterialPtr vtkOsgConverter::CreateMaterial(bool lit, bool hasTexCoords)
{
if (_verbose)
std::cout << "Start CreateMaterial()" << std::endl;
vtkProperty* prop = _actor->GetProperty();
double* diffuseColor = prop->GetDiffuseColor();
double* ambientColor = prop->GetAmbientColor();
double* specularColor = prop->GetSpecularColor();
double specularPower = prop->GetSpecularPower();
double diffuse = prop->GetDiffuse();
double ambient = prop->GetAmbient();
double specular = prop->GetSpecular();
double opacity = prop->GetOpacity();
float pointSize = prop->GetPointSize();
float lineWidth = prop->GetLineWidth();
// int lineStipplePattern = prop->GetLineStipplePattern();
int representation = prop->GetRepresentation();
if (_verbose)
{
std::cout << " Colors:" << std::endl;
std::cout << " diffuse " << diffuse << " * " << diffuseColor[0] << " " <<
diffuseColor[1] << " " << diffuseColor[2] << std::endl;
std::cout << " ambient " << ambient << " * " << ambientColor[0] << " " <<
ambientColor[1] << " " << ambientColor[2] << std::endl;
std::cout << " specular " << specular << " * " << specularColor[0] << " " <<
specularColor[1] << " " << specularColor[2] << std::endl;
}
PolygonChunkPtr polygonChunk = PolygonChunk::create();
beginEditCP(polygonChunk);
{
if (representation == VTK_SURFACE)
{
polygonChunk->setFrontMode(GL_FILL);
polygonChunk->setBackMode(GL_FILL);
}
else if (representation == VTK_WIREFRAME)
{
polygonChunk->setFrontMode(GL_LINE);
polygonChunk->setBackMode(GL_LINE);
}
else
{
polygonChunk->setFrontMode(GL_POINT);
polygonChunk->setBackMode(GL_POINT);
}
} endEditCP(polygonChunk);
MaterialChunkPtr osgMaterialChunk = MaterialChunk::create();
beginEditCP(osgMaterialChunk);
{
osgMaterialChunk->setDiffuse(Color4f(diffuseColor[0] * diffuse, diffuseColor[1] *
diffuse, diffuseColor[2] * diffuse, opacity));
osgMaterialChunk->setSpecular(Color4f(specularColor[0] * specular,
specularColor[1] * specular,
specularColor[2] * specular, 1.0));
osgMaterialChunk->setAmbient(Color4f(ambientColor[0] * ambient, ambientColor[1] *
ambient, ambientColor[2] * ambient, opacity));
osgMaterialChunk->setShininess(specularPower);
//if(opacity < 1.0)
//{
// osgMaterialChunk->setColorMaterial(GL_AMBIENT); // HACK: Opacity does not work with GL_AMBIENT_AND_DIFFUSE
//osgMaterialChunk->setTransparency(1.0f - opacity);
//}
//else
osgMaterialChunk->setColorMaterial(GL_AMBIENT_AND_DIFFUSE);
// On objects consisting only of points or lines, dont lit
if(!lit)
osgMaterialChunk->setLit(false);
} endEditCP(osgMaterialChunk);
ChunkMaterialPtr osgChunkMaterial = ChunkMaterial::create();
beginEditCP(osgChunkMaterial);
{
osgChunkMaterial->addChunk(osgMaterialChunk);
osgChunkMaterial->addChunk(TwoSidedLightingChunk::create());
osgChunkMaterial->addChunk(polygonChunk);
if(pointSize > 1.0f)
{
PointChunkPtr pointChunk = PointChunk::create();
pointChunk->setSize(pointSize);
osgChunkMaterial->addChunk(pointChunk);
}
if(lineWidth > 1.0f)
{
LineChunkPtr lineChunk = LineChunk::create();
lineChunk->setWidth(lineWidth);
osgChunkMaterial->addChunk(lineChunk);
}
// TEXTURE
if (hasTexCoords)
{
vtkTexture* vtkTexture = _actor->GetTexture();
if (vtkTexture)
{
TextureChunkPtr osgTextureChunk = NullFC;
osgTextureChunk = CreateTexture(vtkTexture);
if(osgTextureChunk != NullFC)
{
if (_verbose)
std::cout << " Add TextureChunk" << std::endl;
osgChunkMaterial->addChunk(osgTextureChunk);
}
// Per default EnvMode is set to GL_REPLACE which does not lit the surface
beginEditCP(osgTextureChunk);
osgTextureChunk->setEnvMode(GL_MODULATE);
endEditCP(osgTextureChunk);
}
}
} endEditCP(osgChunkMaterial);
if (_verbose)
std::cout << "End CreateMaterial()" << std::endl;
return osgChunkMaterial;
}
void
display(void)
{
float t = glutGet( GLUT_ELAPSED_TIME );
win->frameInit();
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
Matrix m;
Quaternion q;
q.setValueAsAxisDeg( 0,1,0, -t/20 );
m.setRotate( q );
tchunk1->setMatrix( m );
tchunk1->activate( dact );
mchunk1->activate( dact );
pchunk1->activate( dact );
lichunk1->activate( dact );
glCallList( dlid );
m.setIdentity();
m.setTranslate( cos(t/1000), 0, sin(t/1000) );
tchunk2->setMatrix( m );
pchunk2->changeFrom( dact, get_pointer(pchunk1) );
tchunk2->changeFrom( dact, get_pointer(tchunk1) );
mchunk2->changeFrom( dact, get_pointer(mchunk1) );
lichunk2->changeFrom( dact, get_pointer(lichunk1) );
blchunk->activate( dact );
glCallList( dlid );
tchunk2->deactivate( dact );
mchunk2->deactivate( dact );
pchunk2->deactivate( dact );
lichunk2->deactivate( dact );
blchunk->deactivate( dact );
xchunk1->activate( dact );
txchunk->activate( dact );
#if 0
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_PASS_THROUGH_NV);
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV,34102
);
glTexEnvf(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_SCALE_NV, 0.0000 );
glTexEnvf(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_BIAS_NV, 0.0000 );
glEnable(GL_TEXTURE_SHADER_NV);
GLint consistent;
glGetTexEnviv(GL_TEXTURE_SHADER_NV, GL_SHADER_CONSISTENT_NV,
&consistent);
if(!consistent)
{
FWARNING(("Texture shaders not consistent!\n"));
}
#endif
glCallList( dlid2 );
// glDisable(GL_TEXTURE_SHADER_NV);
xchunk1->deactivate( dact );
txchunk->deactivate( dact );
win->frameExit();
glutSwapBuffers();
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// GLUT init
int winid = setupGLUT(&argc, argv);
gwin = GLUTWindow::create();
// create root
rootNode = makeCoredNode<Group>();
NodePtr scene = makeCoredNode<Group>();
// create lights
TransformPtr point1_trans;
NodePtr point1 = makeCoredNode<PointLight>(&_point1_core);
NodePtr point1_beacon = makeCoredNode<Transform>(&point1_trans);
beginEditCP(point1_trans);
point1_trans->editMatrix().setTranslate(0.0, 0.0, 25.0);
endEditCP(point1_trans);
beginEditCP(_point1_core);
_point1_core->setAmbient(0.15,0.15,0.15,1);
_point1_core->setDiffuse(0.4,0.4,0.4,1);
_point1_core->setSpecular(0.0,0.0,0.0,1);
_point1_core->setBeacon(point1_beacon);
_point1_core->setOn(true);
endEditCP(_point1_core);
TransformPtr point2_trans;
NodePtr point2 = makeCoredNode<PointLight>(&_point2_core);
NodePtr point2_beacon = makeCoredNode<Transform>(&point2_trans);
beginEditCP(point2_trans);
point2_trans->editMatrix().setTranslate(5.0, 5.0, 20.0);
endEditCP(point2_trans);
beginEditCP(_point2_core);
_point2_core->setAmbient(0.15,0.15,0.15,1);
_point2_core->setDiffuse(0.4,0.4,0.4,1);
_point2_core->setSpecular(0.0,0.0,0.0,1);
_point2_core->setBeacon(point2_beacon);
_point2_core->setOn(true);
endEditCP(_point2_core);
beginEditCP(point1);
point1->addChild(point2);
endEditCP(point1);
beginEditCP(point2);
point2->addChild(scene);
endEditCP(point2);
// create scene
// bottom
NodePtr plane = makePlane(25.0, 25.0, 128, 128);
int size = imageWinWidth*imageWinHeight*256;
ImagePtr plane_img = Image::create();
beginEditCP(plane_img);
plane_img->set(Image::OSG_RGBA_PF, imageWinWidth, imageWinHeight, 1, 1, 1, 0, NULL);
endEditCP(plane_img);
TextureChunkPtr plane_tex = TextureChunk::create();
beginEditCP(plane_tex);
plane_tex->setImage(plane_img);
plane_tex->setMinFilter(GL_LINEAR);
plane_tex->setMagFilter(GL_LINEAR);
plane_tex->setTarget(GL_TEXTURE_2D);
plane_tex->setInternalFormat(GL_RGBA16F_ARB);
endEditCP(plane_tex);
SHLChunkPtr shl = SHLChunk::create();
beginEditCP(shl);
shl->setVertexProgram(_vp_program);
shl->setFragmentProgram(_fp_program);
shl->setUniformParameter("tex0", 0);
endEditCP(shl);
SimpleMaterialPtr plane_mat = SimpleMaterial::create();
beginEditCP(plane_mat);
plane_mat->setAmbient(Color3f(0.3,0.3,0.3));
plane_mat->setDiffuse(Color3f(1.0,1.0,1.0));
plane_mat->addChunk(plane_tex);
plane_mat->addChunk(shl);
endEditCP(plane_mat);
GeometryPtr plane_geo = GeometryPtr::dcast(plane->getCore());
beginEditCP(plane_geo);
plane_geo->setMaterial(plane_mat);
beginEditCP(plane_geo);
// box
box_trans_node = makeCoredNode<Transform>(&_box_trans);
beginEditCP(_box_trans);
_box_trans->editMatrix().setTranslate(0.0, 0.0, 12.0);
endEditCP(_box_trans);
NodePtr box = makeBox(4.0, 4.0, 0.8, 10, 10 , 10);
beginEditCP(box_trans_node);
box_trans_node->addChild(box);
endEditCP(box_trans_node);
PolygonChunkPtr pchunk = osg::PolygonChunk::create();
beginEditCP(pchunk);
pchunk->setCullFace(GL_BACK);
endEditCP(pchunk);
SimpleMaterialPtr box_mat = SimpleMaterial::create();
beginEditCP(box_mat);
box_mat->setAmbient(Color3f(0.0,0.0,0.0));
box_mat->setDiffuse(Color3f(0.0,0.0,1.0));
box_mat->addChunk(pchunk);
endEditCP(box_mat);
GeometryPtr box_geo = GeometryPtr::dcast(box->getCore());
beginEditCP(box_geo);
box_geo->setMaterial(box_mat);
beginEditCP(box_geo);
// cylinder1
NodePtr cylinder1_trans_node = makeCoredNode<Transform>(&_cylinder1_trans);
beginEditCP(_cylinder1_trans);
_cylinder1_trans->editMatrix().setTranslate(0.0, 0.0, 5.0);
endEditCP(_cylinder1_trans);
NodePtr cylinder1 = OSG::makeCylinder(10.0, 0.4, 32, true, true ,true);
beginEditCP(cylinder1_trans_node);
cylinder1_trans_node->addChild(cylinder1);
endEditCP(cylinder1_trans_node);
SimpleMaterialPtr cylinder1_mat = SimpleMaterial::create();
beginEditCP(cylinder1_mat);
cylinder1_mat->setAmbient(Color3f(0.0,0.0,0.0));
cylinder1_mat->setDiffuse(Color3f(1.0,0.0,0.0));
cylinder1_mat->addChunk(pchunk);
endEditCP(cylinder1_mat);
GeometryPtr cylinder1_geo = GeometryPtr::dcast(cylinder1->getCore());
beginEditCP(cylinder1_geo);
cylinder1_geo->setMaterial(cylinder1_mat);
beginEditCP(cylinder1_geo);
// cylinder2
NodePtr cylinder2_trans_node = makeCoredNode<Transform>(&_cylinder2_trans);
beginEditCP(_cylinder2_trans);
_cylinder2_trans->editMatrix().setTranslate(0.0, 0.0, 8.0);
endEditCP(_cylinder2_trans);
NodePtr cylinder2 = OSG::makeCylinder(10.0, 0.4, 32, true, true ,true);
beginEditCP(cylinder2_trans_node);
cylinder2_trans_node->addChild(cylinder2);
endEditCP(cylinder2_trans_node);
SimpleMaterialPtr cylinder2_mat = SimpleMaterial::create();
beginEditCP(cylinder2_mat);
cylinder2_mat->setAmbient(Color3f(0.0,0.0,0.0));
cylinder2_mat->setDiffuse(Color3f(0.0,1.0,0.0));
cylinder2_mat->addChunk(pchunk);
endEditCP(cylinder2_mat);
GeometryPtr cylinder2_geo = GeometryPtr::dcast(cylinder2->getCore());
beginEditCP(cylinder2_geo);
cylinder2_geo->setMaterial(cylinder2_mat);
beginEditCP(cylinder2_geo);
// scene
beginEditCP(scene);
scene->addChild(plane);
scene->addChild(box_trans_node);
scene->addChild(cylinder1_trans_node);
scene->addChild(cylinder2_trans_node);
endEditCP(scene);
vp = ShadowViewport::create();
GradientBackgroundPtr gbg = GradientBackground::create();
SolidBackgroundPtr sbg = SolidBackground::create();
UChar8 imgdata[] = { 255,0,0, 0,255,0, 0,0,255, 255,255,0 };
ImagePtr img1 = Image::create();
img1->set(Image::OSG_RGB_PF, 2, 2, 1, 1, 1, 0, imgdata);
TextureChunkPtr tcPtr = TextureChunk::create();
beginEditCP(tcPtr);
tcPtr->setImage(img1);
endEditCP(tcPtr);
TextureBackgroundPtr bkg = TextureBackground::create();
beginEditCP(bkg);
bkg->setTexture(tcPtr);
endEditCP(bkg);
beginEditCP(sbg);
sbg->setColor(Color3f(0.2,0.4,0.6));
endEditCP(sbg);
beginEditCP(gbg);
gbg->addLine(Color3f(0.7, 0.7, 0.8), 0);
gbg->addLine(Color3f(0.1, 0.1, 0.3), 1);
endEditCP(gbg);
beginEditCP(rootNode);
rootNode->addChild(point1);
rootNode->addChild(point1_beacon);
rootNode->addChild(point2_beacon);
endEditCP(rootNode);
//FBOViewportPtr
fbo_vp = FBOViewport::create();
addRefCP(fbo_vp);
// the Camera for the map
cam = PerspectiveCamera::create();
beginEditCP(cam);
cam->setFov(osgdegree2rad(90));
cam->setAspect(1);
cam->setNear(0.001);
cam->setFar(10000);
cam->setBeacon(box_trans_node);
endEditCP(cam);
beginEditCP(fbo_vp);
fbo_vp->setBackground(bkg);
fbo_vp->setRoot(rootNode);
fbo_vp->setCamera(cam);
fbo_vp->setSize(0,0,imageWinWidth-1, imageWinHeight-1);
fbo_vp->setStorageWidth(imageWinWidth);
fbo_vp->setStorageHeight(imageWinHeight);
fbo_vp->setDirty(true);
fbo_vp->editMFTextures ()->push_back(plane_tex);
fbo_vp->editMFExcludeNodes()->push_back(plane);
fbo_vp->setFboOn(true);
endEditCP(fbo_vp);
// normal shadow viewport
beginEditCP(vp);
vp->setBackground(gbg);
vp->setRoot(rootNode);
vp->setSize(0,0,1,1);
endEditCP(vp);
beginEditCP(gwin); //Window
gwin->setId(winid);
gwin->addPort(vp);
gwin->init();
endEditCP(gwin);
Vec3f min,max;
rootNode->updateVolume();
rootNode->getVolume().getBounds( min, max );
// create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
mgr->setWindow(gwin);
mgr->setRoot(rootNode);
//Viewport
beginEditCP(vp);
vp->setCamera(mgr->getCamera());
endEditCP(vp);
mgr->turnHeadlightOff();
mgr->showAll();
// GLUT main loop
glutMainLoop();
return 0;
}
int main( int argc, char *argv[] )
{
osgInit(argc, argv);
glutInit(&argc, argv);
glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutCreateWindow("OpenSG");
glutKeyboardFunc(key);
// glutReshapeFunc(resize);
glutDisplayFunc(display);
// glutMouseFunc(mouse);
// glutMotionFunc(motion);
glutIdleFunc(display);
pImage = Image::create();
// create the dummy structures
// the window is needed for the chunks that access GLObjects
win = GLUTWindow::create();
win->frameInit(); // test for preliminary calls not messing up GLexts
win->init();
dact = DrawAction::create();
dact->setWindow(get_pointer(win));
win->init();
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
gluPerspective( 60, 1, 0.1, 10 );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
gluLookAt( 3, 3, 3, 0, 0, 0, 0, 1, 0 );
glEnable( GL_DEPTH_TEST );
glEnable( GL_LIGHTING );
glEnable( GL_LIGHT0 );
glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
dlid = glGenLists( 1 );
glNewList( dlid, GL_COMPILE );
glutSolidSphere( .8, 8, 8 );
glEndList();
dlid2 = glGenLists( 1 );
glNewList( dlid2, GL_COMPILE );
glBegin( GL_POLYGON );
glNormal3f( 0, 1, 0 );
glColor3f( 1, 1, 1 );
glTexCoord2f( 0, 0 );
glVertex3f( -1.5, -1, -1.5 );
glTexCoord2f( 2, 0 );
glVertex3f( 1.5, -1, -1.5 );
glTexCoord2f( 2, 2 );
glVertex3f( 1.5, -1, 1.5 );
glTexCoord2f( 0, 2 );
glVertex3f( -1.5, -1, 1.5 );
glEnd();
glEndList();
Matrix m;
tchunk1 = TransformChunk::create();
m.setTranslate( 0, 1, 0 );
tchunk1->setMatrix( m );
tchunk2 = TransformChunk::create();
tchunk2->setMatrix( Matrix::identity() );
mchunk1 = MaterialChunk::create();
mchunk1->setDiffuse( Color4f( 1,0,0,0 ) );
mchunk1->setAmbient( Color4f( 1,0,0,0 ) );
mchunk1->setShininess( 20 );
mchunk2 = MaterialChunk::create();
mchunk2->setDiffuse( Color4f( 0,1,0,0 ) );
mchunk2->setAmbient( Color4f( 0,1,0,0 ) );
mchunk2->setShininess( 50 );
// Texture chunk
// UChar8 imgdata[] =
// { 255,0,0,0, 0,255,0,0, 0,0,255,255, 255,255,255,255 };
UChar8 imgdata[] =
{ 255,0,0, 255,0,0, 255,0,255,
255,0,0, 255,0,0, 255,0,255,
255,255,0, 255,255,0, 255,255,255,
255,255,0, 255,255,0, 255,255,255, };
// UChar8 limgdata[] =
// { 0, 128, 64, 255 };
pImage->set( Image::OSG_RGB_PF, 2, 2, 1, 1, 1, 0, imgdata );
if ( argc > 1 )
pImage->read( argv[1] );
xchunk1 = TextureChunk::create();
beginEditCP(xchunk1);
xchunk1->setImage( pImage ); // NOTE: the image is NOT copied, the variable
// needs to be kept around as long as the
// texture is used
xchunk1->setMinFilter( GL_LINEAR );
xchunk1->setMagFilter( GL_NEAREST );
xchunk1->setWrapS( GL_REPEAT );
xchunk1->setWrapT( GL_REPEAT );
xchunk1->setEnvMode( GL_REPLACE );
xchunk1->setEnvColor( Color4f(.5,.5,.5,0) );
xchunk1->setScale( false );
// xchunk1->setShaderOperation(GL_PASS_THROUGH_NV);
endEditCP(xchunk1);
xchunk1->imageContentChanged();
beginEditCP(xchunk1);
xchunk1->setImage( pImage );
endEditCP(xchunk1);
// blend chunk
blchunk = BlendChunk::create();
#ifdef GL_EXT_blend_color
blchunk->setSrcFactor( GL_CONSTANT_ALPHA );
blchunk->setDestFactor( GL_ONE_MINUS_CONSTANT_ALPHA );
#endif
blchunk->setColor( Color4f( .5,.5,.5,0.1 ) );
blchunk->setEquation(GL_FUNC_SUBTRACT);
std::cout << "BlendChunk is trans:" << blchunk->isTransparent() << std::endl;
// texture transform chunk
txchunk = TextureTransformChunk::create();
beginEditCP(txchunk);
txchunk->setMatrix( Matrix(4,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1) );
endEditCP(txchunk);
// polygon chunk
pchunk1 = PolygonChunk::create();
{
UInt32 stipple[32] = {
0xffff0000, 0x0000ffff, 0xffff0000, 0x0000ffff,
0xffff0000, 0x0000ffff, 0xffff0000, 0x0000ffff,
0xffff0000, 0x0000ffff, 0xffff0000, 0x0000ffff,
0xffff0000, 0x0000ffff, 0xffff0000, 0x0000ffff,
0xffff0000, 0x0000ffff, 0xffff0000, 0x0000ffff,
0xffff0000, 0x0000ffff, 0xffff0000, 0x0000ffff,
0xffff0000, 0x0000ffff, 0xffff0000, 0x0000ffff,
0xffff0000, 0x0000ffff, 0xffff0000, 0x0000ffff
};
pchunk1->editMFStipple()->clear();
for ( int i = 0; i < 32; i++ )
pchunk1->editMFStipple()->push_back( stipple[i] );
}
pchunk1->setFrontMode(GL_LINE);
pchunk1->setBackMode(GL_FILL);
pchunk2 = PolygonChunk::create();
{
UInt32 stipple[32] = {
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
};
pchunk2->editMFStipple()->clear();
for ( int i = 0; i < 32; i++ )
pchunk2->editMFStipple()->push_back( stipple[i] );
}
lichunk1 = LineChunk::create();
lichunk1->setSmooth(true);
lichunk1->setStipplePattern(0xf0f0);
lichunk2 = LineChunk::create();
lichunk2->setStippleRepeat(5);
lichunk2->setStipplePattern(0xaaaa);
glutMainLoop();
return 0;
}
