void updateScene()
{
NodePtr roseNodePtr = createRose();
NodePtr topNodePtr = createTag("top", Vec3f(0, 1, 0));
NodePtr bottomNodePtr = createTag("bottom", Vec3f(0, -1, 0));
NodePtr leftNodePtr = createTag("left", Vec3f(-1, 0, 0));
NodePtr rightNodePtr = createTag("right", Vec3f(1, 0, 0));
NodePtr frontNodePtr = createTag("front", Vec3f(0, 0, 1));
NodePtr backNodePtr = createTag("back", Vec3f(0, 0, -1));
beginEditCP(scene, Node::ChildrenFieldMask);
{
scene->addChild(topNodePtr);
scene->addChild(bottomNodePtr);
scene->addChild(leftNodePtr);
scene->addChild(rightNodePtr);
scene->addChild(frontNodePtr);
scene->addChild(backNodePtr);
scene->addChild(roseNodePtr);
}
endEditCP(scene, Node::ChildrenFieldMask);
mgr->showAll();
glutPostRedisplay();
}
NodePtr createScene(void)
{
//Make Main Scene Node
NodePtr scene = osg::Node::create();
osg::ComponentTransformPtr Trans;
Trans = osg::ComponentTransform::create();
osg::setName(Trans, std::string("MainTransformationCore"));
beginEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
scene->setCore(Trans);
for (int i(0); i < SkeletonNodes.size(); ++i)
{
scene->addChild(SkeletonNodes[i]);
}
for (int i(0); i < UnboundGeometries.size(); ++i)
{
scene->addChild(UnboundGeometries[i]);
}
for (int i(0); i < MeshNodes.size(); ++i)
{
scene->addChild(MeshNodes[i]);
}
endEditCP (scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
return scene;
}
virtual void started(const DialogEventPtr e)
{
if(DialogPtr::dcast(e->getSource()) == BDialogChildB)
{
NodePtr s = makeSphere(1,2);
beginEditCP(scene, Node::ChildrenFieldMask);
while(scene->getNChildren() > 0)
{
scene->subChild(scene->getNChildren()-1);
}
scene->addChild(s);
endEditCP(scene, Node::ChildrenFieldMask);
}
if(DialogPtr::dcast(e->getSource()) == BDialogChildA)
{
NodePtr s = makeBox(3,3,3,2,2,2);
beginEditCP(scene, Node::ChildrenFieldMask);
while(scene->getNChildren() > 0)
{
scene->subChild(scene->getNChildren()-1);
}
scene->addChild(s);
endEditCP(scene, Node::ChildrenFieldMask);
}
if(DialogPtr::dcast(e->getSource()) == ADialogChildA)
{
beginEditCP(MainInternalWindowBackground, ColorLayer::ColorFieldMask);
MainInternalWindowBackground->setColor(Color4f(0.0,0.0,1.0,0.5));
endEditCP(MainInternalWindowBackground, ColorLayer::ColorFieldMask);
}
if(DialogPtr::dcast(e->getSource()) == ADialogChildB)
{
beginEditCP(MainInternalWindowBackground, ColorLayer::ColorFieldMask);
MainInternalWindowBackground->setColor(Color4f(1.0,0.0,0.0,0.5));
endEditCP(MainInternalWindowBackground, ColorLayer::ColorFieldMask);
}
if(DialogPtr::dcast(e->getSource()) == End1 || DialogPtr::dcast(e->getSource()) == End2 || DialogPtr::dcast(e->getSource()) == End3 || DialogPtr::dcast(e->getSource()) == End4 )
{
TutorialWindowEventProducer->closeWindow();
}
if(DialogPtr::dcast(e->getSource()) == Restart1 || DialogPtr::dcast(e->getSource()) == Restart2 || DialogPtr::dcast(e->getSource()) == Restart3 || DialogPtr::dcast(e->getSource()) == Restart4)
{
beginEditCP(MainInternalWindowBackground, ColorLayer::ColorFieldMask);
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
endEditCP(MainInternalWindowBackground, ColorLayer::ColorFieldMask);
NodePtr s = makeTorus(.5, 2, 16, 16);
beginEditCP(scene, Node::ChildrenFieldMask);
while(scene->getNChildren() > 0)
{
scene->subChild(scene->getNChildren()-1);
}
scene->addChild(s);
endEditCP(scene, Node::ChildrenFieldMask);
}
}
//////////////////////////////////////////////////////////////////////////
//! build a box
//////////////////////////////////////////////////////////////////////////
void buildBox(void)
{
Vec3f Lengths(frand()*2.0+0.5, frand()*2.0+0.5, frand()*2.0+0.5);
Matrix m;
//create OpenSG mesh
GeometryPtr box;
NodePtr boxNode = makeBox(Lengths.x(), Lengths.y(), Lengths.z(), 1, 1, 1);
box = GeometryPtr::dcast(boxNode->getCore());
SimpleMaterialPtr box_mat = SimpleMaterial::create();
beginEditCP(box_mat);
box_mat->setAmbient(Color3f(0.0,0.0,0.0));
box_mat->setDiffuse(Color3f(0.0,1.0 ,0.0));
endEditCP(box_mat);
beginEditCP(box, Geometry::MaterialFieldMask);
box->setMaterial(box_mat);
endEditCP(box, Geometry::MaterialFieldMask);
TransformPtr boxTrans;
NodePtr boxTransNode = makeCoredNode<Transform>(&boxTrans);
m.setIdentity();
Real32 randX = frand()*10.0-5.0;
Real32 randY = frand()*10.0-5.0;
m.setTranslate(randX, randY, 10.0);
beginEditCP(boxTrans, Transform::MatrixFieldMask);
boxTrans->setMatrix(m);
endEditCP(boxTrans, Transform::MatrixFieldMask);
//create ODE data
PhysicsBodyPtr boxBody = PhysicsBody::create(physicsWorld);
beginEditCP(boxBody, PhysicsBody::PositionFieldMask);
boxBody->setPosition(Vec3f(randX, randY, 10.0));
endEditCP(boxBody, PhysicsBody::PositionFieldMask);
boxBody->setBoxMass(1.0, Lengths.x(), Lengths.y(), Lengths.z());
PhysicsBoxGeomPtr boxGeom = PhysicsBoxGeom::create();
beginEditCP(boxGeom, PhysicsBoxGeom::BodyFieldMask | PhysicsBoxGeom::SpaceFieldMask | PhysicsBoxGeom::LengthsFieldMask | PhysicsBoxGeom::CategoryBitsFieldMask);
boxGeom->setBody(boxBody);
boxGeom->setSpace(physicsSpace);
boxGeom->setLengths(Lengths);
boxGeom->setCategoryBits(BoxCategory);
endEditCP(boxGeom, PhysicsBoxGeom::BodyFieldMask | PhysicsBoxGeom::SpaceFieldMask | PhysicsBoxGeom::LengthsFieldMask | PhysicsBoxGeom::CategoryBitsFieldMask);
//add attachments
beginEditCP(boxNode, Node::AttachmentsFieldMask);
boxNode->addAttachment(boxGeom);
endEditCP(boxNode, Node::AttachmentsFieldMask);
beginEditCP(boxTransNode, Node::AttachmentsFieldMask | Node::ChildrenFieldMask);
boxTransNode->addAttachment(boxBody);
boxTransNode->addChild(boxNode);
endEditCP(boxTransNode, Node::AttachmentsFieldMask | Node::ChildrenFieldMask);
//add to SceneGraph
beginEditCP(spaceGroupNode, Node::ChildrenFieldMask);
spaceGroupNode->addChild(boxTransNode);
endEditCP(spaceGroupNode, Node::ChildrenFieldMask);
}
//////////////////////////////////////////////////////////////////////////
//! build a sphere
//////////////////////////////////////////////////////////////////////////
void buildSphere(void)
{
Real32 Radius(frand()*1.5+0.2);
Matrix m;
//create OpenSG mesh
GeometryPtr sphere;
NodePtr sphereNode = makeSphere(2, Radius);
sphere = GeometryPtr::dcast(sphereNode->getCore());
SimpleMaterialPtr sphere_mat = SimpleMaterial::create();
beginEditCP(sphere_mat);
sphere_mat->setAmbient(Color3f(0.0,0.0,0.0));
sphere_mat->setDiffuse(Color3f(0.0,0.0,1.0));
endEditCP(sphere_mat);
beginEditCP(sphere, Geometry::MaterialFieldMask);
sphere->setMaterial(sphere_mat);
endEditCP(sphere);
TransformPtr sphereTrans;
NodePtr sphereTransNode = makeCoredNode<Transform>(&sphereTrans);
m.setIdentity();
Real32 randX = frand()*10.0-5.0;
Real32 randY = frand()*10.0-5.0;
m.setTranslate(randX, randY, 10.0);
beginEditCP(sphereTrans, Transform::MatrixFieldMask);
sphereTrans->setMatrix(m);
endEditCP(sphereTrans);
//create ODE data
PhysicsBodyPtr sphereBody = PhysicsBody::create(physicsWorld);
beginEditCP(sphereBody, PhysicsBody::PositionFieldMask | PhysicsBody::AngularDampingFieldMask);
sphereBody->setPosition(Vec3f(randX, randY, 10.0));
sphereBody->setAngularDamping(0.0001);
endEditCP(sphereBody, PhysicsBody::PositionFieldMask | PhysicsBody::AngularDampingFieldMask);
sphereBody->setSphereMass(0.4,Radius);
PhysicsSphereGeomPtr sphereGeom = PhysicsSphereGeom::create();
beginEditCP(sphereGeom, PhysicsSphereGeom::BodyFieldMask | PhysicsSphereGeom::SpaceFieldMask | PhysicsSphereGeom::RadiusFieldMask | PhysicsSphereGeom::CategoryBitsFieldMask);
sphereGeom->setBody(sphereBody);
sphereGeom->setSpace(physicsSpace);
sphereGeom->setRadius(Radius);
sphereGeom->setCategoryBits(SphereCategory);
endEditCP(sphereGeom, PhysicsSphereGeom::BodyFieldMask | PhysicsSphereGeom::SpaceFieldMask | PhysicsSphereGeom::RadiusFieldMask | PhysicsSphereGeom::CategoryBitsFieldMask);
//add attachments
beginEditCP(sphereNode, Node::AttachmentsFieldMask);
sphereNode->addAttachment(sphereGeom);
endEditCP(sphereNode);
beginEditCP(sphereTransNode, Node::AttachmentsFieldMask | Node::ChildrenFieldMask);
sphereTransNode->addAttachment(sphereBody);
sphereTransNode->addChild(sphereNode);
endEditCP(sphereTransNode);
//add to SceneGraph
beginEditCP(spaceGroupNode, Node::ChildrenFieldMask);
spaceGroupNode->addChild(sphereTransNode);
endEditCP(spaceGroupNode);
}
void
IceXML::DocumentBuilder::startElement(const string& name, const Attributes& attributes, int line, int column)
{
NodePtr parent = _nodeStack.front();
Element* element = new Element(parent, name, attributes, line, column);
#ifdef NDEBUG
parent->addChild(element);
#else
assert(parent->addChild(element));
#endif
_nodeStack.push_front(element);
}
static NodePtr makePerturbedUniform (UInt16 numSubdiv,
Real32 radius,
Real32 rate = 0.1f)
{
static Real32 factor = 1.1f;
NodePtr sphereNode = makeSphere(numSubdiv, radius);
GeometryPtr sphere = GeometryPtr::dcast(sphereNode->getCore());
GeoPositionsPtr points = sphere->getPositions();
beginEditCP(points);
for (UInt32 i=0; i<points->size(); ++i) {
Real32 random = (rand()/Real32(RAND_MAX));
if (random <= rate) {
points->setValue(factor*points->getValue(i), i);
}
}
endEditCP(points);
NodePtr node = Node::create();
beginEditCP(node);
node->setCore(Transform::create());
node->addChild(sphereNode);
endEditCP(node);
return node;
}
void
IceXML::DocumentBuilder::characters(const string& data, int line, int column)
{
NodePtr parent = _nodeStack.front();
TextPtr text = new Text(parent, data, line, column);
parent->addChild(text);
}
NodePtr makeTransformedCube (Real32 xsize,
Real32 ysize,
Real32 zsize,
UInt16 hor,
UInt16 vert,
UInt16 depth,
const Color3f& c)
{
GeoColors3fPtr color = GeoColors3f::create();
beginEditCP(color);
color->addValue(c);
endEditCP(color);
GeometryPtr box = makeBoxGeo(xsize, ysize, zsize, hor, vert, depth);
beginEditCP(box);
box->setColors(color);
endEditCP(box);
NodePtr boxNode = Node::create();
beginEditCP(boxNode);
boxNode->setCore(box);
endEditCP(boxNode);
NodePtr node = Node::create();
beginEditCP(node);
node->setCore(Transform::create());
node->addChild(boxNode);
endEditCP(node);
return node;
}
virtual void setRoot ( NodePtr root )
{
if(_internalRoot == NullFC)
{
initialize();
}
if(_root != root)
{
if(_root != NullFC)
{
beginEditCP(_internalRoot, Node::ChildrenFieldMask);
_internalRoot->subChild(_root);
endEditCP(_internalRoot, Node::ChildrenFieldMask);
}
_root = root;
if(_root != NullFC)
{
beginEditCP(_internalRoot, Node::ChildrenFieldMask);
_internalRoot->addChild(_root);
endEditCP(_internalRoot, Node::ChildrenFieldMask);
}
}
}
NodePtr createScene(void)
{
endEditCP(_pos);
std::map<UInt32, GeoIndicesPtr>::iterator it, end;
end = _ind.end();
NodePtr scene;
if(_ind.size() == 1)
{
scene = makeNodeFor(createGeo(_ind.begin()->first));
}
else
{
scene = makeNodeFor(Group::create());
beginEditCP(scene);
for(it = _ind.begin(); it != end; ++it)
{
scene->addChild(makeNodeFor(createGeo(it->first)));
}
endEditCP(scene);
}
return scene;
}
NodePtr makeScene()
{
g_fb_chunk = FatBorderChunk::create();
beginEditCP(g_fb_chunk);
g_fb_chunk->activateWithStandardLighting();
g_fb_chunk->setIgnore(true);
endEditCP(g_fb_chunk);
NodePtr root = makeCoredNode<Switch>();
beginEditCP(root);
root->addChild(makeTeapot());
root->addChild(makeTorus());
root->addChild(makeTrimmedCylinder());
endEditCP(root);
return root;
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// GLUT init
int winid = setupGLUT(&argc, argv);
// the connection between GLUT and OpenSG
GLUTWindowPtr gwin= GLUTWindow::create();
gwin->setId(winid);
gwin->init();
// create the scene
NodePtr torus = makeTorus( .5, 2, 16, 32 );
// create the transformation node
// scenegraph nodes are split into 2 parts: the node and its core
// 1. create the Node
NodePtr scene = Node::create();
// 2. create the core
trans = Transform::create();
// 3. associate the core with the node
// OpenSG objects need to be informed when they are being changed,
// that's what beginEditCP() and endEditCP() do
beginEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
{
scene->setCore(trans);
// add the torus as a child
scene->addChild(torus);
}
endEditCP (scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
// create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// tell the manager what to manage
mgr->setWindow(gwin );
mgr->setRoot (scene);
// show the whole scene
mgr->showAll();
// GLUT main loop
glutMainLoop();
return 0;
}
SceneFileHandler::FCPtrStore SceneFileHandler::readTopNodes(
const Char8 *fileName,
GraphOpSeq *graphOpSeq)
{
std::vector<FieldContainerPtr> nodeVec;
if(!fileName)
{
SWARNING << "cannot read NULL file" << std::endl;
return nodeVec;
}
std::string fullFilePath = initPathHandler(fileName);
if(fullFilePath.empty())
{
SWARNING << "Couldn't open file " << fileName << std::endl;
return nodeVec;
}
std::ifstream in(fullFilePath.c_str(), std::ios::binary);
if(in)
{
nodeVec = readTopNodes(in, fullFilePath.c_str(), graphOpSeq);
in.close();
}
else
{
SWARNING << "Couldn't open input stream for file " << fullFilePath << std::endl;
}
// Ok stream interface didn't work try via filename
if(nodeVec.empty())
{
NodePtr scene = read(fullFilePath.c_str());
if(scene == NullFC)
return nodeVec;
while(scene->getNChildren() > 0)
{
NodePtr child = scene->getChild(0);
NodePtr newChild = Node::create();
while(child->getNChildren() > 0)
newChild->addChild(child->getChild(0));
newChild->setCore(child->getCore());
if(graphOpSeq != NULL)
graphOpSeq->run(newChild);
nodeVec.push_back(newChild);
scene->subChild(child);
}
}
return nodeVec;
}
void VRMLLODBinder::addLevel(NodePtr pLevel)
{
NodePtr pNode = NodePtr::dcast(_pFieldContainer);
if(pNode != NullFC && pLevel != NullFC)
{
beginEditCP(pNode, Node::ChildrenFieldMask);
{
pNode->addChild(pLevel);
}
endEditCP (pNode, Node::ChildrenFieldMask);
}
}
FaceSpatialize<BasicTraits>::CategoryRaw::CategoryRaw (NodePtr root,
const FaceIterator& face)
: m_ccw(true),
//m_faceLength(0),
m_hasNormal(hasNormalAttributes(face)),
m_hasColor(hasColorAttributes(face)),
m_hasTex(hasTexAttributes(face))
{
CategoryRaw::begin(face);
beginEditCP(root);
root->addChild(m_node);
endEditCP(root);
}
void VRMLSwitchBinder::addChoice(NodePtr pChoice)
{
NodePtr pNode = NodePtr::dcast(_pFieldContainer);
if(pNode != NullFC && pChoice != NullFC)
{
beginEditCP(pNode, Node::ChildrenFieldMask);
{
pNode->addChild(pChoice);
}
endEditCP (pNode, Node::ChildrenFieldMask);
}
}
void Particles::createSymmetricEmitterLine(Vec3f dir, Real32 dist, UInt16 num)
{
NodePtr localTransNode;
TransformPtr localTrans;
Matrix m;
dir.normalize();
for (int i = 1; i < num; i++)
{
localTransNode = Node::create();
localTrans = Transform::create();
m.setIdentity();
m.setTranslate(dir*(i*dist));
beginEditCP(localTrans, Transform::MatrixFieldMask);
localTrans->setMatrix(m);
endEditCP(localTrans, Transform::MatrixFieldMask);
beginEditCP(localTransNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
localTransNode->setCore(localTrans);
localTransNode->addChild(cloneTree(particleNode));
endEditCP(localTransNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
beginEditCP(particleTransNode, Node::ChildrenFieldMask);
particleTransNode->addChild(localTransNode);
endEditCP(particleTransNode, Node::ChildrenFieldMask);
localTransNode = Node::create();
localTrans = Transform::create();
m.setIdentity();
m.setTranslate(dir*(-i*dist));
beginEditCP(localTrans, Transform::MatrixFieldMask);
localTrans->setMatrix(m);
endEditCP(localTrans, Transform::MatrixFieldMask);
beginEditCP(localTransNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
localTransNode->setCore(localTrans);
localTransNode->addChild(cloneTree(particleNode));
endEditCP(localTransNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
beginEditCP(particleTransNode, Node::ChildrenFieldMask);
particleTransNode->addChild(localTransNode);
endEditCP(particleTransNode, Node::ChildrenFieldMask);
} // for
} // createSymmetricEmitterLine
NodePtr createScenegraph(){
SimpleMaterialPtr simpleMaterial = SimpleMaterial::create();
beginEditCP (simpleMaterial, SimpleMaterial::DiffuseFieldMask |
SimpleMaterial::AmbientFieldMask |
SimpleMaterial::TransparencyFieldMask);
simpleMaterial->setDiffuse(Color3f(1,0,0));
simpleMaterial->setAmbient(Color3f(0.2, 0.2, 0.2));
simpleMaterial->setTransparency(0.5);
endEditCP (simpleMaterial, SimpleMaterial::DiffuseFieldMask |
SimpleMaterial::AmbientFieldMask |
SimpleMaterial::TransparencyFieldMask);
NodePtr simpleMaterialNode = Node::create();
NodePtr sphere = makeSphere(2,6);
MaterialGroupPtr mg = MaterialGroup::create();
beginEditCP(mg);
mg->setMaterial(simpleMaterial);
endEditCP(mg);
beginEditCP(simpleMaterialNode);
simpleMaterialNode->setCore(mg);
simpleMaterialNode->addChild(sphere);
endEditCP(simpleMaterialNode);
NodePtr root = Node::create();
beginEditCP(root);
root->setCore(Group::create());
root->addChild(simpleMaterialNode);
endEditCP(root);
return root;
}
virtual void actionPerformed(const ActionEventPtr e)
{
TutorialSound->stop(TutorialSoundChannelID);
std::cout << "Stop Action" << std::endl;
NodePtr s = makeTorus(.5, 2, 16, 16);
beginEditCP(scene, Node::ChildrenFieldMask);
while(scene->getNChildren() > 0)
{
scene->subChild(scene->getNChildren()-1);
}
scene->addChild(s);
endEditCP(scene, Node::ChildrenFieldMask);
segUpdate = 0;
}
bool SplitGraphOp::traverse(NodePtr& root)
{
// If the root node is not a Group, make it one
if (isLeaf(root))
{
NodePtr n = makeNodeFor(root->getCore());
beginEditCP(root);
root->setCore(Group::create());
root->addChild(n);
endEditCP(root);
}
return GraphOp::traverse(root);
}
virtual void segmentActivated(const CaptionEventPtr e)
{
if(segUpdate == 6)
{
NodePtr s = makeSphere(1,2);
beginEditCP(scene, Node::ChildrenFieldMask);
while(scene->getNChildren() > 0)
{
scene->subChild(scene->getNChildren()-1);
}
scene->addChild(s);
endEditCP(scene, Node::ChildrenFieldMask);
}
if(segUpdate == 9)
{
NodePtr s = makeBox(3,3,3,2,2,2);
beginEditCP(scene, Node::ChildrenFieldMask);
while(scene->getNChildren() > 0)
{
scene->subChild(scene->getNChildren()-1);
}
scene->addChild(s);
endEditCP(scene, Node::ChildrenFieldMask);
}
if(segUpdate == 11)
{
beginEditCP(scene, Node::ChildrenFieldMask);
while(scene->getNChildren() > 0)
{
scene->subChild(scene->getNChildren()-1);
}
endEditCP(scene, Node::ChildrenFieldMask);
}
++segUpdate;
std::cout<<"Segment Activated"<<std::endl;
}
FaceSpatializeIndexed<BasicTraits>::CategoryRaw::CategoryRaw (NodePtr root,
OpenSGFaceBase<OpenSGTraits>* node, const FaceIterator& face)
: m_hasNormal(hasNormalAttributes(face)),
m_hasColor(hasColorAttributes(face)),
m_hasTex(hasTexAttributes(face)),
m_original(node->getObjectAdapter().getNode())
{
// create object adapter
m_original.setObjectAdapter(&node->getObjectAdapter());
CategoryRaw::begin(node, face);
beginEditCP(root);
root->addChild(m_node);
endEditCP(root);
}
NodePtr createNode(const DocumentPtr& owner_doc) {
NodePtr node;
if(name_ == XmlText) {
node = Text::create(value_, owner_doc);
} else {
node = Element::create(name_, owner_doc);
}
for(auto& a : attributes_) {
node->addAttribute(a.second->createAttribute());
}
for(auto& c : children_) {
node->addChild(c->createNode(owner_doc));
}
node->init();
return node;
}
NodePtr createScenegraph()
{
scene = Node::create();
setName(scene, "Scene");
/*
model1 = SceneFileHandler::the().read("data/high_res_box.wrl");
if (model1 == NullFC)
{
cout << "Unable to load model1" << endl;
return NullFC;
}
setName(model1, "Highresbox");
model2 = SceneFileHandler::the().read("data/box.wrl");
if (model2 == NullFC)
{
cout << "Unable to load model2" << endl;
return NullFC;
}
setName(model2, "Box");
*/
#if OSG_MAJOR_VERSION >= 2
model = SceneFileHandler::the()->read("data/char.wrl");
#else
model = SceneFileHandler::the().read("data/chair.wrl");
#endif
if (model == NullFC)
{
cout << "Unable to load model1" << endl;
return NullFC;
}
beginEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
scene->setCore(Group::create());
//scene->addChild(model1);
//scene->addChild(model2);
scene->addChild(model);
endEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
//model = model1;
return scene;
}
OSG_USING_NAMESPACE
#if 1
int main (int argc, char **argv)
{
NodePtr node;
const char *fileName = (argc > 1) ? argv[1] : "tie.wrl";
osgInit(argc, argv);
NodePtr pScene = Node::create();
GroupPtr pSceneGroup = Group::create();
pScene->setCore(pSceneGroup);
node = SceneFileHandler::the().read(fileName);
node->updateVolume();
Vec3f center;
node->getVolume().getCenter(center);
std::cerr << "Volume: center " << center << ", volume "
<< node->getVolume().getScalarVolume() << std::endl;
pScene->addChild(node);
VRMLWriteAction *pWriter = VRMLWriteAction::create();
// pWriter->addOptions(VRMLWriteAction::OSGNoNormals);
//VRMLWriteAction::OSGNoIndent |
pWriter->open((argc > 2) ? argv[2] : "test.wrl");
pWriter->write(pScene);
pWriter->close();
return 0;
}
int main( int argc, char **argv )
{
osgInit(argc,argv);
QApplication::setColorSpec( QApplication::CustomColor );
QApplication a( argc, argv );
if ( !QGLFormat::hasOpenGL() ) {
qWarning( "This system has no OpenGL support. Exiting." );
return -1;
}
OpenSGWidget w(QGLFormat(QGL::DoubleBuffer | QGL::DepthBuffer | QGL::Rgba |
QGL::DirectRendering));
// create the scene
NodePtr scene;
if(argc > 1)
{
scene = Node::create();
GroupPtr g = Group::create();
beginEditCP(scene);
scene->setCore(g);
for(UInt16 i = 1; i < argc; ++i)
scene->addChild(SceneFileHandler::the().read(argv[i]));
endEditCP(scene);
}
else
{
scene = makeTorus(.5, 3, 16, 16);
}
w.getManager()->setRoot(scene);
w.getManager()->showAll();
w.show();
return a.exec();
}
Action::ResultE SplitGraphOp::traverseLeave(NodePtr& node, Action::ResultE res)
{
std::vector<NodePtr>::iterator it = node->editMFChildren()->getValues().begin();
std::vector<NodePtr>::iterator en = node->editMFChildren()->getValues().end ();
std::vector<NodePtr> toAdd;
std::vector<NodePtr> toSub;
for ( ; it != en; ++it )
{
bool special=isInExcludeList(*it);
bool leaf=isLeaf(*it);
if (!special && leaf)
{
if (splitNode(*it, toAdd))
toSub.push_back(*it);
}
}
it = toAdd.begin();
en = toAdd.end ();
for ( ; it != en; ++it )
{
beginEditCP(node, Node::ChildrenFieldMask);
node->addChild(*it);
endEditCP (node, Node::ChildrenFieldMask);
}
it = toSub.begin();
en = toSub.end ();
for ( ; it != en; ++it )
{
beginEditCP(node, Node::ChildrenFieldMask);
addRefCP(*it);
node->subChild(*it);
endEditCP (node, Node::ChildrenFieldMask);
}
return res;
}
static NodePtr makePerturbedAll (UInt16 numSubdiv,
Real32 radius,
Real32 stdDeviation = 0.1f)
{
NodePtr sphereNode = makeSphere(numSubdiv, radius);
GeometryPtr sphere = GeometryPtr::dcast(sphereNode->getCore());
GeoPositionsPtr points = sphere->getPositions();
beginEditCP(points);
for (UInt32 i=0; i<points->size(); ++i) {
Real32 factor = 1.0f + stdDeviation * (rand()/Real32(RAND_MAX) - 0.5f);
points->setValue(factor*points->getValue(i), i);
}
endEditCP(points);
NodePtr node = Node::create();
beginEditCP(node);
node->setCore(Transform::create());
node->addChild(sphereNode);
endEditCP(node);
return node;
}
SceneFileHandler::FCPtrStore SceneFileHandler::readTopNodes(
std::istream &is, const Char8 *fileNameOrExtension,
GraphOpSeq *graphOpSeq)
{
std::vector<FieldContainerPtr> nodeVec;
NodePtr scene = read(is, fileNameOrExtension);
if(scene == NullFC)
return nodeVec;
while(scene->getNChildren() > 0)
{
NodePtr child = scene->getChild(0);
NodePtr newChild = Node::create();
while(child->getNChildren() > 0)
newChild->addChild(child->getChild(0));
newChild->setCore(child->getCore());
if(graphOpSeq != NULL)
graphOpSeq->run(newChild);
nodeVec.push_back(newChild);
scene->subChild(child);
}
return nodeVec;
}
