MaterialPtr createVideoMaterial(void)
{
// Ok, now for the meat of the code...
// first we need an Image to hold the picture(s) to show
//image = Image::create();
//beginEditCP(image);
//{
// set the image's size and type, and allocate memory
// this example uses RGB. On some systems (e.g. Windows) BGR
// or BGRA might be faster, it depends on how the images are
// acquired
// image->set(Image::OSG_RGB_PF, 2, 2);
//}
//endEditCP(image);
// Now create the texture to be used for the background
tex = TextureChunk::create();
beginEditCP(tex);
{
// Associate image and texture
//tex->setImage(image);
// Set filtering modes. LINEAR is cheap and good if the image size
// changes very little (i.e. the window is about the same size as
// the images).
//tex->setMinFilter(GL_LINEAR);
tex->setMinFilter(GL_NEAREST);
tex->setMagFilter(GL_LINEAR);
//tex->setMagFilter(GL_NEAREST);
// Set the wrapping modes. We don't need repetition, it might actually
// introduce artifactes at the borders, so switch it off.
tex->setWrapS(GL_CLAMP_TO_EDGE);
tex->setWrapT(GL_CLAMP_TO_EDGE);
// Newer versions of OpenGl can handle NPOT textures directly.
// OpenSG will do that internally automatically.
//
// Older versions need POT textures. By default OpenSG
// will scale an NPOT texture to POT while defining it.
// For changing textures that's too slow.
// So tell OpenSG not to scale the image, but use the texture
// matrix to scale. This only works if we're not using the
// texture matrix for anything else, which is fine for video
// backgrounds.
// This does not do anything if NPOT textures are supported, so
// it is safe to just set it.
tex->setScale(false);
tex->setNPOTMatrixScale(true);
}
endEditCP(tex);
ChunkMaterialPtr TheMaterial = ChunkMaterial::create();
beginEditCP(TheMaterial, ChunkMaterial::ChunksFieldMask);
TheMaterial->addChunk(tex);
TheMaterial->addChunk(MaterialChunk::create());
endEditCP(TheMaterial, ChunkMaterial::ChunksFieldMask);
return TheMaterial;
}
int main(int argc, char **argv)
{
osgInit(argc,argv);
// GLUT init
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutCreateWindow("OpenSG");
glutReshapeFunc(reshape);
glutDisplayFunc(display);
glutIdleFunc(idle);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutKeyboardFunc(keyboard);
PassiveWindowPtr pwin=PassiveWindow::create();
pwin->init();
// create the texture
tx1 = TextureChunk::create();
const UInt16 width = 16, height = 1;
ImagePtr pImg1 = Image::create();
pImg1->set(Image::OSG_RGB_PF, width, height );
beginEditCP(pImg1);
UInt8 *d = pImg1->editData();
for(UInt16 y = 0; y < height; ++y)
{
for(UInt16 x = 0; x < width; ++x)
{
*d++ = static_cast<UInt8>(x * 255.f / width);
*d++ = static_cast<UInt8>(y * 255.f / height);
*d++ = static_cast<UInt8>(128);
}
}
endEditCP(pImg1);
beginEditCP(tx1);
tx1->setImage(pImg1);
tx1->setMinFilter(GL_NEAREST);
tx1->setMagFilter(GL_NEAREST);
tx1->setWrapS(GL_REPEAT);
tx1->setWrapT(GL_REPEAT);
endEditCP(tx1);
tg = TexGenChunk::create();
beginEditCP(tg);
tg->setGenFuncS(GL_EYE_LINEAR);
tg->setGenFuncSPlane(Vec4f(0,.15,0,0));
endEditCP(tg);
// create the material
SimpleMaterialPtr mat = SimpleMaterial::create();
beginEditCP(mat);
mat->setDiffuse(Color3f(1,1,1));
mat->setLit(false);
mat->addChunk(tx1);
mat->addChunk(tg);
endEditCP(mat);
// create the scene
NodePtr torus = makeTorus( .5, 2, 16, 32 );
GeometryPtr geo = GeometryPtr::dcast(torus->getCore());
beginEditCP(geo, Geometry::MaterialFieldMask);
geo->setMaterial(mat);
endEditCP(geo, Geometry::MaterialFieldMask);
transn1 = makeCoredNode<Transform>(&trans1);
beginEditCP(transn1, Node::CoreFieldMask | Node::ChildrenFieldMask);
{
transn1->addChild(torus);
}
endEditCP (transn1, Node::CoreFieldMask | Node::ChildrenFieldMask);
transn2 = makeCoredNode<Transform>(&trans2);
NodePtr scene = makeCoredNode<Group>();
beginEditCP(scene);
scene->addChild(transn1);
scene->addChild(transn2);
endEditCP(scene);
beginEditCP(tg);
tg->setSBeacon(torus);
endEditCP(tg);
// create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// create the window and initial camera/viewport
mgr->setWindow(pwin );
// tell the manager what to manage
mgr->setRoot (scene);
// show the whole scene
mgr->showAll();
mgr->redraw();
webInterface = new WebInterface();
webInterface->setRoot(scene);
// GLUT main loop
glutMainLoop();
return 0;
}
void updateScene()
{
statfg->editCollector().getElem(majorAlignDesc)->set(alignmentToString(layoutParam.majorAlignment));
statfg->editCollector().getElem(minorAlignDesc)->set(alignmentToString(layoutParam.minorAlignment));
statfg->editCollector().getElem(dirDesc)->set(layoutParam.horizontal ? "Horizontal" : "Vertical");
statfg->editCollector().getElem(horiDirDesc)->set(layoutParam.leftToRight ? "Left to right" : "Right to left");
statfg->editCollector().getElem(vertDirDesc)->set(layoutParam.topToBottom ? "Top to bottom" : "Bottom to top");
if(face == NULL)
return;
// Put it all together into a Geometry NodeCore.
TextLayoutResult layoutResult;
Real32 scale = 2.f;
face->layout(lines, layoutParam, layoutResult);
#if 0
GeometryPtr geo = Geometry::create();
face->fillGeo(geo, layoutResult, scale);
NodePtr textNode = Node::create();
beginEditCP(textNode, Node::CoreFieldMask);
{
textNode->setCore(geo);
}
endEditCP(textNode, Node::CoreFieldMask);
#else
NodePtr textNode = face->makeNode(layoutResult, scale);
GeometryPtr geo = GeometryPtr::dcast(textNode->getCore());
#endif
NodePtr transNodePtr = Node::create();
TransformPtr transPtr = Transform::create();
Matrix transMatrix;
transMatrix.setTranslate(0.f, 0.f, -0.03f);
beginEditCP(transPtr);
{
transPtr->setMatrix(transMatrix);
}
endEditCP(transPtr);
beginEditCP(transNodePtr, Node::CoreFieldMask | Node::ChildrenFieldMask);
{
transNodePtr->setCore(transPtr);
transNodePtr->addChild(textNode);
}
endEditCP(transNodePtr, Node::CoreFieldMask | Node::ChildrenFieldMask);
ImagePtr imagePtr = face->getTexture();
TextureChunkPtr texChunk = TextureChunk::create();
beginEditCP(texChunk);
{
texChunk->setImage(imagePtr);
texChunk->setWrapS(GL_CLAMP);
texChunk->setWrapT(GL_CLAMP);
texChunk->setMagFilter(GL_NEAREST);
texChunk->setMinFilter(GL_NEAREST);
texChunk->setEnvMode(GL_MODULATE);
}
endEditCP(texChunk);
MaterialChunkPtr matChunk = MaterialChunk::create();
beginEditCP(matChunk);
{
matChunk->setAmbient(Color4f(1.f, 1.f, 1.f, 1.f));
matChunk->setDiffuse(Color4f(1.f, 1.f, 1.f, 1.f));
matChunk->setEmission(Color4f(0.f, 0.f, 0.f, 1.f));
matChunk->setSpecular(Color4f(0.f, 0.f, 0.f, 1.f));
matChunk->setShininess(0);
}
endEditCP(matChunk);
BlendChunkPtr blendChunk = BlendChunk::create();
beginEditCP(blendChunk);
{
blendChunk->setSrcFactor(GL_SRC_ALPHA);
blendChunk->setDestFactor(GL_ONE_MINUS_SRC_ALPHA);
}
endEditCP(blendChunk);
ChunkMaterialPtr m = ChunkMaterial::create();
beginEditCP(m);
{
m->addChunk(texChunk);
m->addChunk(matChunk);
m->addChunk(blendChunk);
}
endEditCP(m);
beginEditCP(geo, Geometry::MaterialFieldMask);
{
geo->setMaterial(m);
}
endEditCP(geo, Geometry::MaterialFieldMask);
beginEditCP(scene, Node::ChildrenFieldMask);
{
scene->editMFChildren()->clear();
scene->addChild(createCoordinateCross());
scene->addChild(createMetrics(face, scale, layoutParam, layoutResult));
scene->addChild(transNodePtr);
}
endEditCP(scene, Node::ChildrenFieldMask);
mgr->showAll();
glutPostRedisplay();
}
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, 24, 24 );
glEndList();
dlid2 = glGenLists( 1 );
glNewList( dlid2, GL_COMPILE );
glBegin( GL_POLYGON );
glNormal3f( 0, 1, 0 );
glColor3f( 1, 1, 1 );
glTexCoord3f( 0, 0, 0 );
glVertex3f( -1.5, -1, -1.5 );
glTexCoord3f( 2, 0, 0 );
glVertex3f( 1.5, -1, -1.5 );
glTexCoord3f( 2, 2, 2 );
glVertex3f( 1.5, -1, 1.5 );
glTexCoord3f( 0, 2, 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 );
xchunk1->setMinFilter( GL_LINEAR );
xchunk1->setMagFilter( GL_NEAREST );
xchunk1->setWrapS( GL_REPEAT );
xchunk1->setWrapT( GL_REPEAT );
xchunk1->setEnvMode( GL_REPLACE );
xchunk1->setScale( false );
endEditCP(xchunk1);
xchunk1->imageContentChanged();
beginEditCP(xchunk1);
xchunk1->setImage( pImage );
xchunk1->setLodBias( 10 );
endEditCP(xchunk1);
UChar8 imgdata2[] =
{ 255,0,0, 0,255,0, 0,0,255, 255,255,255 };
ImagePtr pImage2 = Image::create();
pImage2->set(Image::OSG_RGB_PF, 2, 2, 1, 1, 1, 0, imgdata2);
xchunk2 = TextureChunk::create();
beginEditCP(xchunk2);
xchunk2->setImage( pImage2 );
xchunk2->setMinFilter( GL_LINEAR );
xchunk2->setMagFilter( GL_NEAREST );
xchunk2->setWrapS( GL_REPEAT );
xchunk2->setWrapT( GL_REPEAT );
xchunk2->setEnvMode( GL_MODULATE );
xchunk2->setLodBias( 10 );
endEditCP(xchunk2);
// Cube Texture chunk
UChar8 negz[] = { 255,0,0, 128,0,0, 64,0,0, 255,255,255 },
posz[] = { 0,255,0, 0,128,0, 0,64,0, 255,255,255 },
negy[] = { 0,0,255, 0,0,128, 0,0,64, 255,255,255 },
posy[] = { 255,255,0, 128,128,0, 64,64,0, 255,255,255 },
negx[] = { 255,0,255, 128,0,128, 64,0,64, 255,255,255 },
posx[] = { 0,255,255, 0,128,128, 0,64,64, 255,255,255 };
ImagePtr inegz = Image::create();
ImagePtr iposz = Image::create();
ImagePtr inegy = Image::create();
ImagePtr iposy = Image::create();
ImagePtr inegx = Image::create();
ImagePtr iposx = Image::create();
inegz->set( Image::OSG_RGB_PF, 2, 2, 1, 1, 1, 0, negz );
iposz->set( Image::OSG_RGB_PF, 2, 2, 1, 1, 1, 0, posz );
inegy->set( Image::OSG_RGB_PF, 2, 2, 1, 1, 1, 0, negy );
iposy->set( Image::OSG_RGB_PF, 2, 2, 1, 1, 1, 0, posy );
inegx->set( Image::OSG_RGB_PF, 2, 2, 1, 1, 1, 0, negx );
iposx->set( Image::OSG_RGB_PF, 2, 2, 1, 1, 1, 0, posx );
cchunk1 = CubeTextureChunk::create();
beginEditCP(cchunk1);
cchunk1->setImage( inegz );
cchunk1->setPosZImage( iposz );
cchunk1->setPosYImage( iposy );
cchunk1->setNegYImage( inegy );
cchunk1->setPosXImage( iposx );
cchunk1->setNegXImage( inegx );
cchunk1->setMinFilter( GL_LINEAR );
cchunk1->setMagFilter( GL_NEAREST );
cchunk1->setWrapS( GL_REPEAT );
cchunk1->setWrapT( GL_REPEAT );
cchunk1->setEnvMode( GL_MODULATE );
cchunk1->setLodBias( 10 );
endEditCP(cchunk1);
gchunk1 = TexGenChunk::create();
beginEditCP(gchunk1);
gchunk1->setGenFuncS(GL_REFLECTION_MAP_ARB);
gchunk1->setGenFuncT(GL_REFLECTION_MAP_ARB);
gchunk1->setGenFuncR(GL_REFLECTION_MAP_ARB);
endEditCP(gchunk1);
// blend chunk
blchunk = BlendChunk::create();
#ifndef WIN32
// blchunk->setSrcFactor( GL_CONSTANT_ALPHA );
// blchunk->setDestFactor( GL_ONE_MINUS_CONSTANT_ALPHA );
#endif
blchunk->setColor( Color4f( 1,1,1,0.1 ) );
// 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);
glutMainLoop();
return 0;
}
MaterialPtr PerformerLoader::traverseGState(NodePtr node, pfGeoState *gstate)
{
FDEBUG(("PerformerLoader::traverseGState: traversing %p\n", gstate));
if(_materials.find(gstate) != _materials.end())
{
FDEBUG(("PfL:traverseGState: found in matmap.\n"));
return _materials[gstate];
}
ChunkMaterialPtr mat = ChunkMaterial::create();
beginEditCP(mat);
uint64_t inherit;
inherit = gstate->getInherit();
static int pcolormode[] = { PFMTL_CMODE_AMBIENT_AND_DIFFUSE,
PFMTL_CMODE_AMBIENT,
PFMTL_CMODE_DIFFUSE,
PFMTL_CMODE_EMISSION,
PFMTL_CMODE_SPECULAR,
PFMTL_CMODE_OFF,
-1
};
static int ocolormode[] = { GL_AMBIENT_AND_DIFFUSE,
GL_AMBIENT,
GL_DIFFUSE,
GL_EMISSION,
GL_SPECULAR,
GL_NONE
};
pair<void *, void*> key;
if((inherit & (PFSTATE_FRONTMTL | PFSTATE_BACKMTL)) !=
(PFSTATE_FRONTMTL | PFSTATE_BACKMTL)
)
{
MaterialChunkPtr matc;
key.first = NULL;
if (!(inherit & PFSTATE_FRONTMTL))
key.first = gstate->getAttr(PFSTATE_FRONTMTL);
key.second = NULL;
if (!(inherit & PFSTATE_BACKMTL))
key.second = gstate->getAttr(PFSTATE_BACKMTL);
if(_chunks.find(key) != _chunks.end())
{
matc = MaterialChunkPtr::dcast(_chunks[key]);
}
else
{
matc = MaterialChunk::create();
beginEditCP(matc);
if (!(inherit & PFSTATE_FRONTMTL))
{
pfMaterial *mat = (pfMaterial*)gstate->getAttr(PFSTATE_FRONTMTL);
float r,g,b,a;
a = mat->getAlpha();
mat->getColor(PFMTL_AMBIENT, &r, &g, &b);
matc->setAmbient(Color4f(r,g,b,0));
mat->getColor(PFMTL_DIFFUSE, &r, &g, &b);
matc->setDiffuse(Color4f(r,g,b,a));
mat->getColor(PFMTL_SPECULAR, &r, &g, &b);
matc->setSpecular(Color4f(r,g,b,0));
mat->getColor(PFMTL_EMISSION, &r, &g, &b);
matc->setEmission(Color4f(r,g,b,0));
matc->setShininess(mat->getShininess());
int cm = mat->getColorMode(PFMTL_FRONT);
UInt32 om = GL_NONE;
for (UInt16 i = 0; pcolormode[i] != -1; ++i)
if(pcolormode[i] == cm)
om = ocolormode[i];
matc->setColorMaterial(om);
}
if (!(inherit & PFSTATE_BACKMTL))
{
pfMaterial *mat = (pfMaterial*)gstate->getAttr(PFSTATE_BACKMTL);
matc->setBackMaterial(true);
float r,g,b,a;
a = mat->getAlpha();
mat->getColor(PFMTL_AMBIENT, &r, &g, &b);
matc->setBackAmbient(Color4f(r,g,b,0));
mat->getColor(PFMTL_DIFFUSE, &r, &g, &b);
matc->setBackDiffuse(Color4f(r,g,b,a));
mat->getColor(PFMTL_SPECULAR, &r, &g, &b);
matc->setBackSpecular(Color4f(r,g,b,0));
mat->getColor(PFMTL_EMISSION, &r, &g, &b);
matc->setBackEmission(Color4f(r,g,b,0));
matc->setBackShininess(mat->getShininess());
int cm = mat->getColorMode(PFMTL_FRONT);
UInt32 om = GL_NONE;
for (UInt16 i = 0; pcolormode[i] != -1; ++i)
if(pcolormode[i] == cm)
om = ocolormode[i];
matc->setBackColorMaterial(om);
}
endEditCP(matc);
}
mat->addChunk(matc);
}
if((inherit & (PFSTATE_TEXTURE | PFSTATE_TEXENV)) !=
(PFSTATE_TEXTURE | PFSTATE_TEXENV)
)
{
TextureChunkPtr texc;
for(int t = 0; t < PF_MAX_TEXTURES; ++t)
{
if(gstate->getMultiAttr(PFSTATE_TEXTURE, t) == NULL)
continue;
key.first = NULL;
if (!(inherit & PFSTATE_TEXTURE) &&
gstate->getMultiAttr(PFSTATE_TEXTURE, t))
key.first = gstate->getMultiAttr(PFSTATE_TEXTURE, t);
key.second = NULL;
if (!(inherit & PFSTATE_TEXENV) &&
gstate->getMultiAttr(PFSTATE_TEXENV, t))
key.second = gstate->getMultiAttr(PFSTATE_TEXENV, t);
if(_chunks.find(key) != _chunks.end())
{
texc = TextureChunkPtr::dcast(_chunks[key]);
}
else
{
texc = TextureChunk::create();
beginEditCP(texc);
if (!(inherit & PFSTATE_TEXTURE))
{
pfTexture *tex =
(pfTexture*)gstate->getMultiAttr(PFSTATE_TEXTURE, t);
unsigned int* pdata;
int pf, w, h, d, type, comp, sides;
UInt32 intformat = 0, extformat = 0;
tex->getImage(&pdata, &comp, &w, &h, &d);
sides = tex->getFormat(PFTEX_CUBE_MAP) ? 6 : 1;
pf = tex->getFormat(PFTEX_IMAGE_FORMAT);
if(pf == 0x7fff)
{
switch(comp)
{
case 1: pf = Image::OSG_L_PF; break;
case 2: pf = Image::OSG_LA_PF; break;
case 3: pf = Image::OSG_RGB_PF; break;
case 4: pf = Image::OSG_RGBA_PF; break;
}
}
switch(tex->getFormat(PFTEX_EXTERNAL_FORMAT))
{
case PFTEX_PACK_8: type = Image::OSG_UINT8_IMAGEDATA;
break;
case PFTEX_PACK_16: type = Image::OSG_UINT16_IMAGEDATA;
break;
default:
type = Image::OSG_UINT8_IMAGEDATA;
FWARNING(("PerformerLoader::traverseGState: "
"Unknown tex format %d!\n",
tex->getFormat(PFTEX_EXTERNAL_FORMAT)));
extformat = tex->getFormat(PFTEX_EXTERNAL_FORMAT);
break;
}
intformat = tex->getFormat(PFTEX_INTERNAL_FORMAT);
ImagePtr img = Image::create();
beginEditCP(img);
img->set(pf, w, h, d, 1, 1, 0, NULL, type, 1, sides);
if(sides == 1)
{
memcpy(img->getData(), pdata, img->getSize());
}
else
{
FWARNING(("PerformerLoader::traverseGState: "
"CubeTex not impl yet!\n"));
}
endEditCP(img);
texc->setImage(img);
texc->setInternalFormat(intformat);
texc->setWrapS(tex->getRepeat(PFTEX_WRAP_S));
texc->setWrapT(tex->getRepeat(PFTEX_WRAP_T));
texc->setWrapR(tex->getRepeat(PFTEX_WRAP_R));
static int ptexfilter[] = { PFTEX_POINT,
PFTEX_LINEAR,
PFTEX_BILINEAR,
PFTEX_TRILINEAR,
PFTEX_QUADLINEAR,
PFTEX_MIPMAP_POINT,
PFTEX_MIPMAP_LINEAR,
PFTEX_MIPMAP_BILINEAR,
PFTEX_MIPMAP_TRILINEAR,
PFTEX_MIPMAP_QUADLINEAR,
-1
};
static int otexfilter[] = { GL_NEAREST,
GL_LINEAR,
GL_LINEAR,
GL_LINEAR,
GL_LINEAR,
GL_NEAREST_MIPMAP_NEAREST,
GL_NEAREST_MIPMAP_LINEAR,
GL_LINEAR_MIPMAP_NEAREST,
GL_LINEAR_MIPMAP_LINEAR,
GL_LINEAR_MIPMAP_LINEAR
};
int ptf = tex->getFilter(PFTEX_MINFILTER);
UInt32 otf = GL_NONE;
for (UInt16 i = 0; ptexfilter[i] != -1; ++i)
if(ptexfilter[i] == ptf)
otf = otexfilter[i];
texc->setMinFilter(otf);
ptf = tex->getFilter(PFTEX_MAGFILTER);
otf = GL_NONE;
for (UInt16 i = 0; ptexfilter[i] != -1; ++i)
if(ptexfilter[i] == ptf)
otf = otexfilter[i];
texc->setMagFilter(otf);
}
if (!(inherit & PFSTATE_TEXENV))
{
pfTexEnv *te =
(pfTexEnv*)gstate->getMultiAttr(PFSTATE_TEXENV, t);
if(te != NULL)
{
texc->setEnvMode(te->getMode());
float r,g,b,a;
te->getBlendColor(&r,&g,&b,&a);
texc->setEnvColor(Color4f(r,g,b,a));
}
}
endEditCP(texc);
}
mat->addChunk(texc);
} // for t
}
/* Unhandled: lightmodel, lights, fog, texgen, texlod, vtxprog, fragprog,
gprogparms, colortable, highlight, lpointstate, shadprog
*/
endEditCP(mat);
_materials[gstate] = mat;
return mat;
}
int main (int argc, char **argv)
{
// GLUT init
osgInit(argc, argv);
osgLog().setLogLevel ( OSG::LOG_DEBUG );
FieldContainerPtr pProto = Geometry::getClassType().getPrototype();
GeometryPtr pGeoProto = GeometryPtr::dcast(pProto);
if(pGeoProto != NullFC)
{
pGeoProto->setDlistCache(true);
}
glutInit(&argc, argv);
glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
UInt32 id = glutCreateWindow("OpenSG");
glutKeyboardFunc(key);
glutReshapeFunc(resize);
glutDisplayFunc(display);
// glutMouseFunc(mouse);
// glutMotionFunc(motion);
glutIdleFunc(display);
// create a material (need that to test textures)
ChunkMaterialPtr mat;
beginEditCP(mat);
mat = ChunkMaterial::create();
MaterialChunkPtr mc = MaterialChunk::create();
beginEditCP(mc);
mc->setDiffuse( Color4f( 1,.8,.8,1 ) );
mc->setAmbient( Color4f( 0.1,0.1,0.1,1 ) );
mc->setSpecular( Color4f( 1,1,1,1 ) );
mc->setShininess( 20 );
mc->setBackMaterial(true);
mc->setBackColorMaterial(GL_DIFFUSE);
mc->setBackDiffuse( Color4f( 1,0,0,1 ) );
mc->setBackAmbient( Color4f( 0.1,0.1,0.1,1 ) );
mc->setBackSpecular( Color4f( 0,1,0,1 ) );
mc->setBackShininess( 10 );
mc->setLit(true);
endEditCP(mc);
mat->addChunk(mc);
// Texture chunk
UChar8 imgdata[] =
{ 255,0,0,128, 0,255,0,128, 0,0,255,255, 255,255,255,255 };
ImagePtr pImage = Image::create();
pImage->set( Image::OSG_RGBA_PF, 2, 2, 1, 1, 1, 0, imgdata );
if ( argc > 1 )
pImage->read( argv[1] );
TextureChunkPtr xchunk;
xchunk = TextureChunk::create();
xchunk->setImage( pImage );
xchunk->setMinFilter( GL_NEAREST );
xchunk->setMagFilter( GL_NEAREST );
xchunk->setWrapS( GL_REPEAT );
xchunk->setWrapT( GL_REPEAT );
xchunk->setEnvMode( GL_MODULATE );
mat->addChunk( xchunk );
endEditCP(mat);
objects[0] = makePolygon(ccwSquare,
sizeof(ccwSquare)/sizeof(double[3]));
objects[1] = makePolygon(ccwSquare,
sizeof(ccwSquare)/sizeof(double[3]));
objects[2] = makePolygon(star,
sizeof(star)/sizeof(double[3]));
objects[3] = makePolygon(star,
sizeof(star)/sizeof(double[3]));
objects[4] = makePolygon(cwSquare,
sizeof(cwSquare)/sizeof(double[3]));
objects[5] = makePolygon(cwSquare,
sizeof(cwSquare)/sizeof(double[3]));
objects[6] = makePolygon(doubleEight,
sizeof(doubleEight)/sizeof(double[3]));
objects[7] = makePolygon(doubleEight,
sizeof(doubleEight)/sizeof(double[3]));
//tesselate every second object
for(int i = 1; i < nobjects; i+=2) {
GeometryPtr::dcast(objects[i]->getCore())->setMaterial( mat );
std::cerr << "Polygon Node: " << std::hex << objects[i] << std::endl;
// try to create convex primitives
OSG::GeometryPtr pGeo = GeometryPtr::dcast(objects[i]->getCore());
std::cerr << "Tesselating polygon : "
<< i
<< std::endl;
createConvexPrimitives(pGeo);
}
// normal material
SimpleMaterialPtr nmat;
nmat = SimpleMaterial::create();
beginEditCP(nmat);
nmat->setEmission( Color3f( 0,1,0 ) );
endEditCP(nmat);
for ( UInt16 i = 0; i < nobjects; i++ )
{
normalobjects[i] = calcVertexNormalsGeo(
GeometryPtr::dcast(objects[i]->getCore()), .5);
GeometryPtr::dcast(normalobjects[i]->getCore())->setMaterial(nmat);
}
//
// The action
win = GLUTWindow::create();
win->setId(id);
win->init();
glEnable( GL_LIGHT0 );
float p[4]={0,0,1,0};
glLightfv(GL_LIGHT0, GL_POSITION, p);
float c[4]={1,1,1,1};
glLightfv(GL_LIGHT0, GL_DIFFUSE, c);
glLightfv(GL_LIGHT0, GL_SPECULAR, c);
glPointSize( 3 );
glEnable( GL_DEPTH_TEST );
glEnable( GL_LIGHTING );
glClearColor( .3, .3, .8, 1 );
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
gluPerspective( 60, 1, 0.1, 10 );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
gluLookAt( 3, 3, 3, 0, 0, 0, 0, 0, 1 );
dact = DrawAction::create();
dact->setWindow(get_pointer(win));
dact->setFrustumCulling( false );
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;
}
