PhysicsBodyUnrecPtr buildBox(const Pnt3f& Position,
const Vec3f& Dimensions,
const Color3f& Color,
Node* const spaceGroupNode,
PhysicsWorld* const physicsWorld,
PhysicsHashSpace* const physicsSpace)
{
Matrix m;
//create OpenSG mesh
GeometryUnrecPtr box;
NodeUnrecPtr boxNode = makeBox(Dimensions.x(), Dimensions.y(), Dimensions.z(), 1, 1, 1);
box = dynamic_cast<Geometry*>(boxNode->getCore());
SimpleMaterialUnrecPtr box_mat = SimpleMaterial::create();
box_mat->setAmbient(Color3f(0.0,0.0,0.0));
box_mat->setDiffuse(Color);
box->setMaterial(box_mat);
TransformUnrecPtr boxTrans;
NodeUnrecPtr boxTransNode = makeCoredNode<Transform>(&boxTrans);
m.setIdentity();
m.setTranslate(Position);
boxTrans->setMatrix(m);
//create ODE data
PhysicsBodyUnrecPtr boxBody = PhysicsBody::create(physicsWorld);
boxBody->setPosition(Vec3f(Position));
boxBody->setBoxMass(1.0,Dimensions.x(), Dimensions.y(), Dimensions.z());
boxBody->setLinearDamping(0.0001);
boxBody->setAngularDamping(0.0001);
PhysicsBoxGeomUnrecPtr boxGeom = PhysicsBoxGeom::create();
boxGeom->setBody(boxBody);
boxGeom->setSpace(physicsSpace);
boxGeom->setLengths(Dimensions);
//add attachments
boxNode->addAttachment(boxGeom);
boxTransNode->addAttachment(boxBody);
boxTransNode->addChild(boxNode);
//add to SceneGraph
spaceGroupNode->addChild(boxTransNode);
return boxBody;
}
//////////////////////////////////////////////////////////////////////////
//! build a sphere
//////////////////////////////////////////////////////////////////////////
PhysicsBodyUnrecPtr buildSphere(void)
{
Real32 Radius((Real32)(rand()%2)*0.5+0.5);
Matrix m;
//create OpenSG mesh
GeometryUnrecPtr sphere;
NodeUnrecPtr sphereNode = makeSphere(2, Radius);
sphere = dynamic_cast<Geometry*>(sphereNode->getCore());
SimpleMaterialUnrecPtr sphere_mat = SimpleMaterial::create();
sphere_mat->setAmbient(Color3f(0.0,0.0,0.0));
sphere_mat->setDiffuse(Color3f(0.0,0.0,1.0));
sphere->setMaterial(sphere_mat);
TransformUnrecPtr sphereTrans;
NodeUnrecPtr sphereTransNode = makeCoredNode<Transform>(&sphereTrans);
m.setIdentity();
Real32 randX = (Real32)(rand()%10)-5.0;
Real32 randY = (Real32)(rand()%10)-5.0;
m.setTranslate(randX, randY, 10.0);
sphereTrans->setMatrix(m);
//create ODE data
PhysicsBodyUnrecPtr sphereBody = PhysicsBody::create(physicsWorld);
sphereBody->setPosition(Vec3f(randX, randY, 10.0));
sphereBody->setLinearDamping(0.0001);
sphereBody->setAngularDamping(0.0001);
sphereBody->setSphereMass(1.0,Radius);
PhysicsSphereGeomUnrecPtr sphereGeom = PhysicsSphereGeom::create();
sphereGeom->setBody(sphereBody);
sphereGeom->setSpace(physicsSpace);
sphereGeom->setRadius(Radius);
//add attachments
sphereNode->addAttachment(sphereGeom);
sphereTransNode->addAttachment(sphereBody);
sphereTransNode->addChild(sphereNode);
//add to SceneGraph
spaceGroupNode->addChild(sphereTransNode);
commitChanges();
return sphereBody;
}
//////////////////////////////////////////////////////////////////////////
//! build a box
//////////////////////////////////////////////////////////////////////////
PhysicsBodyUnrecPtr buildBox(void)
{
Vec3f Lengths((Real32)(rand()%2)+1.0, (Real32)(rand()%2)+1.0, (Real32)(rand()%2)+1.0);
Matrix m;
//create OpenSG mesh
GeometryUnrecPtr box;
NodeUnrecPtr boxNode = makeBox(Lengths.x(), Lengths.y(), Lengths.z(), 1, 1, 1);
box = dynamic_cast<Geometry*>(boxNode->getCore());
SimpleMaterialUnrecPtr box_mat = SimpleMaterial::create();
box_mat->setAmbient(Color3f(0.0,0.0,0.0));
box_mat->setDiffuse(Color3f(0.0,1.0 ,0.0));
box->setMaterial(box_mat);
TransformUnrecPtr boxTrans;
NodeUnrecPtr boxTransNode = makeCoredNode<Transform>(&boxTrans);
m.setIdentity();
Real32 randX = (Real32)(rand()%10)-5.0;
Real32 randY = (Real32)(rand()%10)-5.0;
m.setTranslate(randX, randY, 10.0);
boxTrans->setMatrix(m);
//create ODE data
PhysicsBodyUnrecPtr boxBody = PhysicsBody::create(physicsWorld);
boxBody->setPosition(Vec3f(randX, randY, 10.0));
boxBody->setBoxMass(1.0, Lengths.x(), Lengths.y(), Lengths.z());
PhysicsBoxGeomUnrecPtr boxGeom = PhysicsBoxGeom::create();
boxGeom->setBody(boxBody);
boxGeom->setSpace(physicsSpace);
boxGeom->setLengths(Lengths);
//add attachments
boxNode->addAttachment(boxGeom);
boxTransNode->addAttachment(boxBody);
boxTransNode->addChild(boxNode);
//add to SceneGraph
spaceGroupNode->addChild(boxTransNode);
commitChanges();
return boxBody;
}
Pnt3f calcGeometryCenter(GeometryUnrecPtr geo)
{
if(geo == NULL ||
geo->getPositions() == NULL ||
geo->getPositions()->size() == 0)
{
return Pnt3f();
}
GeoVectorProperty* Positions(geo->getPositions());
Pnt3f Sum;
for(UInt32 i(1) ; i<Positions->size(); ++i)
{
Sum = Sum + Vec3f(Positions->getValue<Pnt3f>(i));
}
return Sum * (1.0f/static_cast<Real32>(Positions->size()));
}
void MergeGraphOp::processTransformations(Node * const node)
{
MFUnrecChildNodePtr::const_iterator mfit = node->getMFChildren()->begin();
MFUnrecChildNodePtr::const_iterator mfen = node->getMFChildren()->end ();
std::vector<Node *> toAdd;
std::vector<Node *> toSub;
for ( ; mfit != mfen; ++mfit )
{
bool special=isInExcludeList(*mfit);
bool leaf=isLeaf(*mfit);
bool empty=true;
//if a transformation:
if ((*mfit)->getCore()->getType().isDerivedFrom(
Transform::getClassType()))
{
if (!leaf && !special)
{
//try to apply it to children geometries
//move all "moveable" children one level up
//if empty after that, delete it
MFUnrecChildNodePtr::const_iterator it2 =
(*mfit)->getMFChildren()->begin();
MFUnrecChildNodePtr::const_iterator en2 =
(*mfit)->getMFChildren()->end ();
for ( ; it2 != en2; ++it2 )
{
if (!isInExcludeList(*it2))
{
//check if geometry
if ((*it2)->getCore()->getType().isDerivedFrom(
Geometry::getClassType()))
{
if(!isLeaf(*it2))
{
//hmm...bad tree...
empty=false;
}
else
{
//it is a leaf geometry, so apply the transformation
Geometry *geo_old =
dynamic_cast<Geometry *>(
(*it2)->getCore());
//GeometryPtr geo = geo_old->clone();
GeometryUnrecPtr geo =
dynamic_pointer_cast<Geometry>(
OSG::deepClone(geo_old, "Material"));
Transform *t =
dynamic_cast<Transform *>(
(*mfit)->getCore());
GeoPnt3fProperty *pos = dynamic_cast<GeoPnt3fProperty *>(geo->getPositions());
GeoVec3fProperty *norm = dynamic_cast<GeoVec3fProperty *>(geo->getNormals());
GeoColor3fProperty *color = dynamic_cast<GeoColor3fProperty *>(geo->getColors());
GeoColor3fProperty *scolor = dynamic_cast<GeoColor3fProperty *>(geo->getSecondaryColors());
GeoVec3fProperty *texcoord0 = dynamic_cast<GeoVec3fProperty *>(geo->getTexCoords());
GeoVec3fProperty *texcoord1 = dynamic_cast<GeoVec3fProperty *>(geo->getTexCoords1());
GeoVec3fProperty *texcoord2 = dynamic_cast<GeoVec3fProperty *>(geo->getTexCoords2());
GeoVec3fProperty * texcoord3 = dynamic_cast<GeoVec3fProperty *>(geo->getTexCoords3());
Matrix m=t->getMatrix();
if(pos!=NULL)
{
for(UInt32 i = 0; i < pos->size(); ++i)
{
Pnt3f p=pos->getValue(i);
m.multFull(p, p);
pos->setValue(p,i);
}
}
if(norm!=NULL)
{
for(UInt32 i = 0; i < norm->size(); ++i)
{
Vec3f n=norm->getValue(i);
m.mult(n, n);
n.normalize();
norm->setValue(n,i);
}
}
if(color != NULL && _color_is_vector)
{
for(UInt32 i = 0; i < color->size(); ++i)
{
Color3f c = color->getValue(i);
Vec3f v;
v.setValue(c.getValuesRGB());
m.mult(v, v);
v.normalize();
c.setValuesRGB(v[0], v[1], v[2]);
color->setValue(c,i);
}
}
if(scolor != NULL && _secondary_color_is_vector)
{
for(UInt32 i = 0; i < scolor->size(); ++i)
{
Color3f c = scolor->getValue(i);
Vec3f v;
v.setValue(c.getValuesRGB());
m.mult(v, v);
v.normalize();
c.setValuesRGB(v[0], v[1], v[2]);
scolor->setValue(c,i);
}
}
if(texcoord0 != NULL && _texcoord0_is_vector)
{
for(UInt32 i = 0; i < texcoord0->size(); ++i)
{
Vec3f v = texcoord0->getValue(i);
m.mult(v, v);
v.normalize();
texcoord0->setValue(v,i);
}
}
if(texcoord1 != NULL && _texcoord1_is_vector)
{
for(UInt32 i = 0; i < texcoord1->size(); ++i)
{
Vec3f v = texcoord1->getValue(i);
m.mult(v, v);
v.normalize();
texcoord1->setValue(v,i);
}
}
if(texcoord2 != NULL && _texcoord2_is_vector)
{
for(UInt32 i = 0; i < texcoord2->size(); ++i)
{
Vec3f v = texcoord2->getValue(i);
m.mult(v, v);
v.normalize();
texcoord2->setValue(v,i);
}
}
if (texcoord3 != NULL && _texcoord3_is_vector)
{
for(UInt32 i = 0; i < texcoord3->size(); i++)
{
Vec3f v = texcoord3->getValue(i);
m.mult(v, v);
v.normalize();
texcoord3->setValue(v,i);
}
}
(*it2)->setCore(geo);
toAdd.push_back(*it2);
}
} else empty=false;
} else empty=false;
}
}
//now check whether we have to remove it
if ((empty||leaf) && !special)
{
toSub.push_back(*mfit);
continue;
}
if (leaf && special)
{
//what to do?
}
if (!leaf && special)
{
//what to do?
}
continue;
}
}
std::vector<Node *>::const_iterator vit = toAdd.begin();
std::vector<Node *>::const_iterator ven = toAdd.end ();
for ( ; vit != ven; ++vit )
{
node->addChild(*vit);
}
vit = toSub.begin();
ven = toSub.end ();
for ( ; vit != ven; ++vit )
{
node->subChild(*vit);
}
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
OSG::preloadSharedObject("OSGFileIO");
OSG::preloadSharedObject("OSGImageFileIO");
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
//Initialize Window
TutorialWindow->initWindow();
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
//Attach to events
TutorialWindow->connectMousePressed(boost::bind(mousePressed, _1, &sceneManager));
TutorialWindow->connectMouseReleased(boost::bind(mouseReleased, _1, &sceneManager));
TutorialWindow->connectMouseDragged(boost::bind(mouseDragged, _1, &sceneManager));
TutorialWindow->connectMouseWheelMoved(boost::bind(mouseWheelMoved, _1, &sceneManager));
TutorialWindow->connectKeyPressed(boost::bind(keyPressed, _1, TutorialWindow.get()));
//Box Geometry
GeometryUnrecPtr BoxGeometry = makeBoxGeo(1.0,1.0,1.0,1,1,1);
ChunkMaterialUnrecPtr TheBoxMaterial = ChunkMaterial::create();
BoxGeometry->setMaterial(TheBoxMaterial);
NodeUnrecPtr BoxGeometryNode = Node::create();
BoxGeometryNode->setCore(BoxGeometry);
//Make Box Node
NodeUnrecPtr BoxNode = Node::create();
TransformUnrecPtr BoxNodeTrans;
BoxNodeTrans = Transform::create();
BoxNode->setCore(BoxNodeTrans);
BoxNode->addChild(BoxGeometryNode);
//Make Main Scene Node
NodeUnrecPtr scene = Node::create();
ComponentTransformUnrecPtr Trans;
Trans = ComponentTransform::create();
scene->setCore(Trans);
// add the torus as a child
scene->addChild(BoxNode);
//Setup the Animation
AnimationUnrecPtr TheAnimation = setupAnimation(TheBoxMaterial);
TheAnimation->attachUpdateProducer(TutorialWindow);
TheAnimation->start();
// tell the manager what to manage
sceneManager.setRoot (scene);
//Create the Documentation
SimpleScreenDoc TheSimpleScreenDoc(&sceneManager, TutorialWindow);
// show the whole scene
sceneManager.showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"09TextureSelectAnimation");
//Main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// Set up Window
TutorialWindow = createNativeWindow();
//Initialize Window
TutorialWindow->initWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
//Add Window Listener
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
TutorialMouseListener TheTutorialMouseListener;
TutorialMouseMotionListener TheTutorialMouseMotionListener;
TutorialWindow->addMouseListener(&TheTutorialMouseListener);
TutorialWindow->addMouseMotionListener(&TheTutorialMouseMotionListener);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindow);
//Setup the Animation
setupAnimation();
//Box Geometry
GeometryUnrecPtr BoxGeometry = makeBoxGeo(1.0,1.0,1.0,1,1,1);
BoxGeometry->setMaterial(TheBoxMaterial);
NodeUnrecPtr BoxGeometryNode = Node::create();
BoxGeometryNode->setCore(BoxGeometry);
//Make Box Node
NodeUnrecPtr BoxNode = Node::create();
TransformUnrecPtr BoxNodeTrans;
BoxNodeTrans = Transform::create();
BoxNode->setCore(BoxNodeTrans);
BoxNode->addChild(BoxGeometryNode);
//Make Main Scene Node
NodeUnrecPtr scene = Node::create();
ComponentTransformUnrecPtr Trans;
Trans = ComponentTransform::create();
scene->setCore(Trans);
// add the torus as a child
scene->addChild(BoxNode);
// tell the manager what to manage
mgr->setRoot (scene);
// show the whole scene
mgr->showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"05TextureAnimation");
//Main Loop
TutorialWindow->mainLoop();
osgExit();
return 0;
}
//----------------------------
// Function name: read
//----------------------------
//
//Parameters:
//p: Scene &image, const char *fileName
//GlobalVars:
//g:
//Returns:
//r:bool
// Caution
//c:
//Assumations:
//a:
//Describtions:
//d: read the image from the given file
//SeeAlso:
//s:
//
//------------------------------
NodeTransitPtr OBJSceneFileType::read( std::istream &is,
const Char8 *,
Resolver ) const
{
NodeUnrecPtr rootPtr, nodePtr;
std::string elem;
std::map<std::string, DataElem>::const_iterator elemI;
Vec3f vec3r;
Pnt3f pnt3r;
Vec2f vec2r;
Real32 x,y,z;
GeoPnt3fPropertyUnrecPtr coordPtr = GeoPnt3fProperty::create();
GeoVec2fPropertyUnrecPtr texCoordPtr = GeoVec2fProperty::create();
GeoVec3fPropertyUnrecPtr normalPtr = GeoVec3fProperty::create();
GeometryUnrecPtr geoPtr;
GeoIntegralPropertyUnrecPtr posIndexPtr, texIndexPtr, normalIndexPtr;
GeoIntegralPropertyUnrecPtr lensPtr;
GeoIntegralPropertyUnrecPtr typePtr;
DataElem dataElem;
DataElem lastDataElem;
Char8 strBuf[8192], *token, *nextToken;
Int32 strBufSize = sizeof(strBuf)/sizeof(Char8);
Int32 index, posIndex = 0, indexType;
Int32 i,j,n,primCount[3];
std::list<Mesh> meshList;
std::map<std::string, SimpleTexturedMaterialUnrecPtr> mtlMap;
std::map<std::string, SimpleTexturedMaterialUnrecPtr>::iterator mtlI;
Mesh emptyMesh;
Face emptyFace;
TiePoint emptyTie;
Int32 indexMask, meshIndexMask;
std::list<Face>::iterator faceI;
std::list<Mesh>::iterator meshI;
bool isSingleIndex;
// create the first mesh entry
meshList.push_back(emptyMesh);
meshI = meshList.begin();
if(is)
{
primCount[0] = 0;
primCount[1] = 0;
primCount[2] = 0;
for(is >> elem; is.eof() == false; is >> elem)
{
if(elem[0] == '#' || elem[0] == '$')
{
is.ignore(INT_MAX, '\n');
}
else
{
SceneFileHandler::the()->updateReadProgress();
elemI = _dataElemMap.find(elem);
dataElem = ((elemI == _dataElemMap.end()) ?
UNKNOWN_DE : elemI->second );
switch (dataElem)
{
case OBJECT_DE:
case GROUP_DE:
case SMOOTHING_GROUP_DE:
is.ignore(INT_MAX, '\n');
break;
case VERTEX_DE:
primCount[0]++;
is >> x >> y >> z;
pnt3r.setValues(x,y,z);
coordPtr->addValue(pnt3r);
break;
case VERTEX_TEXTURECOORD_DE:
primCount[1]++;
is >> x >> y;
vec2r.setValues(x,y);
texCoordPtr->addValue(vec2r);
break;
case VERTEX_NORMAL_DE:
primCount[2]++;
is >> x >> y >> z;
vec3r.setValues(x,y,z);
normalPtr->addValue(vec3r);
break;
case LIB_MTL_DE:
is >> elem;
readMTL ( elem.c_str(), mtlMap );
is.ignore(INT_MAX, '\n');
break;
case USE_MTL_DE:
is >> elem;
if (meshI->faceList.empty() == false)
{
meshList.push_front(emptyMesh);
meshI = meshList.begin();
}
mtlI = mtlMap.find(elem);
if (mtlI == mtlMap.end())
{
FFATAL (("Unkown mtl %s\n", elem.c_str()));
}
else
{
meshI->mtlPtr = mtlI->second;
}
break;
case FACE_DE:
meshI->faceList.push_front(emptyFace);
faceI = meshI->faceList.begin();
is.get(strBuf,strBufSize);
token = strBuf;
indexType = 0;
while(token && *token)
{
// some tools use line continuation for long
// face definitions - these use a \ at the line
// end
if(*token == '\\')
{
is.ignore(1, '\n');
is.get(strBuf,strBufSize);
token = strBuf;
indexType = 0;
continue;
}
for (; *token == '/'; token++)
indexType++;
for (; isspace(*token); token++)
indexType = 0;
index = strtol(token, &nextToken, 10);
if (token == nextToken)
break;
if (indexType == 0)
faceI->tieVec.push_back(emptyTie);
if (index >= 0)
index--;
else
index = primCount[indexType] + index;
faceI->tieVec.back().index[indexType] = index;
token = nextToken;
}
break;
case UNKNOWN_DE:
default:
// don't warn about 3rd tex coord
if(lastDataElem != VERTEX_TEXTURECOORD_DE)
{
FWARNING (( "Unkown obj data elem: %s\n",
elem.c_str()));
}
is.ignore(INT_MAX, '\n');
break;
}
lastDataElem = dataElem;
}
}
#if 0
std::cerr << "------------------------------------------------" << std::endl;
i = 0;
for (meshI = meshList.begin(); meshI != meshList.end(); meshI++)
{
std::cerr << "Mesh " << i << " faceCount :"
<< meshI->faceList.size() << std::endl;
j = 0 ;
for ( faceI = meshI->faceList.begin(); faceI != meshI->faceList.end();
faceI++)
std::cerr << "MESH " << i << "face: " << j++ << "tie num: "
<< faceI->tieVec.size() << std::endl;
i++;
}
std::cerr << "------------------------------------------------" << std::endl;
#endif
// create Geometry objects
for (meshI = meshList.begin(); meshI != meshList.end(); meshI++)
{
geoPtr = Geometry::create();
posIndexPtr = NULL;
texIndexPtr = NULL;
normalIndexPtr = NULL;
lensPtr = GeoUInt32Property::create();
typePtr = GeoUInt8Property ::create();
// create and check mesh index mask
meshIndexMask = 0;
isSingleIndex = true;
if ( meshI->faceList.empty() == false)
{
for ( faceI = meshI->faceList.begin();
faceI != meshI->faceList.end(); faceI++)
{
indexMask = 0;
n = UInt32(faceI->tieVec.size());
for (i = 0; i < n; i++)
{
for (j = 0; j < 3; j++)
{
if ((index = (faceI->tieVec[i].index[j])) >= 0)
{
indexMask |= (1 << j);
if (j)
isSingleIndex &= (posIndex == index);
else
posIndex = index;
}
}
}
if (meshIndexMask == 0)
{
meshIndexMask = indexMask;
}
else if (meshIndexMask != indexMask)
{
// consider this real-world example:
// [...]
// f 1603//1747 1679//1744 1678//1743
// s 1
// f 9/1/10 5/2/9 1680/3/1748 1681/4/174
// [...]
// Some faces contain texture coords and others do not.
// The old version did just skip this geometry.
// This version should continue if there's at least
// the vertex index
// I've seen the change in the maskIndex only after a smooth group,
// so it's perhaps smarter to not ignore the smooth group further up in this code
if( !(indexMask & 1) )
{
// if there are vertex indices there's no reason to get in here
FFATAL (( "IndexMask unmatch, can not create geo\n"));
meshIndexMask = 0;
break;
}
else
{
// consider the minimum similarities of mesh masks
meshIndexMask &= indexMask;
}
}
}
}
else
{
FWARNING (("Mesh with empty faceList\n"));
}
// fill the geo properties
if (meshIndexMask)
{
geoPtr->setPositions ( coordPtr );
posIndexPtr = GeoUInt32Property::create();
if(!isSingleIndex)
geoPtr->setIndex(posIndexPtr, Geometry::PositionsIndex);
geoPtr->setLengths ( lensPtr );
geoPtr->setTypes ( typePtr );
if ( (meshIndexMask & 2) && texCoordPtr->size() > 0 )
{
geoPtr->setTexCoords ( texCoordPtr );
texIndexPtr = GeoUInt32Property::create();
if(!isSingleIndex)
geoPtr->setIndex(texIndexPtr, Geometry::TexCoordsIndex);
}
else
{
geoPtr->setTexCoords ( NULL );
}
if ( (meshIndexMask & 4) && normalPtr->size() > 0 )
{
geoPtr->setNormals ( normalPtr );
normalIndexPtr = GeoUInt32Property::create();
if(!isSingleIndex)
geoPtr->setIndex(normalIndexPtr, Geometry::NormalsIndex);
}
else
{
geoPtr->setNormals ( NULL );
}
if (meshI->mtlPtr == NULL)
{
meshI->mtlPtr = SimpleTexturedMaterial::create();
meshI->mtlPtr->setDiffuse( Color3f( .8f, .8f, .8f ) );
meshI->mtlPtr->setSpecular( Color3f( 1.f, 1.f, 1.f ) );
meshI->mtlPtr->setShininess( 20.f );
}
geoPtr->setMaterial ( meshI->mtlPtr );
for ( faceI = meshI->faceList.begin();
faceI != meshI->faceList.end(); faceI++)
{
n = UInt32(faceI->tieVec.size());
// add the lens entry
lensPtr->push_back(n);
// add the type entry
typePtr->push_back(GL_POLYGON);
// create the index values
for (i = 0; i < n; i++)
{
if (isSingleIndex)
{
posIndexPtr->push_back(faceI->tieVec[i].index[0]);
}
else
{
posIndexPtr->push_back(faceI->tieVec[i].index[0]);
if(texIndexPtr != NULL)
texIndexPtr->push_back(faceI->tieVec[i].index[1]);
if(normalIndexPtr != NULL)
normalIndexPtr->push_back(faceI->tieVec[i].index[2]);
}
}
}
if(isSingleIndex)
{
geoPtr->setIndex(posIndexPtr, Geometry::PositionsIndex);
geoPtr->setIndex(posIndexPtr, Geometry::NormalsIndex );
geoPtr->setIndex(posIndexPtr, Geometry::TexCoordsIndex);
}
// need to port the geometry functions ...
createSharedIndex( geoPtr );
// check if we have normals
// need to port the geometry functions ...
if(geoPtr->getNormals() == NULL)
calcVertexNormals(geoPtr);
// create and link the node
nodePtr = Node::create();
nodePtr->setCore( geoPtr );
if (meshList.size() > 1)
{
if (rootPtr == NULL)
{
rootPtr = Node::create();
GroupUnrecPtr tmpPtr = Group::create();
rootPtr->setCore ( tmpPtr );
rootPtr->addChild(nodePtr);
}
else
{
rootPtr->addChild(nodePtr);
}
}
else
{
rootPtr = nodePtr;
}
}
}
}
SceneFileHandler::the()->updateReadProgress(100);
commitChanges();
return NodeTransitPtr(rootPtr);
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// Set up Window
TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
//Add Window Listener
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
TutorialMouseListener TheTutorialMouseListener;
TutorialMouseMotionListener TheTutorialMouseMotionListener;
TutorialWindow->addMouseListener(&TheTutorialMouseListener);
TutorialWindow->addMouseMotionListener(&TheTutorialMouseMotionListener);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindow);
//Torus Material
TheTorusMaterial = SimpleMaterial::create();
dynamic_pointer_cast<SimpleMaterial>(TheTorusMaterial)->setAmbient(Color3f(0.3,0.3,0.3));
dynamic_pointer_cast<SimpleMaterial>(TheTorusMaterial)->setDiffuse(Color3f(0.7,0.7,0.7));
dynamic_pointer_cast<SimpleMaterial>(TheTorusMaterial)->setSpecular(Color3f(1.0,1.0,1.0));
dynamic_pointer_cast<SimpleMaterial>(TheTorusMaterial)->setShininess(20.0);
//Torus Geometry
GeometryUnrecPtr TorusGeometry = makeTorusGeo(.5, 2, 32, 32);
TorusGeometry->setMaterial(TheTorusMaterial);
NodeUnrecPtr TorusGeometryNode = Node::create();
TorusGeometryNode->setCore(TorusGeometry);
//Make Torus Node
NodeUnrecPtr TorusNode = Node::create();
TorusNodeTrans = Transform::create();
setName(TorusNodeTrans, std::string("TorusNodeTransformationCore"));
TorusNode->setCore(TorusNodeTrans);
TorusNode->addChild(TorusGeometryNode);
//Make Main Scene Node
NodeUnrecPtr scene = Node::create();
ComponentTransformUnrecPtr Trans;
Trans = ComponentTransform::create();
setName(Trans, std::string("MainTransformationCore"));
scene->setCore(Trans);
// add the torus as a child
scene->addChild(TorusNode);
setupAnimation();
// tell the manager what to manage
mgr->setRoot (scene);
// show the whole scene
mgr->showAll();
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"OpenSG 07AnimationGroup Window");
//Enter main Loop
TutorialWindow->mainLoop();
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
//Initialize Window
TutorialWindow->initWindow();
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
//Attach to events
TutorialWindow->connectMousePressed(boost::bind(mousePressed, _1, &sceneManager));
TutorialWindow->connectMouseReleased(boost::bind(mouseReleased, _1, &sceneManager));
TutorialWindow->connectMouseDragged(boost::bind(mouseDragged, _1, &sceneManager));
TutorialWindow->connectMouseWheelMoved(boost::bind(mouseWheelMoved, _1, &sceneManager));
TutorialWindow->connectKeyPressed(boost::bind(keyPressed, _1, TutorialWindow.get()));
//Shader Chunk
SimpleSHLChunkUnrecPtr TheSHLChunk = SimpleSHLChunk::create();
TheSHLChunk->setVertexProgram(createSHLVertexProg());
TheSHLChunk->setFragmentProgram(createSHLFragProg());
//TheSHLChunk->addUniformVariable("Color1",Vec4f(0.0f,1.0f,0.0f,1.0f));
//TheSHLChunk->addUniformVariable("Color2",Vec4f(1.0f,1.0f,1.0f,1.0f));
//Shader Parameter Chunk
SimpleSHLVariableChunkUnrecPtr SHLParameters = SimpleSHLVariableChunk::create();
//Color Parameter
SHLParameters->addUniformVariable("Color1",Vec4f(0.0f,1.0f,0.0f,1.0f));
SHLParameters->addUniformVariable("Color2",Vec4f(1.0f,1.0f,1.0f,1.0f));
ChunkMaterialUnrecPtr ShaderMaterial = ChunkMaterial::create();
ShaderMaterial->addChunk(TheSHLChunk);
ShaderMaterial->addChunk(SHLParameters);
//Torus Node
GeometryUnrecPtr TorusGeometry = makeTorusGeo(5.0f,20.0f, 32,32);
TorusGeometry->setMaterial(ShaderMaterial);
NodeUnrecPtr TorusNode = Node::create();
TorusNode->setCore(TorusGeometry);
// Make Main Scene Node
NodeUnrecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusNode);
sceneManager.setRoot(scene);
// Show the whole Scene
sceneManager.showAll();
//Create the Animations
ShaderVariableVec4fUnrecPtr Color1Parameter;
ShaderVariableVec4fUnrecPtr Color2Parameter;
Color1Parameter = dynamic_cast<ShaderVariableVec4f*>(const_cast<ShaderVariable*>(SHLParameters->getVariables()->getVariable("Color1")));
Color2Parameter = dynamic_cast<ShaderVariableVec4f*>(const_cast<ShaderVariable*>(SHLParameters->getVariables()->getVariable("Color2")));
commitChanges();
AnimationUnrecPtr TheAnimation = setupAnimation(Color1Parameter, "value");
TheAnimation->attachUpdateProducer(TutorialWindow);
TheAnimation->start();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"04ShaderAnimation");
//Main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
Node *
ColladaGeometry::createInstance(ColladaInstInfo *colInstInfo)
{
typedef ColladaInstanceGeometry::MaterialMap MaterialMap;
typedef ColladaInstanceGeometry::MaterialMapConstIt MaterialMapConstIt;
domGeometryRef geometry = getDOMElementAs<domGeometry>();
NodeUnrecPtr groupN = makeCoredNode<Group>();
OSG_COLLADA_LOG(("ColladaGeometry::createInstance id [%s]\n",
geometry->getId()));
if(getGlobal()->getOptions()->getCreateNameAttachments() == true &&
geometry->getName() != NULL )
{
setName(groupN, geometry->getName());
}
ColladaInstanceGeometryRefPtr colInstGeo =
dynamic_cast<ColladaInstanceGeometry *>(colInstInfo->getColInst());
const MaterialMap &matMap =
colInstGeo->getMaterialMap();
// iterate over all parts of geometry
GeoStoreIt gsIt = _geoStore.begin();
GeoStoreIt gsEnd = _geoStore.end ();
for(; gsIt != gsEnd; ++gsIt)
{
OSG_ASSERT(gsIt->_propStore.size() == gsIt->_indexStore.size());
// find the material associated with the geometry's material symbol
MaterialMapConstIt mmIt = matMap.find(gsIt->_matSymbol);
std::string matTarget;
if(mmIt != matMap.end())
{
matTarget = mmIt->second->getTarget();
}
// check if the geometry was already used with that material
GeometryUnrecPtr geo = NULL;
InstanceMapConstIt instIt = gsIt->_instMap.find(matTarget);
if(instIt != gsIt->_instMap.end())
{
// reuse geometry
geo = dynamic_pointer_cast<Geometry>(
getInstStore()[instIt->second]);
getGlobal()->getStatCollector()->getElem(
ColladaGlobal::statNGeometryUsed)->inc();
}
else
{
// create new geometry
geo = Geometry::create();
getGlobal()->getStatCollector()->getElem(
ColladaGlobal::statNGeometryCreated)->inc();
geo->setLengths(gsIt->_lengths);
geo->setTypes (gsIt->_types );
handleBindMaterial(*gsIt, geo, colInstGeo);
// record the instantiation of the geometry with the
// material for reuse
gsIt->_instMap.insert(
InstanceMap::value_type(matTarget, getInstStore().size()));
editInstStore().push_back(geo);
}
NodeUnrecPtr geoN = makeNodeFor(geo);
groupN->addChild(geoN);
}
// store the generated group node
editInstStore().push_back(groupN);
return groupN;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// Set up Window
TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
//Add Window Listener
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
TutorialMouseListener TheTutorialMouseListener;
TutorialMouseMotionListener TheTutorialMouseMotionListener;
TutorialWindow->addMouseListener(&TheTutorialMouseListener);
TutorialWindow->addMouseMotionListener(&TheTutorialMouseMotionListener);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindow);
//Print key command info
std::cout << "\n\nKEY COMMANDS:" << std::endl;
std::cout << "space Play/Pause the animation" << std::endl;
std::cout << "B Show/Hide the bind pose skeleton" << std::endl;
std::cout << "SHIFT-B Show/Hide the bind pose mesh" << std::endl;
std::cout << "P Show/Hide the current pose skeleton" << std::endl;
std::cout << "SHIFT-P Show/Hide the current pose mesh" << std::endl;
std::cout << "CTRL-Q Exit\n\n" << std::endl;
//SkeletonDrawer System Material
LineChunkUnrecPtr ExampleLineChunk = LineChunk::create();
ExampleLineChunk->setWidth(2.0f);
ExampleLineChunk->setSmooth(true);
BlendChunkUnrecPtr ExampleBlendChunk = BlendChunk::create();
ExampleBlendChunk->setSrcFactor(GL_SRC_ALPHA);
ExampleBlendChunk->setDestFactor(GL_ONE_MINUS_SRC_ALPHA);
MaterialChunkUnrecPtr ExampleMaterialChunk = MaterialChunk::create();
ExampleMaterialChunk->setAmbient(Color4f(1.0f,1.0f,1.0f,1.0f));
ExampleMaterialChunk->setDiffuse(Color4f(0.0f,0.0f,0.0f,1.0f));
ExampleMaterialChunk->setSpecular(Color4f(0.0f,0.0f,0.0f,1.0f));
ChunkMaterialUnrecPtr ExampleMaterial = ChunkMaterial::create();
ExampleMaterial->addChunk(ExampleLineChunk);
ExampleMaterial->addChunk(ExampleMaterialChunk);
ExampleMaterial->addChunk(ExampleBlendChunk);
//Skeleton
ExampleSkeleton = SkeletonBlendedGeometry::create();
//===========================================Joints==================================================================
Matrix TempMat;
Matrix InvBind;
/*================================================================================================*/
/* Pelvis */
Pelvis = Joint::create(); //create a joint called Pelvis
TempMat.setTranslate(0.0,7.0,0.0);
Pelvis->setJointTransformation(TempMat);
NodeRecPtr PelvisNode = makeNodeFor(Pelvis);
InvBind = PelvisNode->getToWorld();
InvBind.invert();
ExampleSkeleton->pushToJoints(Pelvis, InvBind);
setName(Pelvis, "Pelvis Joint");
setName(PelvisNode, "Pelvis Node");
/*================================================================================================*/
/* Clavicle */
Clavicle = Joint::create(); //create a joint called Clavicle
TempMat.setTranslate(0.0,5.0,0.0);
Clavicle->setJointTransformation(TempMat);
NodeRecPtr ClavicleNode = makeNodeFor(Clavicle);
PelvisNode->addChild(ClavicleNode);
InvBind = ClavicleNode->getToWorld();
InvBind.invert();
ExampleSkeleton->pushToJoints(Clavicle, InvBind);
setName(Clavicle, "Clavicle Joint");
setName(ClavicleNode, "Clavicle Node");
/*================================================================================================*/
/* Left Shoulder */
LeftShoulder = Joint::create(); //create a joint called LeftShoulder
TempMat.setTranslate(1.0,-0.5,0.0);
LeftShoulder->setJointTransformation(TempMat);
NodeRecPtr LeftShoulderNode = makeNodeFor(LeftShoulder);
ClavicleNode->addChild(LeftShoulderNode);
InvBind = LeftShoulderNode->getToWorld();
InvBind.invert();
ExampleSkeleton->pushToJoints(LeftShoulder, InvBind);
setName(LeftShoulder, "Left Shoulder Joint");
setName(LeftShoulderNode, "Left Shoulder Node");
/*================================================================================================*/
/* Left Elbow */
LeftElbow = Joint::create(); //create a joint called LeftElbow
TempMat.setTranslate(2.0,0.0,0.0);
LeftElbow->setJointTransformation(TempMat);
NodeRecPtr LeftElbowNode = makeNodeFor(LeftElbow);
LeftShoulderNode->addChild(LeftElbowNode);
InvBind = LeftElbowNode->getToWorld();
InvBind.invert();
ExampleSkeleton->pushToJoints(LeftElbow, InvBind);
setName(LeftElbow, "Left Elbow Joint");
setName(LeftElbowNode, "Left Elbow Node");
/*================================================================================================*/
/* Left Hand */
LeftHand = Joint::create(); //create a joint called LeftHand
TempMat.setTranslate(2.0,0.0,0.0);
LeftHand->setJointTransformation(TempMat);
NodeRecPtr LeftHandNode = makeNodeFor(LeftHand);
LeftElbowNode->addChild(LeftHandNode);
InvBind = LeftHandNode->getToWorld();
InvBind.invert();
ExampleSkeleton->pushToJoints(LeftHand, InvBind);
setName(LeftHand, "Left Hand Joint");
setName(LeftHandNode, "Left Hand Node");
/*================================================================================================*/
/* Left Fingers */
LeftFingers = Joint::create(); //create a joint called LeftFingers
TempMat.setTranslate(1.0,0.0,0.0);
LeftFingers->setJointTransformation(TempMat);
NodeRecPtr LeftFingersNode = makeNodeFor(LeftFingers);
LeftHandNode->addChild(LeftFingersNode);
InvBind = LeftFingersNode->getToWorld();
InvBind.invert();
ExampleSkeleton->pushToJoints(LeftFingers, InvBind);
setName(LeftFingers, "Left Fingers Joint");
setName(LeftFingersNode, "Left Fingers Node");
/*================================================================================================*/
/* Right Shoulder */
RightShoulder = Joint::create(); //create a joint called RightShoulder
TempMat.setTranslate(-1.0,-0.5,0.0);
RightShoulder->setJointTransformation(TempMat);
NodeRecPtr RightShoulderNode = makeNodeFor(RightShoulder);
ClavicleNode->addChild(RightShoulderNode);
InvBind = RightShoulderNode->getToWorld();
InvBind.invert();
ExampleSkeleton->pushToJoints(RightShoulder, InvBind);
setName(RightShoulder, "Right Shoulder Joint");
setName(RightShoulderNode, "Right Shoulder Node");
/*================================================================================================*/
/* Right Elbow */
RightElbow = Joint::create(); //create a joint called RightElbow
TempMat.setTranslate(-2.0,0.0,0.0);
RightElbow->setJointTransformation(TempMat);
NodeRecPtr RightElbowNode = makeNodeFor(RightElbow);
RightShoulderNode->addChild(RightElbowNode);
InvBind = RightElbowNode->getToWorld();
InvBind.invert();
ExampleSkeleton->pushToJoints(RightElbow, InvBind);
setName(RightElbow, "Right Elbow Joint");
setName(RightElbowNode, "Right Elbow Node");
/*================================================================================================*/
/* Right Hand */
RightHand = Joint::create(); //create a joint called RightHand
TempMat.setTranslate(-2.0,0.0,0.0);
RightHand->setJointTransformation(TempMat);
NodeRecPtr RightHandNode = makeNodeFor(RightHand);
RightElbowNode->addChild(RightHandNode);
InvBind = RightHandNode->getToWorld();
InvBind.invert();
ExampleSkeleton->pushToJoints(RightHand, InvBind);
setName(RightHand, "Right Hand Joint");
setName(RightHandNode, "Right Hand Node");
/*================================================================================================*/
/* Right Fingers */
RightFingers = Joint::create(); //create a joint called RightFingers
TempMat.setTranslate(-1.0,0.0,0.0);
RightFingers->setJointTransformation(TempMat);
NodeRecPtr RightFingersNode = makeNodeFor(RightFingers);
RightHandNode->addChild(RightFingersNode);
InvBind = RightFingersNode->getToWorld();
InvBind.invert();
ExampleSkeleton->pushToJoints(RightFingers, InvBind);
setName(RightFingers, "Right Fingers Joint");
setName(RightFingersNode, "Right Fingers Node");
/*================================================================================================*/
/* Head */
Head = Joint::create(); //create a joint called Head
TempMat.setTranslate(0.0,1.0,0.0);
Head->setJointTransformation(TempMat);
NodeRecPtr HeadNode = makeNodeFor(Head);
ClavicleNode->addChild(HeadNode);
InvBind = HeadNode->getToWorld();
InvBind.invert();
ExampleSkeleton->pushToJoints(Head, InvBind);
setName(Head, "Head Joint");
setName(HeadNode, "Head Node");
/*================================================================================================*/
/* Left Hip */
LeftHip = Joint::create(); //create a joint called LeftHip
TempMat.setTranslate(1.0,-1.0,0.0);
LeftHip->setJointTransformation(TempMat);
NodeRecPtr LeftHipNode = makeNodeFor(LeftHip);
PelvisNode->addChild(LeftHipNode);
InvBind = LeftHipNode->getToWorld();
InvBind.invert();
ExampleSkeleton->pushToJoints(LeftHip, InvBind);
setName(LeftHip, "Left Hip Joint");
setName(LeftHipNode, "Left Hip Node");
/*================================================================================================*/
/* Left Knee */
LeftKnee = Joint::create(); //create a joint called LeftKnee
TempMat.setTranslate(0.0,-3.0,0.0);
LeftKnee->setJointTransformation(TempMat);
NodeRecPtr LeftKneeNode = makeNodeFor(LeftKnee);
LeftHipNode->addChild(LeftKneeNode);
InvBind = LeftKneeNode->getToWorld();
InvBind.invert();
ExampleSkeleton->pushToJoints(LeftKnee, InvBind);
setName(LeftKnee, "Left Knee Joint");
setName(LeftKneeNode, "Left Knee Node");
/*================================================================================================*/
/* Left Foot */
LeftFoot = Joint::create(); //create a joint called LeftFoot
TempMat.setTranslate(0.0,-3.0,0.0);
LeftFoot->setJointTransformation(TempMat);
NodeRecPtr LeftFootNode = makeNodeFor(LeftFoot);
LeftKneeNode->addChild(LeftFootNode);
InvBind = LeftFootNode->getToWorld();
InvBind.invert();
ExampleSkeleton->pushToJoints(LeftFoot, InvBind);
setName(LeftFoot, "Left Foot Joint");
setName(LeftFootNode, "Left Foot Node");
/*================================================================================================*/
/* Left Toes */
LeftToes = Joint::create(); //create a bone called ExampleChildbone
TempMat.setTranslate(0.0,0.0,1.0);
LeftToes->setJointTransformation(TempMat);
NodeRecPtr LeftToesNode = makeNodeFor(LeftToes);
LeftFootNode->addChild(LeftToesNode);
InvBind = LeftToesNode->getToWorld();
InvBind.invert();
ExampleSkeleton->pushToJoints(LeftToes, InvBind);
setName(LeftToes, "Left Toes Joint");
setName(LeftToesNode, "Left Toes Node");
/*================================================================================================*/
/* Right Hip */
RightHip = Joint::create(); //create a joint called RightHip
TempMat.setTranslate(-1.0,-1.0,0.0);
RightHip->setJointTransformation(TempMat);
NodeRecPtr RightHipNode = makeNodeFor(RightHip);
PelvisNode->addChild(RightHipNode);
InvBind = RightHipNode->getToWorld();
InvBind.invert();
ExampleSkeleton->pushToJoints(RightHip, InvBind);
setName(RightHip, "Right Hip Joint");
setName(RightHipNode, "Right Hip Node");
/*================================================================================================*/
/* Right Knee */
RightKnee = Joint::create(); //create a joint called RightKnee
TempMat.setTranslate(0.0,-3.0,0.0);
RightKnee->setJointTransformation(TempMat);
NodeRecPtr RightKneeNode = makeNodeFor(RightKnee);
RightHipNode->addChild(RightKneeNode);
InvBind = RightKneeNode->getToWorld();
InvBind.invert();
ExampleSkeleton->pushToJoints(RightKnee, InvBind);
setName(RightKnee, "Right Knee Joint");
setName(RightKneeNode, "Right Knee Node");
/*================================================================================================*/
/* Right Foot */
RightFoot = Joint::create(); //create a joint called RightFoot
TempMat.setTranslate(0.0,-3.0,0.0);
RightFoot->setJointTransformation(TempMat);
NodeRecPtr RightFootNode = makeNodeFor(RightFoot);
RightKneeNode->addChild(RightFootNode);
InvBind = RightFootNode->getToWorld();
InvBind.invert();
ExampleSkeleton->pushToJoints(RightFoot, InvBind);
setName(RightFoot, "Right Foot Joint");
setName(RightFootNode, "Right Foot Node");
/*================================================================================================*/
/* Right Toes */
RightToes = Joint::create(); //create a joint called RightToes
TempMat.setTranslate(0.0,0.0,1.0);
RightToes->setJointTransformation(TempMat);
NodeRecPtr RightToesNode = makeNodeFor(RightToes);
RightFootNode->addChild(RightToesNode);
InvBind = RightToesNode->getToWorld();
InvBind.invert();
ExampleSkeleton->pushToJoints(RightToes, InvBind);
setName(RightToes, "Right Toes Joint");
setName(RightToesNode, "Right Toes Node");
//Create a geometry to attach to the skeleton (i.e-> skin)
GeoUInt8PropertyUnrecPtr type = GeoUInt8Property::create();
type->push_back(GL_QUADS);
GeoUInt32PropertyUnrecPtr lens = GeoUInt32Property::create();
lens->push_back(72);
GeoPnt3fPropertyUnrecPtr pnts = GeoPnt3fProperty ::create();
// the points of the Quads
//Back
pnts->push_back(Pnt3f(-0.5, 6.0, 0));
pnts->push_back(Pnt3f( 0.5, 6.0, 0));
pnts->push_back(Pnt3f( 0.5, 12.0, 0));
pnts->push_back(Pnt3f(-0.5, 12.0, 0));
//Head
pnts->push_back(Pnt3f(-0.5, 12, 0));
pnts->push_back(Pnt3f( 0.5, 12, 0));
pnts->push_back(Pnt3f( 0.5, 13, 0));
pnts->push_back(Pnt3f(-0.5, 13, 0));
//Left Shoulder
pnts->push_back(Pnt3f(0.0, 11.5, 0));
pnts->push_back(Pnt3f(0.0, 12.5, 0));
pnts->push_back(Pnt3f(1.0, 12.0, 0));
pnts->push_back(Pnt3f(1.0, 11.0, 0));
//Left Humerus
pnts->push_back(Pnt3f(1.0, 11.0, 0));
pnts->push_back(Pnt3f(1.0, 12.0, 0));
pnts->push_back(Pnt3f(3.0, 12.0, 0));
pnts->push_back(Pnt3f(3.0, 11.0, 0));
//Left Radius
pnts->push_back(Pnt3f(3.0, 11.0, 0));
pnts->push_back(Pnt3f(3.0, 12.0, 0));
pnts->push_back(Pnt3f(5.0, 12.0, 0));
pnts->push_back(Pnt3f(5.0, 11.0, 0));
//Left Hand
pnts->push_back(Pnt3f(5.0, 11.0, 0));
pnts->push_back(Pnt3f(5.0, 12.0, 0));
pnts->push_back(Pnt3f(6.0, 12.0, 0));
pnts->push_back(Pnt3f(6.0, 11.0, 0));
//Right Shoulder
pnts->push_back(Pnt3f(0.0, 11.5, 0));
pnts->push_back(Pnt3f(0.0, 12.5, 0));
pnts->push_back(Pnt3f(-1.0, 12.0, 0));
pnts->push_back(Pnt3f(-1.0, 11.0, 0));
//Right Humerus
pnts->push_back(Pnt3f(-1.0, 11.0, 0));
pnts->push_back(Pnt3f(-1.0, 12.0, 0));
pnts->push_back(Pnt3f(-3.0, 12.0, 0));
pnts->push_back(Pnt3f(-3.0, 11.0, 0));
//Right Radius
pnts->push_back(Pnt3f(-3.0, 11.0, 0));
pnts->push_back(Pnt3f(-3.0, 12.0, 0));
pnts->push_back(Pnt3f(-5.0, 12.0, 0));
pnts->push_back(Pnt3f(-5.0, 11.0, 0));
//Right Hand
pnts->push_back(Pnt3f(-5.0, 11.0, 0));
pnts->push_back(Pnt3f(-5.0, 12.0, 0));
pnts->push_back(Pnt3f(-6.0, 12.0, 0));
pnts->push_back(Pnt3f(-6.0, 11.0, 0));
//Left Hip
pnts->push_back(Pnt3f(0.0, 6.5, 0));
pnts->push_back(Pnt3f(0.5, 7.5, 0));
pnts->push_back(Pnt3f( 1.5, 6.0, 0));
pnts->push_back(Pnt3f(0.5, 6.0, 0));
//Left Femur
pnts->push_back(Pnt3f(0.5, 6.0, 0));
pnts->push_back(Pnt3f( 1.5, 6.0, 0));
pnts->push_back(Pnt3f( 1.5, 3.0, 0));
pnts->push_back(Pnt3f(0.5, 3.0, 0));
//Left Tibia
pnts->push_back(Pnt3f(0.5, 3.0, 0));
pnts->push_back(Pnt3f( 1.5, 3.0, 0));
pnts->push_back(Pnt3f( 1.5, 0.0, 0));
pnts->push_back(Pnt3f(0.5, 0.0, 0));
//Left Foot
pnts->push_back(Pnt3f(0.5, 0.0, 0));
pnts->push_back(Pnt3f( 1.5, 0.0, 0));
pnts->push_back(Pnt3f( 1.5, 0.0, 1.0));
pnts->push_back(Pnt3f(0.5, 0.0, 1.0));
//Right Hip
pnts->push_back(Pnt3f(0.0, 6.5, 0));
pnts->push_back(Pnt3f(-0.5, 7.5, 0));
pnts->push_back(Pnt3f( -1.5, 6.0, 0));
pnts->push_back(Pnt3f(-0.5, 6.0, 0));
//Right Femur
pnts->push_back(Pnt3f(-0.5, 6.0, 0));
pnts->push_back(Pnt3f( -1.5, 6.0, 0));
pnts->push_back(Pnt3f( -1.5, 3.0, 0));
pnts->push_back(Pnt3f(-0.5, 3.0, 0));
//Right Tibia
pnts->push_back(Pnt3f(-0.5, 3.0, 0));
pnts->push_back(Pnt3f( -1.5, 3.0, 0));
pnts->push_back(Pnt3f( -1.5, 0.0, 0));
pnts->push_back(Pnt3f(-0.5, 0.0, 0));
//Right Foot
pnts->push_back(Pnt3f(-0.5, 0.0, 0));
pnts->push_back(Pnt3f( -1.5, 0.0, 0));
pnts->push_back(Pnt3f( -1.5, 0.0, 1.0));
pnts->push_back(Pnt3f(-0.5, 0.0, 1.0));
//Normals
GeoVec3fPropertyUnrecPtr norms = GeoVec3fProperty ::create();
geo=Geometry::create();
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
//Left Hip
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
//Left Femur
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
//Left Tibia
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
//Left Foot
norms->push_back(Vec3f( 0.0,1.0,0.0));
norms->push_back(Vec3f( 0.0,1.0,0.0));
norms->push_back(Vec3f( 0.0,1.0,0.0));
norms->push_back(Vec3f( 0.0,1.0,0.0));
//Right Hip
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
//Right Femur
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
//Right Tibia
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
norms->push_back(Vec3f( 0.0,0.0,1.0));
//Right Foot
norms->push_back(Vec3f( 0.0,1.0,0.0));
norms->push_back(Vec3f( 0.0,1.0,0.0));
norms->push_back(Vec3f( 0.0,1.0,0.0));
norms->push_back(Vec3f( 0.0,1.0,0.0));
//Tell the geometry (geo) to use the points and normals we just defined
geo->setTypes (type);
geo->setLengths (lens);
geo->setPositions(pnts);
geo->setNormals(norms);
// assign a material to the geometry to make it visible. The details
// of materials are defined later.
geo->setMaterial(getDefaultMaterial());
//Create unbound geometry node (for displaying mesh in its bind pose)
UnboundGeometry = Node::create();
UnboundGeometry->setCore(geo);
UnboundGeometry->setTravMask(0); //By default, we won't show the mesh's bind pose
//SkeletonDrawer
SkeletonDrawableUnrecPtr ExampleSkeletonDrawable = SkeletonDrawable::create();
ExampleSkeletonDrawable->setSkeleton(ExampleSkeleton);
ExampleSkeletonDrawable->setMaterial(ExampleMaterial);
ExampleSkeletonDrawable->setDrawBindPose(false); //By default, we don't draw the skeleton's bind pose
ExampleSkeletonDrawable->setBindPoseColor(Color4f(0.0, 1.0, 0.0, 1.0)); //When drawn, the skeleton's bind pose renders green
ExampleSkeletonDrawable->setDrawPose(true); //By default, we do draw the skeleton's current pose
ExampleSkeletonDrawable->setPoseColor(Color4f(0.0, 0.0, 1.0, 1.0)); //The skeleton's current pose renders blue
//Skeleton Node
SkeletonNode = Node::create();
SkeletonNode->setCore(ExampleSkeletonDrawable);
// Skeleton Blended Geometry
// Here we are attaching the "skin" to the skeleton so that when the skeleton is animated, the skin moves with it
ExampleSkeleton->setBaseGeometry(geo);
//Back
ExampleSkeleton->addJointBlending(0,Pelvis,1.0f);
ExampleSkeleton->addJointBlending(1,Pelvis,1.0f);
ExampleSkeleton->addJointBlending(2,Clavicle,1.0f);
ExampleSkeleton->addJointBlending(3,Clavicle,1.0f);
//Head
ExampleSkeleton->addJointBlending(4,Clavicle,1.0f);
ExampleSkeleton->addJointBlending(5,Clavicle,1.0f);
ExampleSkeleton->addJointBlending(6,Head,1.0f);
ExampleSkeleton->addJointBlending(7,Head,1.0f);
//Left Shoulder
ExampleSkeleton->addJointBlending(8,Clavicle,1.0f);
ExampleSkeleton->addJointBlending(9,Clavicle,1.0f);
ExampleSkeleton->addJointBlending(10,LeftShoulder,1.0f);
ExampleSkeleton->addJointBlending(11,LeftShoulder,1.0f);
//Left Humerus
ExampleSkeleton->addJointBlending(12,LeftShoulder,1.0f);
ExampleSkeleton->addJointBlending(13,LeftShoulder,1.0f);
ExampleSkeleton->addJointBlending(14,LeftElbow,0.8f);
ExampleSkeleton->addJointBlending(15,LeftElbow,0.8f);
ExampleSkeleton->addJointBlending(14,LeftHand,0.2f);
ExampleSkeleton->addJointBlending(15,LeftHand,0.2f);
//Left Radius
ExampleSkeleton->addJointBlending(16,LeftElbow,1.0f);
ExampleSkeleton->addJointBlending(17,LeftElbow,1.0f);
ExampleSkeleton->addJointBlending(18,LeftHand,1.0f);
ExampleSkeleton->addJointBlending(19,LeftHand,1.0f);
//Left Hand
ExampleSkeleton->addJointBlending(20,LeftHand,1.0f);
ExampleSkeleton->addJointBlending(21,LeftHand,1.0f);
ExampleSkeleton->addJointBlending(22,LeftFingers,1.0f);
ExampleSkeleton->addJointBlending(23,LeftFingers,1.0f);
//Right Shoulder
ExampleSkeleton->addJointBlending(24,Clavicle,1.0f);
ExampleSkeleton->addJointBlending(25,Clavicle,1.0f);
ExampleSkeleton->addJointBlending(26,RightShoulder,1.0f);
ExampleSkeleton->addJointBlending(27,RightShoulder,1.0f);
//Right Humerus
ExampleSkeleton->addJointBlending(28,RightShoulder,1.0f);
ExampleSkeleton->addJointBlending(29,RightShoulder,1.0f);
ExampleSkeleton->addJointBlending(30,RightElbow,1.0f);
ExampleSkeleton->addJointBlending(31,RightElbow,1.0f);
//Right Radius
ExampleSkeleton->addJointBlending(32,RightElbow,1.0f);
ExampleSkeleton->addJointBlending(33,RightElbow,1.0f);
ExampleSkeleton->addJointBlending(34,RightHand,1.0f);
ExampleSkeleton->addJointBlending(35,RightHand,1.0f);
//Right Hand
ExampleSkeleton->addJointBlending(36,RightHand,1.0f);
ExampleSkeleton->addJointBlending(37,RightHand,1.0f);
ExampleSkeleton->addJointBlending(38,RightFingers,1.0f);
ExampleSkeleton->addJointBlending(39,RightFingers,1.0f);
//Left Hip
ExampleSkeleton->addJointBlending(40,Pelvis,1.0f);
ExampleSkeleton->addJointBlending(41,Pelvis,1.0f);
ExampleSkeleton->addJointBlending(42,LeftHip,1.0f);
ExampleSkeleton->addJointBlending(43,LeftHip,1.0f);
//Left Femur
ExampleSkeleton->addJointBlending(44,LeftHip,1.0f);
ExampleSkeleton->addJointBlending(45,LeftHip,1.0f);
ExampleSkeleton->addJointBlending(46,LeftKnee,1.0f);
ExampleSkeleton->addJointBlending(47,LeftKnee,1.0f);
//Left Tibia
ExampleSkeleton->addJointBlending(48,LeftKnee,1.0f);
ExampleSkeleton->addJointBlending(49,LeftKnee,1.0f);
ExampleSkeleton->addJointBlending(50,LeftFoot,1.0f);
ExampleSkeleton->addJointBlending(51,LeftFoot,1.0f);
//Left Foot
ExampleSkeleton->addJointBlending(52,LeftFoot,1.0f);
ExampleSkeleton->addJointBlending(53,LeftFoot,1.0f);
ExampleSkeleton->addJointBlending(54,LeftToes,1.0f);
ExampleSkeleton->addJointBlending(55,LeftToes,1.0f);
//Right Hip
ExampleSkeleton->addJointBlending(56,Pelvis,1.0f);
ExampleSkeleton->addJointBlending(57,Pelvis,1.0f);
ExampleSkeleton->addJointBlending(58,RightHip,1.0f);
ExampleSkeleton->addJointBlending(59,RightHip,1.0f);
//Right Femur
ExampleSkeleton->addJointBlending(60,RightHip,1.0f);
ExampleSkeleton->addJointBlending(61,RightHip,1.0f);
ExampleSkeleton->addJointBlending(62,RightKnee,1.0f);
ExampleSkeleton->addJointBlending(63,RightKnee,1.0f);
//Right Tibia
ExampleSkeleton->addJointBlending(64,RightKnee,1.0f);
ExampleSkeleton->addJointBlending(65,RightKnee,1.0f);
ExampleSkeleton->addJointBlending(66,RightFoot,1.0f);
ExampleSkeleton->addJointBlending(67,RightFoot,1.0f);
//Right Foot
ExampleSkeleton->addJointBlending(68,RightFoot,1.0f);
ExampleSkeleton->addJointBlending(69,RightFoot,1.0f);
ExampleSkeleton->addJointBlending(70,RightToes,1.0f);
ExampleSkeleton->addJointBlending(71,RightToes,1.0f);
MeshNode = Node::create();
MeshNode->setCore(ExampleSkeleton);
//Create scene node
NodeUnrecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(UnboundGeometry);
scene->addChild(SkeletonNode);
scene->addChild(MeshNode);
mgr->setRoot(scene);
//Setup the Animation
setupAnimation();
//Save to an xml file
FCFileType::FCPtrStore Containers;
Containers.insert(ExampleSkeleton);
Containers.insert(PelvisNode);
Containers.insert(TheSkeletonAnimation);
//Use an empty Ignore types vector
FCFileType::FCTypeVector IgnoreTypes;
//IgnoreTypes.push_back(Node::getClassType().getId());
//Write the Field Containers to a xml file
FCFileHandler::the()->write(Containers,BoostPath("./13Output.xml"),IgnoreTypes);
// Show the whole Scene
mgr->showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"13MeshBlending");
//Main Loop
TutorialWindow->mainLoop();
osgExit();
return 0;
}
NodeTransitPtr RAWSceneFileType::read( std::istream &is,
const Char8 *,
Resolver ) const
{
NodeTransitPtr root;
GeometryUnrecPtr geo;
GeoPnt3fPropertyUnrecPtr points;
GeoVec3fPropertyUnrecPtr normals;
GeoIntegralPropertyUnrecPtr index;
GeoIntegralPropertyUnrecPtr lens;
GeoIntegralPropertyUnrecPtr type;
Vec3f vec[3];
UInt32 i = 0, n, triCount = 0;
Real32 x,y,z;
if(is)
{
root = Node ::create();
geo = Geometry::create();
root->setCore( geo );
points = GeoPnt3fProperty::create();
geo->setPositions(points);
normals = GeoVec3fProperty::create();
geo->setNormals(normals);
triCount = i = 0;
while(1)
{
is >> x >> y >> z;
if(is.eof())
{
break;
}
else
{
points->editFieldPtr()->push_back(Pnt3f(x, y, z));
vec[i].setValues(x,y,z);
std::cerr << x << " " << y << " " << z << std::endl;
if(i == 2)
{
vec[0] -= vec[1];
vec[1] -= vec[2];
vec[0].crossThis(vec[1]);
vec[0].normalize();
normals->editFieldPtr()->push_back(vec[0]);
normals->editFieldPtr()->push_back(vec[0]);
normals->editFieldPtr()->push_back(vec[0]);
i = 0;
triCount++;
}
else
{
i++;
}
}
}
if(triCount != 0)
{
index = GeoUInt32Property::create();
geo->setIndex(index, Geometry::PositionsIndex);
geo->setIndex(index, Geometry::NormalsIndex );
n = triCount * 3;
for(i = 0; i < n; i++)
index->push_back(i);
lens = GeoUInt32Property::create();
geo->setLengths(lens);
lens->push_back(n);
type = GeoUInt8Property::create();
geo->setTypes(type);
type->push_back(GL_TRIANGLES);
}
SimpleMaterialUnrecPtr mat = SimpleMaterial::create();
mat->setDiffuse (Color3f( .8f, .8f, .8f));
mat->setSpecular (Color3f( 1.f, 1.f, 1.f ));
mat->setShininess(20.f );
geo->setMaterial(mat);
}
if(triCount)
{
SNOTICE << triCount << " triangle read " << std::endl;
}
commitChanges();
return root;
}
void VTKPolyDataMapper::initGeometries(void)
{
NodeUnrecPtr pRoot = Node::create();
pRoot->setCore(Group::create());
setRoot(pRoot);
for(UInt32 i = 0; i < 4; ++i)
{
GeometryUnrecPtr pGeo = Geometry::create();
ChunkMaterialUnrecPtr pMat = ChunkMaterial::create();
MaterialChunkUnrecPtr pMatChunk = MaterialChunk::create();
GeoPnt3fPropertyUnrecPtr pPoints = GeoPnt3fProperty ::create();
GeoUInt32PropertyUnrecPtr pLengths = GeoUInt32Property ::create();
GeoUInt8PropertyUnrecPtr pTypes = GeoUInt8Property ::create();
GeoColor4fPropertyUnrecPtr pColors = GeoColor4fProperty::create();
GeoVec3fPropertyUnrecPtr pNormals = GeoVec3fProperty ::create();
if(i < 2)
{
pMatChunk->setLit(false);
}
pMatChunk->setDiffuse (OSG::Color4f(1.0, 1.0, 1.0, 1.0));
pMatChunk->setSpecular (OSG::Color4f(0.0, 0.0, 0.0, 1.0));
pMatChunk->setShininess(10.0f);
pMat->addChunk(pMatChunk);
TwoSidedLightingChunkUnrecPtr pTSLChunk =
TwoSidedLightingChunk::create();
pMat->addChunk(pTSLChunk);
pGeo->setDlistCache(false );
pGeo->setMaterial (pMat );
pGeo->setPositions (pPoints );
pGeo->setLengths (pLengths);
pGeo->setTypes (pTypes );
pGeo->setColors (pColors );
if(i > 1)
{
pGeo->setNormals(pNormals);
}
OSG::NodeUnrecPtr pGeoRoot = OSG::Node::create();
pGeoRoot->setCore (pGeo);
pGeoRoot->setTravMask(0 );
pRoot->addChild(pGeoRoot);
this->pushToGeometries (pGeo );
this->pushToMaterials (pMat );
this->pushToMaterialChunks(pMatChunk);
this->pushToPositions (pPoints );
this->pushToLength (pLengths );
this->pushToTypes (pTypes );
this->pushToColors (pColors );
this->pushToNormals (pNormals );
this->pushToGeoRoots (pGeoRoot );
}
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
//Initialize Window
TutorialWindow->initWindow();
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
//Attach to events
TutorialWindow->connectMousePressed(boost::bind(mousePressed, _1, &sceneManager));
TutorialWindow->connectMouseReleased(boost::bind(mouseReleased, _1, &sceneManager));
TutorialWindow->connectMouseDragged(boost::bind(mouseDragged, _1, &sceneManager));
TutorialWindow->connectMouseWheelMoved(boost::bind(mouseWheelMoved, _1, &sceneManager));
//Torus Material
SimpleMaterialUnrecPtr TheTorusMaterial = SimpleMaterial::create();
TheTorusMaterial->setAmbient(Color3f(0.3,0.3,0.3));
TheTorusMaterial->setDiffuse(Color3f(0.7,0.7,0.7));
TheTorusMaterial->setSpecular(Color3f(1.0,1.0,1.0));
TheTorusMaterial->setShininess(20.0);
//Torus Geometry
GeometryUnrecPtr TorusGeometry = makeTorusGeo(.5, 2, 32, 32);
TorusGeometry->setMaterial(TheTorusMaterial);
NodeUnrecPtr TorusGeometryNode = Node::create();
TorusGeometryNode->setCore(TorusGeometry);
//Make Torus Node
NodeUnrecPtr TorusNode = Node::create();
TransformUnrecPtr TorusNodeTrans = Transform::create();
setName(TorusNodeTrans, std::string("TorusNodeTransformationCore"));
TorusNode->setCore(TorusNodeTrans);
TorusNode->addChild(TorusGeometryNode);
//Make Main Scene Node
NodeUnrecPtr scene = Node::create();
ComponentTransformUnrecPtr Trans = ComponentTransform::create();
setName(Trans, std::string("MainTransformationCore"));
scene->setCore(Trans);
// add the torus as a child
scene->addChild(TorusNode);
AnimationGroupUnrecPtr TheAnimation = setupAnimation(TheTorusMaterial, TorusNodeTrans);
TutorialWindow->connectKeyPressed(boost::bind(keyPressed, _1,
TheAnimation.get(),
TutorialWindow.get()));
TheAnimation->attachUpdateProducer(TutorialWindow);
TheAnimation->start();
// tell the manager what to manage
sceneManager.setRoot (scene);
//Create the Documentation
SimpleScreenDoc TheSimpleScreenDoc(&sceneManager, TutorialWindow);
// show the whole scene
sceneManager.showAll();
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"07AnimationGroup");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
void PlaneMoveManipulator::onCreate(const PlaneMoveManipulator* source)
{
// Skip direct parent, don't want the default geometry creation
Transform::onCreate(source);
SimpleMaterialUnrecPtr pMat = SimpleMaterial::create();
pMat->setDiffuse(Color3f(.5, .5, .5));
pMat->setLit (false );
setMaterialX(pMat);
pMat = SimpleMaterial::create();
pMat->setDiffuse(Color3f(0, 1, 0));
pMat->setLit (false );
LineChunkUnrecPtr lc = LineChunk::create();
lc->setWidth(3);
pMat->addChunk(lc);
setMaterialY(pMat);
pMat = SimpleMaterial::create();
pMat->setDiffuse(Color3f(0., 0., 1.));
pMat->setLit (true );
setMaterialZ(pMat);
// SimpleMaterial *simpleMat;
// Geometry *geo;
setExternalUpdateHandler(NULL);
// add a name attachment
NameUnrecPtr nameN = Name::create();
nameN->editFieldPtr()->setValue("XYManipulator");
addAttachment(nameN);
// make the axis line. Not really a handle, but easier to manage this way.
GeoBuilder b;
b.vertex(Pnt3f(0,0,0));
b.vertex(Pnt3f(0,getLength()[1],0));
b.line(0, 1);
GeometryUnrecPtr g = b.getGeometry();
g->setMaterial(getMaterialY());
NodeUnrecPtr pNode = makeNodeFor(g);
setTransYNode(pNode);
// make the plane handle
pNode = Node::create();
setTransXNode(pNode);
g = makePlaneGeo(getLength()[0] / 2.f, getLength()[2] / 2.f, 1, 1);
g->setMaterial(getMaterialX());
pNode = makeNodeFor(g);
OSG::ComponentTransformUnrecPtr transHandleXC = ComponentTransform::create();
setHandleXNode(pNode);
getTransXNode()->setCore (transHandleXC );
getTransXNode()->addChild(getHandleXNode());
transHandleXC->setTranslation(Vec3f(0, getLength()[1], 0));
transHandleXC->setRotation (Quaternion(Vec3f(1, 0, 0), osgDegree2Rad(90)));
//
// make the rotate handle
pNode = Node::create();
setTransZNode(pNode);
g = makeCylinderGeo(0.05f, 0.1f, 16, true, true, true);
g->setMaterial(getMaterialZ());
pNode = makeNodeFor(g);
OSG::ComponentTransformUnrecPtr transHandleZC = ComponentTransform::create();
setHandleZNode(pNode);
getTransZNode()->setCore (transHandleZC );
getTransZNode()->addChild(getHandleZNode());
transHandleZC->setTranslation(Vec3f(0, getLength()[1], 0));
commitChanges();
}
void
OSBGeometryElement::readV100(void)
{
OSG_OSB_LOG(("OSBGeometryElement::readV100:\n"));
OSBRootElement *root = editRoot();
BinaryReadHandler *rh = editRoot()->getReadHandler();
OSBGeometryHelper gh;
GeometryUnrecPtr geo = Geometry::create();
setContainer(geo);
// The "properties" mfield can be thought of the unification of the
// "positions", "normals", etc sfields of the 1.x Geometry.
// For the conversion the PtrFieldInfo structure for the "properties"
// mfield is filled with the corresponding ids of the sfields from the
// file. The remapping after postRead will fill in the right pointers.
FieldDescriptionBase *propFieldDesc =
geo->getFieldDescription("properties");
UInt32 propFieldId = propFieldDesc->getFieldId();
root->editPtrFieldList().push_back(PtrFieldInfo(geo, propFieldId));
PtrFieldInfo &propFieldPFI = root->editPtrFieldList().back();
propFieldPFI.editIdStore().resize(Geometry::MaxAttribs);
while(true)
{
std::string fieldName;
std::string fieldTypeName;
UInt32 fieldSize;
PtrFieldListIt ptrFieldIt;
if(!readFieldHeader("", fieldName, fieldTypeName, fieldSize))
{
OSG_OSB_LOG(("OSBGeometryElement::readV100: "
"Reading stopped at field: [%s].\n", fieldName.c_str()));
break;
}
if(fieldName == "indexMapping")
{
// read into temporary field
MField<UInt16> indexMappingField;
indexMappingField.copyFromBin(*rh);
// copy to member for use in postRead
indexMappingField.getValues().swap(_indexMapping);
}
else if(fieldName == "indices")
{
// read container id of indices property
// postRead will handle the conversion of multi indices
rh->getValue(_indicesId);
}
else if(fieldName == "positions")
{
UInt32 positionsId;
rh->getValue(positionsId);
propFieldPFI.editIdStore()[Geometry::PositionsIndex] = positionsId;
}
else if(fieldName == "normals")
{
UInt32 normalsId;
rh->getValue(normalsId);
propFieldPFI.editIdStore()[Geometry::NormalsIndex] = normalsId;
}
else if(fieldName == "colors")
{
UInt32 colorsId;
rh->getValue(colorsId);
propFieldPFI.editIdStore()[Geometry::ColorsIndex] = colorsId;
}
else if(fieldName == "secondaryColors")
{
UInt32 secondaryColorsId;
rh->getValue(secondaryColorsId);
propFieldPFI.editIdStore()[Geometry::SecondaryColorsIndex] =
secondaryColorsId;
}
else if(fieldName == "texCoords")
{
UInt32 texCoordsId;
rh->getValue(texCoordsId);
propFieldPFI.editIdStore()[Geometry::TexCoordsIndex] =
texCoordsId;
}
else if(fieldName == "texCoords1")
{
UInt32 texCoordsId1;
rh->getValue(texCoordsId1);
propFieldPFI.editIdStore()[Geometry::TexCoords1Index] =
texCoordsId1;
}
else if(fieldName == "texCoords2")
{
UInt32 texCoordsId2;
rh->getValue(texCoordsId2);
propFieldPFI.editIdStore()[Geometry::TexCoords2Index] =
texCoordsId2;
}
else if(fieldName == "texCoords3")
{
UInt32 texCoordsId3;
rh->getValue(texCoordsId3);
propFieldPFI.editIdStore()[Geometry::TexCoords3Index] =
texCoordsId3;
}
else if(fieldName == "texCoords4")
{
UInt32 texCoordsId4;
rh->getValue(texCoordsId4);
propFieldPFI.editIdStore()[Geometry::TexCoords4Index] =
texCoordsId4;
}
else if(fieldName == "texCoords5")
{
UInt32 texCoordsId5;
rh->getValue(texCoordsId5);
propFieldPFI.editIdStore()[Geometry::TexCoords5Index] =
texCoordsId5;
}
else if(fieldName == "texCoords6")
{
UInt32 texCoordsId6;
rh->getValue(texCoordsId6);
propFieldPFI.editIdStore()[Geometry::TexCoords6Index] =
texCoordsId6;
}
else if(fieldName == "texCoords7")
{
UInt32 texCoordsId7;
rh->getValue(texCoordsId7);
propFieldPFI.editIdStore()[Geometry::TexCoords7Index] =
texCoordsId7;
}
else if(fieldName == "pindices")
{
UInt32 maxValue;
UInt32 propSize;
UInt32 byteSize;
_indicesPacked = true;
gh.readPackedIntegralPropertyHeader(rh, maxValue,
propSize, byteSize);
if(root->getOptions().unpack16BitIndices())
{
if(maxValue > TypeTraits<UInt16>::getMax())
{
GeoUInt32PropertyUnrecPtr ui32Indices =
GeoUInt32Property::create();
gh.readPackedIntegralProperty(rh, ui32Indices, maxValue,
propSize, byteSize );
_indices16Bit = false;
_indices = ui32Indices;
}
else
{
GeoUInt16PropertyUnrecPtr ui16Indices =
GeoUInt16Property::create();
gh.readPackedIntegralProperty(rh, ui16Indices, maxValue,
propSize, byteSize );
_indices16Bit = true;
_indices = ui16Indices;
}
}
else
{
GeoUInt32PropertyUnrecPtr ui32Indices =
GeoUInt32Property::create();
gh.readPackedIntegralProperty(rh, ui32Indices, maxValue,
propSize, byteSize );
_indices16Bit = false;
_indices = ui32Indices;
}
}
else if(fieldName == "qpositions")
{
// Quantized positions are stored inside the geometry object, not
// in the geo-property. They are always of type Pnt3f.
GeoPnt3fPropertyUnrecPtr propPos = GeoPnt3fProperty::create();
UInt8 resolution;
Real32 minValue;
Real32 maxValue;
UInt32 propSize;
gh.readQuantizedVectorPropertyHeader(rh, resolution, minValue,
maxValue, propSize );
gh.readQuantizedVectorProperty(rh, propPos, fieldSize, resolution,
minValue, maxValue, propSize );
geo->setProperty(propPos, Geometry::PositionsIndex);
}
else if(fieldName == "qnormals")
{
// Quantized normals are stored inside the geometry object, not
// in the geo-property. They are always of type Vec3f.
GeoVec3fPropertyUnrecPtr propNorm = GeoVec3fProperty::create();
UInt8 resolution;
Real32 minValue;
Real32 maxValue;
UInt32 propSize;
gh.readQuantizedVectorPropertyHeader(
rh, resolution, minValue, maxValue, propSize);
gh.readQuantizedVectorProperty(
rh, propNorm, fieldSize, resolution,
minValue, maxValue, propSize );
geo->setProperty(propNorm, Geometry::NormalsIndex);
}
else if(fieldName == "qtexCoords")
{
// Quantized texCoords are stored inside the geometry object, not
// in the geo-property. They are always of type Vec2f.
GeoVec2fPropertyUnrecPtr propTexCoords = GeoVec2fProperty::create();
UInt8 resolution;
Real32 minValue;
Real32 maxValue;
UInt32 propSize;
gh.readQuantizedVectorPropertyHeader(
rh, resolution, minValue, maxValue, propSize);
gh.readQuantizedVectorProperty(
rh, propTexCoords, fieldSize, resolution,
minValue, maxValue, propSize );
geo->setProperty(propTexCoords, Geometry::NormalsIndex);
}
else
{
// 1.x Geometry has _sfVbo, it can be skipped
readFieldContent(fieldName, fieldTypeName, fieldSize,
"'vbo'", ptrFieldIt );
}
}
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// Set up Window
TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
//Add Window Listener
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
TutorialMouseListener TheTutorialMouseListener;
TutorialMouseMotionListener TheTutorialMouseMotionListener;
TutorialWindow->addMouseListener(&TheTutorialMouseListener);
TutorialWindow->addMouseMotionListener(&TheTutorialMouseMotionListener);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindow);
//Shader Material
BlendChunkUnrecPtr ExampleBlendChunk = BlendChunk::create();
ExampleBlendChunk->setSrcFactor(GL_SRC_ALPHA);
ExampleBlendChunk->setDestFactor(GL_ONE_MINUS_SRC_ALPHA);
//Material Chunk
MaterialChunkUnrecPtr ShaderMaterialChunk = MaterialChunk::create();
ShaderMaterialChunk->setAmbient(Color4f(0.4f,0.4f,0.4f,1.0f));
ShaderMaterialChunk->setDiffuse(Color4f(0.7f,0.7f,0.7f,1.0f));
ShaderMaterialChunk->setSpecular(Color4f(1.0f,1.0f,1.0f,1.0f));
//Shader Chunk
SimpleSHLChunkUnrecPtr TheSHLChunk = SimpleSHLChunk::create();
TheSHLChunk->setVertexProgram(createSHLVertexProg());
TheSHLChunk->setFragmentProgram(createSHLFragProg());
//Color Parameter
ShaderVariableVec4fUnrecPtr Color1Parameter = ShaderVariableVec4f::create();
Color1Parameter->setName("Color1");
Color1Parameter->setValue(Vec4f(0.0f,1.0f,0.0f,1.0f));
ShaderVariableVec4fUnrecPtr Color2Parameter = ShaderVariableVec4f::create();
Color2Parameter->setName("Color2");
Color2Parameter->setValue(Vec4f(1.0f,1.0f,1.0f,1.0f));
//Shader Parameter Chunk
SHLParameterChunkUnrecPtr SHLParameters = SHLParameterChunk::create();
SHLParameters->getParameters().push_back(Color1Parameter);
SHLParameters->getParameters().push_back(Color2Parameter);
SHLParameters->setSHLChunk(TheSHLChunk);
ChunkMaterialUnrecPtr ShaderMaterial = ChunkMaterial::create();
ShaderMaterial->addChunk(ShaderMaterialChunk);
ShaderMaterial->addChunk(TheSHLChunk);
ShaderMaterial->addChunk(SHLParameters);
//Torus Node
GeometryUnrecPtr TorusGeometry = makeTorusGeo(5.0f,20.0f, 32,32);
TorusGeometry->setMaterial(ShaderMaterial);
NodeUnrecPtr TorusNode = Node::create();
TorusNode->setCore(TorusGeometry);
// Make Main Scene Node
NodeUnrecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusNode);
mgr->setRoot(scene);
// Show the whole Scene
mgr->showAll();
//Create the Animations
initAnimations(Color1Parameter, "value");
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"04ShaderAnimation");
//Main Loop
TutorialWindow->mainLoop();
osgExit();
return 0;
}
// Initialize GLUT & OpenSG and set up the rootNode
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// Set up Window
TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
TutorialMouseListener TheTutorialMouseListener;
TutorialMouseMotionListener TheTutorialMouseMotionListener;
TutorialWindow->addMouseListener(&TheTutorialMouseListener);
TutorialWindow->addMouseMotionListener(&TheTutorialMouseMotionListener);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindow);
//Make Torus Node
NodeUnrecPtr TorusNode = makeTorus(.5, 2, 32, 32);
//Make Main Scene Node
NodeUnrecPtr scene = makeCoredNode<Group>();
setName(scene, "scene");
rootNode = Node::create();
setName(rootNode, "rootNode");
ComponentTransformUnrecPtr Trans;
Trans = ComponentTransform::create();
rootNode->setCore(Trans);
// add the torus as a child
rootNode->addChild(scene);
//Setup Physics Scene
physicsWorld = PhysicsWorld::create();
physicsWorld->setWorldContactSurfaceLayer(0.005);
physicsWorld->setAutoDisableFlag(1);
physicsWorld->setAutoDisableTime(0.75);
physicsWorld->setWorldContactMaxCorrectingVel(100.0);
physicsWorld->setGravity(Vec3f(0.0, 0.0, -9.81));
//physicsSpace = PhysicsSimpleSpace::create();
//physicsSpace = PhysicsQuadTreeSpace::create();
//physicsSpace = PhysicsHashSpace::create();
physicsSpace = PhysicsSweepAndPruneSpace::create();
CollisionContactParametersUnrecPtr DefaultCollisionParams = CollisionContactParameters::createEmpty();
DefaultCollisionParams->setMode(dContactApprox1 | dContactBounce);
DefaultCollisionParams->setMu(0.3);
DefaultCollisionParams->setMu2(0.0);
DefaultCollisionParams->setBounce(0.2);
DefaultCollisionParams->setBounceSpeedThreshold(0.1);
DefaultCollisionParams->setSoftCFM(0.1);
DefaultCollisionParams->setSoftERP(0.2);
DefaultCollisionParams->setMotion1(0.0);
DefaultCollisionParams->setMotion2(0.0);
DefaultCollisionParams->setMotionN(0.0);
DefaultCollisionParams->setSlip1(0.0);
DefaultCollisionParams->setSlip2(0.0);
physicsSpace->setDefaultCollisionParameters(DefaultCollisionParams);
physHandler = PhysicsHandler::create();
physHandler->setWorld(physicsWorld);
physHandler->pushToSpaces(physicsSpace);
physHandler->setUpdateNode(rootNode);
physHandler->attachUpdateProducer(TutorialWindow->editEventProducer());
rootNode->addAttachment(physHandler);
rootNode->addAttachment(physicsWorld);
rootNode->addAttachment(physicsSpace);
/************************************************************************/
/* create spaces, geoms and bodys */
/************************************************************************/
//create a group for our space
GroupUnrecPtr spaceGroup;
spaceGroupNode = makeCoredNode<Group>(&spaceGroup);
//create the ground plane
GeometryUnrecPtr plane;
NodeUnrecPtr planeNode = makeBox(30.0, 30.0, 1.0, 1, 1, 1);
plane = dynamic_cast<Geometry*>(planeNode->getCore());
//and its Material
SimpleMaterialUnrecPtr plane_mat = SimpleMaterial::create();
plane_mat->setAmbient(Color3f(0.7,0.7,0.7));
plane_mat->setDiffuse(Color3f(0.9,0.6,1.0));
plane->setMaterial(plane_mat);
//create Physical Attachments
PhysicsBoxGeomUnrecPtr planeGeom = PhysicsBoxGeom::create();
planeGeom->setLengths(Vec3f(30.0, 30.0, 1.0));
//add geoms to space for collision
planeGeom->setSpace(physicsSpace);
//add Attachments to nodes...
spaceGroupNode->addAttachment(physicsSpace);
spaceGroupNode->addChild(planeNode);
planeNode->addAttachment(planeGeom);
scene->addChild(spaceGroupNode);
//Create Statistics Foreground
SimpleStatisticsForegroundUnrecPtr PhysicsStatForeground = SimpleStatisticsForeground::create();
PhysicsStatForeground->setSize(25);
PhysicsStatForeground->setColor(Color4f(0,1,0,0.7));
PhysicsStatForeground->addElement(PhysicsHandler::statPhysicsTime,
"Physics time: %.3f s");
PhysicsStatForeground->addElement(PhysicsHandler::statCollisionTime,
"Collision time: %.3f s");
PhysicsStatForeground->addElement(PhysicsHandler::statSimulationTime,
"Simulation time: %.3f s");
PhysicsStatForeground->addElement(PhysicsHandler::statNCollisions,
"%d collisions");
PhysicsStatForeground->addElement(PhysicsHandler::statNCollisionTests,
"%d collision tests");
PhysicsStatForeground->addElement(PhysicsHandler::statNPhysicsSteps,
"%d simulation steps per frame");
// tell the manager what to manage
mgr->setRoot (rootNode);
mgr->getWindow()->getPort(0)->addForeground(PhysicsStatForeground);
physHandler->setStatistics(PhysicsStatForeground->getCollector());
// show the whole rootNode
mgr->showAll();
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"05Explosion");
//Enter main Loop
TutorialWindow->mainLoop();
osgExit();
return 0;
}
