//method that will be called when entering //a new node osg::Action::ResultE enter(osg::NodePtr& node) { if (node->getCore()->getType().isDerivedFrom(OSG::CharacterBase::getClassType())) { osg::CharacterPtr charac = osg::CharacterPtr::dcast(node->getCore()); std::string name; if (getName(node)) { name = getName(node); } else { osg::CharacterModelPtr model = charac->getModel(); name = model->getConfigFile(); std::cout << "character model file " << name << std::endl; std::string::size_type slashpos = name.size()-1; slashpos = name.find_last_of("/"); if(slashpos != name.npos) name = name.substr(slashpos+1); slashpos = name.size()-1; slashpos = name.find_last_of("\\"); if(slashpos != name.npos) name = name.substr(slashpos+1); std::string::size_type dotpos = 0; dotpos = name.find_last_of("."); if(dotpos != name.npos) name = name.substr(0, dotpos); } std::cout << name << " is a character" << std::endl; return process(node, charac, name); } return osg::Action::Continue; }
int main(int argc, char **argv) { OSG::NodePtr pRoot; int i = 0; OSG::osgInit(i, NULL); OSG::Node::create(); if((argc > 2) && (OSG::stringcmp(argv[2], "pushNames") == 0)) { OSG::SceneFileHandler::the().setOptions("wrl", "pushNames=true"); } pRoot = OSG::SceneFileHandler::the().read(argv[1]); std::cerr << "Tree : " << std::endl; if(pRoot == OSG::NullFC) { std::cerr << "\t Empty" << std::endl; } else { pRoot->dump(); } // char *szFilename = "stirnwand.wrl"; OSG::osgExit(); return 0; }
OSG::NodePtr makePolygon(double pntData[][3], int numPoints) { OSG::GeometryPtr geoPtr = OSG::Geometry::create(); OSG::NodePtr nodePtr = OSG::Node::create(); GeoPositions3fPtr pnts = GeoPositions3f::create(); GeoNormals3fPtr norms = GeoNormals3f::create(); GeoTexCoords2fPtr tex = GeoTexCoords2f::create(); GeoIndicesUI32Ptr indices = GeoIndicesUI32::create(); GeoPLengthsUI32Ptr lens = GeoPLengthsUI32::create(); GeoPTypesUI8Ptr types = GeoPTypesUI8::create(); //Set up the properties according to the geometry defined above beginEditCP(pnts); beginEditCP(norms); for(int i = 0; i < numPoints; i++) { pnts->push_back(Pnt3f(pntData[i][0], pntData[i][1], pntData[i][2])); indices->push_back(2*i); norms->push_back(Vec3f(0.0, 0.0, pntData[i][2])); indices->push_back(2*i + 1); } endEditCP(pnts); endEditCP(norms); beginEditCP(types); beginEditCP(lens); types->push_back(GL_POLYGON); lens->push_back(numPoints); endEditCP(types); endEditCP(lens); beginEditCP(geoPtr); geoPtr->setMaterial(getDefaultMaterial()); geoPtr->setPositions(pnts); geoPtr->setNormals(norms); geoPtr->setIndices(indices); geoPtr->editMFIndexMapping()->push_back(Geometry::MapPosition | Geometry::MapNormal); geoPtr->setTypes(types); geoPtr->setLengths(lens); endEditCP(geoPtr); nodePtr->setCore(geoPtr); return nodePtr; }
void testObj::setActive( osg::NodePtr parent, bool active ) { if ( _isActive && ! active ) { osg::addRefCP( node ); parent->subChild( node ); } else if ( ! _isActive && active ) parent->addChild( node ); _isActive = active; }
void testNode(void) { #if 0 OSG::SFNodePtr sfNode; OSG::MFNodePtr mfNode; OSG::NodePtr pNode = OSG::Node::create(); sfNode.setValue(pNode); mfNode.push_back(pNode); /* fprintf(stderr, "%p %p %p | %d %d\n", pNode, sfNode.getValue(), mfNode[0], OSG::Node::VolumeFieldId, OSG::Node::TravMaskFieldId); */ OSG::NodePtr pNode1 = OSG::Node::create(); sfNode.setValue(pNode1); mfNode.resize(2); mfNode.replace(1, pNode1); const OSG::Field *pF1 = pNode->getSFVolume(); OSG::Field *pF2 = pNode->editSFVolume(); OSG::GetFieldHandlePtr pRF1 = pNode->getField("volume"); OSG::EditFieldHandlePtr pRF2 = pNode->editField("volume"); fprintf(stderr, "#### Field %p %p | %p %p\n", pF1, pF2, pRF1.get(), pRF2.get()); // fprintf(stderr, "%p %p %p\n", pNode1, sfNode.getValue(), mfNode[1]); const OSG::SFNodePtr constSFNode; // fprintf(stderr, "%p %p\n", pNode1, constSFNode.getValue()); OSG::FieldContainerPtr pNodeClone = deepClone(pNode); OSG::FieldContainerPtr pFC = OSG::FieldContainerFactory::the()->createContainer("Billboard"); fprintf(stderr, "### FOO %p\n", getCPtr(pFC)); #endif }
void addWithHull( osg::NodePtr testObj ) { testGeom = osg::GeometryPtr::dcast( testObj->getCore() ); testHull = testGeom; testHullObj = testHull.getGeomNode(); testHull.print(); // set material osg::SimpleMaterialPtr mat = osg::SimpleMaterial::create(); mat->setDiffuse( osg::Color3f( 1.0,0.7,1.0 ) ); mat->setAmbient( osg::Color3f( 0.2,0.2,0.2 ) ); mat->setSpecular( osg::Color3f( 1,1,1 ) ); mat->setShininess( 20 ); testGeom->setMaterial( mat ); osg::GeometryPtr::dcast(testHullObj->getCore())->setMaterial( mat ); // add to scene graph beginEditCP(root); root->addChild( testObj ); root->addChild( testHullObj ); endEditCP(root); }
Transform::Transform(OSG::NodePtr node) : Group(node) { _transform = OSG::cast_dynamic<OSG::TransformPtr>(node->getCore()); // OSG::beginEditCP(_node); _node->setCore(_transform); // OSG::endEditCP(_node); }
Group::Group(OSG::NodePtr node) : NodeBase(node) { _group = OSG::cast_dynamic<OSG::GroupPtr>(node->getCore()); // OSG::beginEditCP(_node); _node->setCore(_group); // OSG::endEditCP(_node); }
Geometry::Geometry(OSG::NodePtr node) : NodeBase(node) { _geometry = OSG::cast_dynamic<OSG::GeometryPtr>(node->getCore()); // OSG::beginEditCP(_node); _node->setCore(_geometry); // OSG::endEditCP(_node); }
NodeBase NodeIterator::next(void) { while(!_stack.empty()) { OSG::NodePtr act = _stack.back(); _stack.pop_back(); for(OSG::UInt32 i = 0; i < act->getNChildren(); ++i) _stack.push_back(act->getChild(i)); if(act->getCore()->getType().isDerivedFrom(*_type)) { return NodeBase(act); } } PyErr_SetString(PyExc_StopIteration, "Out of Nodes"); boost::python::throw_error_already_set(); }
osg::Action::ResultE enter(osg::NodePtr& node) { //if (osg::getName(node)) if (node->getCore()->getType().isDerivedFrom(OSG::CharacterBase::getClassType())) { std::cout << osg::getName(node) << "is a character" << std::endl; } //else //{ // std::cout << osg::getName(node) << "is not a character" << std::endl; //} return osg::Action::Continue; }
void InventorLoader::checkForRedundancy( osg::NodePtr OSGGroup ) { return; // TODO: Check the type of the node and return, if it's not a node // that should be discarded (discardable: group, not discardable: geometry) // If the group node has no children, then let's kick it ! if( OSGGroup->getNChildren() == 0 ) { if(OSGGroup->getParent() != NullFC) { OSGGroup->getParent()->subChild(OSGGroup); } else { subRefCP(OSGGroup); } } // If there's only one child, then add it to the parent of the group, // copy the name and remove the group else if ( OSGGroup->getNChildren() == 1 ) { // Get parent and child osg::NodePtr _Child = OSGGroup->getChild(0); osg::NodePtr _Parent = OSGGroup->getParent(); // Copy the name const char* _Name = getName(OSGGroup); if( _Name ) setName( _Child, _Name ); // Add the child to the parent _Parent->addChild( _Child ); // Remove the group node _Parent->subChild( OSGGroup ); } }
NodePtr createScoreBoards() { GeometryPtr geo; NodePtr bg; SimpleMaterialPtr m; ScoreBoard1 = new TextStuff() ; ScoreBoard2 = new TextStuff() ; // First get the global group node OSG::NodePtr scoreBoardsNodePtr = OSG::Node::create(); scoreBoardsNodePtr->setCore(OSG::Group::create()); // Setup text 1 ScoreBoard1->initialize(); ScoreBoard1->updateFace(); ScoreBoard1->updateScore(0,0); // Setup text 2 ScoreBoard2->initialize(); ScoreBoard2->updateFace(); ScoreBoard2->updateScore(0,0); ////////// 1 ///////// // make its transform TransformPtr trans1; NodePtr trans_node1 = makeCoredNode<Transform>(&trans1); beginEditCP(trans1); trans1->getMatrix().setTransform(Vec3f(0,4,-10.5),Quaternion( Vec3f(0,1,0),deg2rad(0))); endEditCP(trans1); // make geometry bg = makePlane(9.3, 1, 8,2); m= SimpleMaterial::create(); beginEditCP(m); { m->setAmbient (Color3f(0,0,0)); m->setDiffuse (Color3f(0.0,0.0,0.0)); } endEditCP (m); geo = GeometryPtr::dcast(bg->getCore()); beginEditCP(geo); geo->setMaterial(m); beginEditCP(geo); beginEditCP(bg); bg->addChild(ScoreBoard1->mRootNode); endEditCP(bg); beginEditCP(trans_node1); trans_node1->addChild(bg); endEditCP(trans_node1); ////////// 2 ///////// // make its transform TransformPtr trans2; NodePtr trans_node2 = makeCoredNode<Transform>(&trans2); beginEditCP(trans2); trans2->getMatrix().setTransform(Vec3f(0,4,10.5),Quaternion( Vec3f(0,1,0),deg2rad(180))); endEditCP(trans2); // make geometry bg = makePlane(9.3, 1, 8,2); m = SimpleMaterial::create(); beginEditCP(m); { m->setAmbient (Color3f(0,0,0)); m->setDiffuse (Color3f(0.0,0.0,0.0)); } endEditCP (m); geo = GeometryPtr::dcast(bg->getCore()); beginEditCP(geo); geo->setMaterial(m); beginEditCP(geo); beginEditCP(bg); bg->addChild(ScoreBoard2->mRootNode); endEditCP(bg); beginEditCP(trans_node2); trans_node2->addChild(bg); endEditCP(trans_node2); beginEditCP(scoreBoardsNodePtr); scoreBoardsNodePtr->addChild(trans_node1); scoreBoardsNodePtr->addChild(trans_node2); endEditCP(scoreBoardsNodePtr); return scoreBoardsNodePtr; }
int main(int argc, char *argv[]) {/* int j = 0; // Allocate Sotrage std::vector<std::vector<cv::Point3f> > object_points; std::vector<std::vector<cv::Point2f> > image_points; int numBoards = 20; int numCornersHor = 9; int numCornersVer = 6; int numSquares = numCornersHor * numCornersVer; cv::Size board_sz = cv::Size(numCornersVer, numCornersHor); vector<cv::Point2f> corners; int successes=0; cv::Mat init_Image; vector<cv::Point3f> obj; for(int y(0); y < numCornersHor; ++y) { double tmp (y * 60.0); for(int x(0); x < numCornersVer; ++x){ obj.push_back(cv::Point3f(x * 60.0, tmp, 0)); cout << "::" << x * 60.0 << " - " << tmp << endl; } } //cv::VideoCapture capture = cv::VideoCapture(0); //while(successes < numBoards){ for(int i = 1 ; i< 518 ; i++){ // every 10 pictures if(j != 1){ j++; continue; } else { j=0; } stringstream stream; stream << "pics/init/"; stream << i; stream << ".bmp"; cout << "#### PICTURE NO. "<<i<<"####" << stream.str().c_str() <<endl; init_Image = cvLoadImage(stream.str().c_str()); cv::Mat grayImage; //capture >> init_Image; cv::cvtColor(init_Image, grayImage, CV_BGR2GRAY); bool found = cv::findChessboardCorners(grayImage, board_sz, corners, cv::CALIB_CB_ADAPTIVE_THRESH + cv::CALIB_CB_NORMALIZE_IMAGE); if(found) { cv::cornerSubPix(grayImage, corners, cv::Size(11, 11), cv::Size(-1, -1), cv::TermCriteria(CV_TERMCRIT_EPS | CV_TERMCRIT_ITER, 30, 0.1)); cv::drawChessboardCorners(grayImage, board_sz, corners, found); image_points.push_back(corners); object_points.push_back(obj); cout << "Snap stored!" << endl; successes++; if(successes>=numBoards) break; } cv::imshow("Calib1",init_Image); cv::imshow("Calib2",grayImage); int key = cv::waitKey(1); } cout << "image point size : " << image_points.size() << endl; cout << "object point size : " << object_points.size() << endl; cv::Mat distCoeffs; vector<cv::Mat> rvecs; vector<cv::Mat> tvecs; cv::Mat intrinsic; cv::calibrateCamera(object_points, image_points, init_Image.size(), intrinsic, distCoeffs, rvecs, tvecs); cout << "##INTRINSIC##" <<endl; cout << intrinsic.ptr<double>(0)[0] << " " <<intrinsic.ptr<double>(0)[1]<<" " <<intrinsic.ptr<double>(0)[2]<< endl; cout << intrinsic.ptr<double>(1)[0] << " " <<intrinsic.ptr<double>(1)[1]<< " " <<intrinsic.ptr<double>(1)[2] << endl; cout << intrinsic.ptr<double>(2)[0] << " " <<intrinsic.ptr<double>(2)[1]<< " " <<intrinsic.ptr<double>(2)[2] << endl; cout << "##DISTORTION##" <<endl; cout << distCoeffs.ptr<double>(0)[0] << " " << distCoeffs.ptr<double>(0)[1] << " " << distCoeffs.ptr<double>(0)[2] << " " << distCoeffs.ptr<double>(0)[3] << " " << distCoeffs.ptr<double>(0)[4] << " " << distCoeffs.ptr<double>(0)[5] << " " <<endl; for(int i = 1 ; i< 300 ; i++){ stringstream stream,s2; stream << "pics/"; stream << i; stream << ".bmp"; cout << "#### PICTURE NO. "<<i<<"####" << stream.str().c_str() <<endl; cv:: Mat image = cvLoadImage(stream.str().c_str()); cv::Mat newI; cv::undistort(image,newI,intrinsic,distCoeffs); s2 << "pics/undist/"; s2 << i; s2 << ".bmp"; cv::imwrite(s2.str().c_str(),newI); } exit(0);*/ // AR _BEGIN_ /* const char *cparam_name = "pics/camera_para.dat"; ARParam cparam; ARParam wparam; // opencv-test char *patt_name = "davit.patt"; std::cout << QDir::currentPath().toStdString() << endl; cv::Mat m,n; cv::namedWindow("looky looky"); ARUint8 *dataPtr; int patt_id; if( (patt_id=arLoadPatt(patt_name)) < 0 ) { cout << "Pattern load error" <<endl; } else { cout << "Pattern loaded... "<<endl; } // set the initial camera parameters if( arParamLoad(cparam_name, 1, &wparam) < 0 ) { cout << "Camera parameter load error !!"<<endl; exit(0); } else { cout << "Loaded Camera Parameter !! "<<endl; } //wparam.xsize = 1280; //wparam.ysize = 1024; //wparam.mat[0][0] = 1598.0; //wparam.mat[1][1] = 1596.15; //wparam.mat[0][2] = 555.006; //wparam.mat[1][2] = 525.028; //wparam.dist_factor[0] = -0.477959; //wparam.dist_factor[1] = 1.83017; //wparam.dist_factor[2] = -0.0036001; //wparam.dist_factor[3] = -0.0001997; //cout <<"RESET..."<<endl; arParamChangeSize( &wparam, 1280, 1024, &cparam ); arInitCparam( &cparam ); cout << "*** Camera Parameter ***"<<endl; arParamDisp( &cparam ); //open file fstream file; file.open("1280x1024Data.dat",ios::out); cv::Mat RGB; int v = 0; for(int u=1;u<=200;++u){ file<<"#FRAME_"<<u<<endl; //cout << "in loop..."<<endl; stringstream stream; stream << "pics/undist/"; stream << u; stream << ".bmp"; RGB = cv::imread(stream.str().c_str()); cv::flip(RGB,RGB,0); cv::Mat matAR(RGB.rows,RGB.cols,CV_8UC4); cv::cvtColor(RGB,matAR,CV_BGR2BGRA); cv::Mat newAR(RGB.rows,RGB.cols,CV_8UC4); cv::Mat in[] = {matAR}; cv::Mat out[] = {newAR}; int from[] = {3,0,0,3,1,2,2,1}; cv::mixChannels(in,1,out,1,from,4); dataPtr = (ARUint8*)newAR.data; ARMarkerInfo *marker_info; int marker_num; if( dataPtr == NULL ) { arUtilSleep(2); cout << "No Image data found..."; return 2; } cout << "try detecting... " << u <<endl; if( arDetectMarker(dataPtr, 45, &marker_info, &marker_num) < 0 ) { cout << "No Markers found... :("; //cleanup(); //exit(0); return 4; } int j,k; k = -1; for( j = 0; j < marker_num; j++ ) { if( patt_id == marker_info[j].id ) { if( k == -1 ) k = j; else if( marker_info[k].cf < marker_info[j].cf ) k = j; } } //cout << "k: " << k << endl; double patt_width = 225.0; double patt_center[2] = {0.0,0.0}; double patt_trans[3][4]; double quat[4]; double pos[3]; if(marker_num > 0 && k == 0){ //cout << "Marker found : " << marker_num << " " << v++ << " - k: " << k <<endl; arGetTransMat(&marker_info[k],patt_center,patt_width,patt_trans); if(arUtilMat2QuatPos(patt_trans,quat,pos) == 0){ cout << "quat worked" <<endl; cout << "quat: " << quat[0] << " " << quat[1] << " " << quat[2] << " " << quat[3] << endl; cout << "pos: " << pos[0] << " " << pos[1] << " " << pos[2] << endl; cout <<endl; } file << patt_trans[0][0] << " " << patt_trans[0][1] << " " << patt_trans[0][2] << " " << patt_trans[0][3] << " "<<endl; file << patt_trans[1][0] << " " << patt_trans[1][1] << " " << patt_trans[1][2] << " " << patt_trans[1][3] << " "<<endl; file << patt_trans[2][0] << " " << patt_trans[2][1] << " " << patt_trans[2][2] << " " << patt_trans[2][3] << " "<<endl; //file << patt_center[0] << " " << patt_center[1] <<endl; //cout << "patt width: " << patt_width <<endl; file << marker_info[k].pos[0] << " " << marker_info[k].pos[1] <<endl; cout << "p1: " << marker_info[k].vertex[0][0] << " " << marker_info[k].vertex[0][1]<< endl; cout << "p2: " << marker_info[k].vertex[1][0] << " " << marker_info[k].vertex[1][1]<< endl; cout << "p3: " << marker_info[k].vertex[2][0] << " " << marker_info[k].vertex[2][1]<< endl; cout << "p4: " << marker_info[k].vertex[3][0] << " " << marker_info[k].vertex[3][1]<< endl; cv::line(newAR,cv::Point(marker_info[k].vertex[0][0],marker_info[k].vertex[0][1]),cv::Point(marker_info[k].vertex[1][0],marker_info[k].vertex[1][1]),CV_RGB(255,0,0)); cv::line(newAR,cv::Point(marker_info[k].vertex[1][0],marker_info[k].vertex[1][1]),cv::Point(marker_info[k].vertex[2][0],marker_info[k].vertex[2][1]),CV_RGB(255,0,0)); cv::line(newAR,cv::Point(marker_info[k].vertex[2][0],marker_info[k].vertex[2][1]),cv::Point(marker_info[k].vertex[3][0],marker_info[k].vertex[3][1]),CV_RGB(255,0,0)); cv::line(newAR,cv::Point(marker_info[k].vertex[3][0],marker_info[k].vertex[3][1]),cv::Point(marker_info[k].vertex[0][0],marker_info[k].vertex[0][1]),CV_RGB(255,0,0)); cv::line(newAR,cv::Point(marker_info[k].vertex[0][0],marker_info[k].vertex[0][1]),cv::Point(marker_info[k].vertex[2][0],marker_info[k].vertex[2][1]),CV_RGB(255,0,0)); cv::line(newAR,cv::Point(marker_info[k].vertex[1][0],marker_info[k].vertex[1][1]),cv::Point(marker_info[k].vertex[3][0],marker_info[k].vertex[3][1]),CV_RGB(255,0,0)); cv::line(RGB,cv::Point(marker_info[k].vertex[0][0],marker_info[k].vertex[0][1]),cv::Point(marker_info[k].vertex[1][0],marker_info[k].vertex[1][1]),CV_RGB(255,0,0)); cv::line(RGB,cv::Point(marker_info[k].vertex[1][0],marker_info[k].vertex[1][1]),cv::Point(marker_info[k].vertex[2][0],marker_info[k].vertex[2][1]),CV_RGB(255,0,0)); cv::line(RGB,cv::Point(marker_info[k].vertex[2][0],marker_info[k].vertex[2][1]),cv::Point(marker_info[k].vertex[3][0],marker_info[k].vertex[3][1]),CV_RGB(255,0,0)); cv::line(RGB,cv::Point(marker_info[k].vertex[3][0],marker_info[k].vertex[3][1]),cv::Point(marker_info[k].vertex[0][0],marker_info[k].vertex[0][1]),CV_RGB(255,0,0)); cv::line(RGB,cv::Point(marker_info[k].vertex[0][0],marker_info[k].vertex[0][1]),cv::Point(marker_info[k].vertex[2][0],marker_info[k].vertex[2][1]),CV_RGB(255,0,0)); cv::line(RGB,cv::Point(marker_info[k].vertex[1][0],marker_info[k].vertex[1][1]),cv::Point(marker_info[k].vertex[3][0],marker_info[k].vertex[3][1]),CV_RGB(255,0,0)); cv::waitKey(1); } stringstream stream2; stream2 << "pics/new/"; stream2 << u; stream2 << ".bmp"; //cv::imwrite(stream2.str().c_str(),RGB); file<< "##"<<endl; cv::imshow("looky looky",RGB); cv::waitKey(1); } file.close(); */ // AR _ENDE_ !! //} // QCoreApplication a(argc, argv); OSG::osgInit(argc,argv); cout << "argc " << argc <<endl; for(int ar(0);ar<argc;++ar) cout << argv[ar] << " "; cout << endl; int winid = setupGLUT(&argc,argv); //GLUTWindowPtr gwin = GLUTWindow::create(); //gwin->setGlutId(winid); //gwin->init(); OSG::NodePtr scene = SceneFileHandler::the().read("data/test__1.obj"); //OSG::NodePtr scene = SceneFileHandler::the().read("data/test3_4.obj"); //GroupPtr scene = GroupPtr::dcast(scene); cout << "type: " << scene.getCore()->getTypeName()<< endl; cout << "children in scene: " << scene->getNChildren()<<endl; GeometryPtr geo = GeometryPtr::dcast(scene->getCore()); GeoPTypesPtr type = GeoPTypesUI8::create(); type->addValue(GL_LINE); LineIterator lit; int lines(0); TEST = geo; for(lit = geo->beginLines();lit != geo->endLines();++lit){ lines++; } cout << "lines: " << lines <<endl; SimpleMaterialPtr mat = SimpleMaterial::create(); geo->setMaterial(mat); // Create and setup our little friend - the SSM mgr = new SimpleSceneManager; //mgr->setWindow(gwin); //mgr->setRoot(scene); //mgr->showAll(); //glutCreateWindow("test"); glutMainLoop(); return 0; }
osg::NodePtr InventorLoader::traverseGraph( SoNode* OIVNode, osg::NodePtr OSGNode ) { //////////////////////////////////////////////////////////////////////////// FDEBUG((" InventorLoader::traverseGraph( %x )\n", OIVNode)); //////////////////////////////////////////////////////////////////////////// ///////////////// // Material node ///////////////// if( OIVNode->isOfType( SoMaterial::getClassTypeId() ) ) { // Convert current material osg::SimpleMaterialPtr _Material; _Material = convertMaterial( ( SoMaterial* ) OIVNode ); if( mMergeMaterial ) { // Check if that material was already encountered TMaterialSet::iterator _Iter; for(_Iter = mMaterialSet.begin(); _Iter != mMaterialSet.end(); ++_Iter ) { if( compareMaterial( *_Iter, _Material, mMergeTolerance ) ) break; } if( _Iter != mMaterialSet.end() ) { mCurrentState.Material = *_Iter; // Delete the converted material from above as it isn't used. subRefCP( _Material ); } else { mMaterialSet.insert( _Material ); mCurrentState.Material = _Material; } } else { mCurrentState.Material = _Material; } // Return the old OSG node as the current OSG node return OSGNode; } /////////////////// // Coordinate node /////////////////// if( OIVNode->isOfType( SoCoordinate3::getClassTypeId() ) ) { // Save current coordinates mCurrentState.Positions = convertCoordinates((SoCoordinate3*)OIVNode); // Return the old OSG node as the current OSG node return OSGNode; } ////////////////////// // Normalbinding node ////////////////////// if( OIVNode->isOfType( SoNormalBinding::getClassTypeId() ) ) { // Save current normalbinding SoNormalBinding* _Binding = ( SoNormalBinding* ) OIVNode; mCurrentState.NormalBinding = _Binding->value.getValue(); // Return the old OSG node as the current OSG node return OSGNode; } /////////////// // Normal node /////////////// if( OIVNode->isOfType( SoNormal::getClassTypeId() ) ) { // Save current normals mCurrentState.Normals = convertNormals( ( SoNormal* ) OIVNode ); // Return the old OSG node as the current OSG node return OSGNode; } /////////////////////// // Transformation node /////////////////////// if( OIVNode->isOfType( SoTransform::getClassTypeId() ) ) { osg::NodePtr _OSGTransform = convertTransformation( OIVNode ); // Add the transformation to the current OSG node beginEditCP ( OSGNode, Node::ChildrenFieldMask ); { OSGNode->addChild( _OSGTransform ); } endEditCP ( OSGNode, Node::ChildrenFieldMask ); // Return the new transform node as the current OSG node return _OSGTransform; } /////////////////////// // MatrixTransformation node /////////////////////// if( OIVNode->isOfType( SoMatrixTransform::getClassTypeId() ) ) { osg::NodePtr _OSGTransform = convertMatrixTransformation( OIVNode ); // Add the transformation to the current OSG node beginEditCP ( OSGNode, Node::ChildrenFieldMask ); { OSGNode->addChild( _OSGTransform ); } endEditCP ( OSGNode, Node::ChildrenFieldMask ); // Return the new transform node as the current OSG node return _OSGTransform; } //////////////////// // Indexed face set //////////////////// if( OIVNode->isOfType( SoIndexedFaceSet::getClassTypeId() ) ) { osg::NodePtr _OSGGeometry = convertIFSGeometry( OIVNode ); // Add the geometry to the current OSG node beginEditCP ( OSGNode, Node::ChildrenFieldMask ); { OSGNode->addChild( _OSGGeometry ); } endEditCP ( OSGNode, Node::ChildrenFieldMask ); // Return the old OSG node as the current OSG node return OSGNode; } //////////////////// // Face set //////////////////// if( OIVNode->isOfType( SoFaceSet::getClassTypeId() ) ) { osg::NodePtr _OSGGeometry = convertFSGeometry( OIVNode ); // Add the geometry to the current OSG node beginEditCP ( OSGNode, Node::ChildrenFieldMask ); { OSGNode->addChild( _OSGGeometry ); } endEditCP ( OSGNode, Node::ChildrenFieldMask ); // Return the old OSG node as the current OSG node return OSGNode; } ////////////////// // Separator node ////////////////// if( OIVNode->isOfType( SoSeparator::getClassTypeId() ) ) { SoGroup* _OIVGroup = ( SoGroup* ) OIVNode; osg::NodePtr _OSGGroup = getGroupNode( OIVNode ); osg::NodePtr _CurrentNode = _OSGGroup; // Add the group to the current OSG node beginEditCP ( OSGNode, Node::ChildrenFieldMask ); { OSGNode->addChild( _OSGGroup ); } endEditCP ( OSGNode, Node::ChildrenFieldMask ); // Save the current state TState _TmpState = mCurrentState; // Traverse children for( int i=0; i < _OIVGroup->getNumChildren(); ++i ) { SoNode* _OIVChild = _OIVGroup->getChild( i ); _CurrentNode = traverseGraph( _OIVChild, _CurrentNode ); } // Restore the state mCurrentState = _TmpState; // Check if the new group node has only one child // --> then it's redundant and can be discarded checkForRedundancy( _OSGGroup ); // Return the old OSG node as the current OSG node return OSGNode; } ////////////// // Group node ////////////// else if( OIVNode->isOfType( SoGroup::getClassTypeId() ) ) { osg::NodePtr _CurrentNode = OSGNode; SoGroup* _OIVGroup = ( SoGroup* ) OIVNode; // Traverse children for( int i=0; i < _OIVGroup->getNumChildren(); ++i ) { SoNode* _OIVChild = _OIVGroup->getChild( i ); _CurrentNode = traverseGraph( _OIVChild, _CurrentNode ); } // Return the end of the group as current OSG node return _CurrentNode; } FWARNING (( "Unhandled Inventor node: %s\n", OIVNode->getTypeId().getName().getString() )); return OSGNode; }
void parsecommandline( int argc, char *argv[] ) { /* valid option characters; last char MUST be 0 ! */ char optionchar[] = { 'h', 'g', 'x', 'v', 'n', 'a', 'w', 'd', 'A', 'T', 'f', 'W', 'c', 'r', 'p', 0 }; int musthaveparam[] = { 0 , 1, 1, 1, 2, 1, 0, 2, 1, 0, 1, 0, 0, 1, 0, 0 }; int nopts; int mhp[256]; int isopt[256]; int optchar; nopts = strlen(optionchar); if ( nopts > 50 ) { fprintf(stderr, "\n\nparsecommandline: the option-chars string " "seems to be\nVERY long (%d bytes) !\n\n", nopts ); exit(-1); } fill_n( isopt, 256, 0 ); fill_n( mhp, 256, 0 ); for ( int i = 0; i < nopts; i ++ ) { if ( isopt[static_cast<int>(optionchar[i])] ) { fprintf(stderr, "\n\nparsecommandline: Bug: option character '%c'" " is specified twice in the\n" "option character array !\n\n", optionchar[i] ); exit(-1); } isopt[ static_cast<int>(optionchar[i]) ] = 1; mhp[ static_cast<int>(optionchar[i])] = musthaveparam[i]; } ++argv; --argc; while ( argc > 0 ) { if ( argv[0][0] == '-' ) { optchar = argv[0][1]; if ( ! isopt[optchar] ) { fprintf(stderr, "\nIs not a valid command line option\n"); commandlineerror( argv[0], NULL ); } for ( int i = 0; i < mhp[optchar]; i ++ ) if ( ! argv[1+i] || argv[1+i][0] == '-' ) { fprintf(stderr, "\nCommand line option -%c must " "have %d parameter(s)\n", argv[0][1], mhp[optchar] ); commandlineerror( argv[0], NULL ); argv += 1 + i; argc -= 1 + i; continue; } switch ( optchar ) { case 'h': commandlineerror( NULL, NULL); break; case 'w': With_window = true; break; case 'T': No_timing = true; break; case 'W': White_background = true; break; case 'c': All_collisions = true; break; case 'x': Complexity = atoi( argv[1] ); break; case 'a': Rot_vel = atof( argv[1] ); break; case 'n': Ndistances = atoi( argv[1] ); Nrotations = atoi( argv[2] ); break; case 'd': Dist_1 = atof( argv[1] ); Dist_2 = atof( argv[2] ); break; case 'v': for ( unsigned int i = 0; i < strlen(argv[1]); i ++ ) switch ( argv[1][i] ) { case 'v': col_verbose = true; break; case 'b': verbose |= VERBOSE_PRINT; break; case 'h': col_verboseShowHulls = true; break; default : commandlineerror(argv[0],argv[1]); } break; case 'g': if ( ! strcmp(argv[1],"pl") ) geom_type = OBJ_PLANES; else if ( ! strcmp(argv[1],"sh") ) geom_type = OBJ_SPHERES; else if ( ! strcmp(argv[1],"to") ) geom_type = OBJ_TORUS; else if ( ! strcmp(argv[1],"file") ) geom_type = OBJ_FILE; // just a dummy else { fputs("unrecognized obj type\n",stderr); commandlineerror(argv[0],argv[1]); } break; case 'A': if ( ! strcmp(argv[1],"do") ) Algorithm = col::ALGO_DOPTREE; else if ( ! strcmp(argv[1],"bx") ) Algorithm = col::ALGO_BOXTREE; else { fputs("unrecognized algorithm\n",stderr); commandlineerror(argv[0],argv[1]); } break; case 'f': loadGeom( argv[1], &fixed_node ); moving_node = fixed_node->clone(); fixed_geom = col::getGeom( fixed_node ); moving_geom = col::getGeom( moving_node ); geom_type = OBJ_FILE; // post: moving_geom == fixed_geom break; case 'r': configFile = argv[1]; break; case 'p': print_pairs = true; break; default: fprintf(stderr, "\nBug in parsecommandline !\n"); commandlineerror( argv[0], NULL ); } argv += 1 + mhp[optchar]; argc -= 1 + mhp[optchar]; } else { /* command line arg doesn't start with '-' */ fprintf(stderr, "\nThis is not a valid command line option\n"); commandlineerror( argv[0], NULL ); /* or, load file instead .. */ } } // check sanity of options if ( Complexity < 1 || (geom_type != OBJ_PLANES && Complexity < 3) || Complexity > 1000 ) { fprintf(stderr,"complexity (%u) out of range!\n", Complexity ); exit(-1); } if ( Ndistances > MaxNumDistances ) { fprintf(stderr,"too many (%u) distances!\n", Ndistances ); Ndistances = MaxNumDistances; } if ( Ndistances < 1 ) Ndistances = 1; if ( Rot_vel < col::NearZero ) Rot_vel = 360.0f / Nrotations; Rot_vel *= 2.0 * 3.1415926535 / 360.0; if ( Ndistances > 1 ) // Dist_vel will be used like this: // d = Dist_1 + dist_step * Dist_vel Dist_vel = (Dist_2 - Dist_1) / (Ndistances - 1); else Dist_vel = 0.0; if ( geom_type == OBJ_FILE && (moving_node == osg::NullFC || fixed_node == osg::NullFC) ) { fputs("bench: '-g file' or '-f' option given,\n" " but moving node or fixed node is still NULL!", stderr ); exit(-1); } }
void testRefCount(void) { #if 0 OSG::NodePtr pNode = OSG::Node::create(); OSG::NodePtr pNode1 = OSG::Node::create(); fprintf(stderr, "1\n"); //XX #if 0 pNode.dump(); pNode1.dump(); #endif pNode->addChild(pNode1); fprintf(stderr, "2\n"); //XX #if 0 pNode.dump(); pNode1.dump(); #endif fprintf(stderr, "3\n"); //XX #if 0 pNode.dump(); pNode1.dump(); #endif applyToAspect(1, false); applyToAspect(2); fprintf(stderr, "4\n"); //XX #if 0 pNode.dump(); pNode1.dump(); #endif fprintf(stderr, "5\n"); //XX #if 0 pNode.dump(); pNode1.dump(); #endif applyToAspect(1, false); fprintf(stderr, "6\n"); //XX #if 0 pNode.dump(); pNode1.dump(); #endif applyToAspect(2); fprintf(stderr, "7\n"); #endif }
int main( int argc, char *argv[] ) { // OSG init osg::osgLog().setLogLevel(osg::LOG_WARNING); osg::osgInit(argc, argv); // parse command line options parsecommandline( argc, argv ); // disable display lists osg::FieldContainerPtr pProto= osg::Geometry::getClassType().getPrototype(); osg::GeometryPtr pGeoProto = osg::GeometryPtr::dcast(pProto); if ( pGeoProto != osg::NullFC ) pGeoProto->setDlistCache(false); // create the graph osg::NodePtr node; // root root = osg::Node::create(); beginEditCP(root); root->setCore( osg::Group::create() ); // beacon for camera and light osg::NodePtr beacon; beacon = osg::Node::create(); beginEditCP(beacon); beacon->setCore( osg::Group::create() ); endEditCP(beacon); // light light_node = osg::Node::create(); osg::DirectionalLightPtr light = osg::DirectionalLight::create(); beginEditCP( light_node ); light_node->setCore( light ); root->addChild( light_node ); beginEditCP(light); light->setAmbient( .3, .3, .3, 1 ); light->setDiffuse( 1, 1, 1, 1 ); light->setDirection(0,0,1); light->setBeacon( beacon ); endEditCP(light); // transformation, parent of beacon node = osg::Node::create(); cam_trans = osg::Transform::create(); beginEditCP(node); node->setCore( cam_trans ); node->addChild( beacon ); endEditCP(node); root->addChild( node ); // Camera osg::PerspectiveCameraPtr cam = osg::PerspectiveCamera::create(); cam->setBeacon( beacon ); cam->setFov( 50 ); cam->setNear( 0.1 ); cam->setFar( 10000 ); // Background osg::SolidBackgroundPtr background = osg::SolidBackground::create(); if ( White_background ) { beginEditCP( background ); background->setColor(osg::Color3f(1,1,1)); endEditCP( background ); } // Viewport osg::ViewportPtr vp = osg::Viewport::create(); vp->setCamera( cam ); vp->setBackground( background ); vp->setRoot( root ); vp->setSize( 0,0, 1,1 ); if ( With_window ) { // GLUT init glutInitWindowSize( 400, 400 ); // before glutInit so user can glutInitWindowPosition( 100, 100 ); // override with comannd line args glutInit(&argc, argv); glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE); int winid = glutCreateWindow("Collision Benchmark"); glutKeyboardFunc(key); glutVisibilityFunc(vis); glutReshapeFunc(reshape); glutDisplayFunc(display); glutMouseFunc(mouse); glutMotionFunc(motion); glutIdleFunc(display); glEnable( GL_DEPTH_TEST ); glEnable( GL_LIGHTING ); glEnable( GL_LIGHT0 ); glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 1); // Window osg::GLUTWindowPtr gwin; GLint glvp[4]; glGetIntegerv( GL_VIEWPORT, glvp ); gwin = osg::GLUTWindow::create(); gwin->setId(winid); gwin->setSize( glvp[2], glvp[3] ); win = gwin; win->addPort( vp ); // Action render_action = osg::DrawAction::create(); // trackball Vec3f min(-2.5,-2.5,-2.5), max(2.5,2.5,2.5); trackball.setMode( osg::Trackball::OSGObject ); float d = max[2] + (max[2]-min[2]); trackball.setStartPosition( 0, 0, d, true ); trackball.setSum( true ); trackball.setTranslationMode( osg::Trackball::OSGFree ); } // create moving objects if ( geom_type != OBJ_FILE ) createGeom( geom_type, Complexity, &fixed_node, &fixed_geom ); // else: has been loaded from file light_node->addChild( fixed_node ); if ( geom_type != OBJ_FILE ) createGeom( geom_type, Complexity, &moving_node, &moving_geom ); //#define DOPTREE_NUM_ORI 16 double pi = 3.141592653589793f; vector<Vec3f> translates; vector<Vec3f> rotation_xyzs; vector<float> rotates; //string config(""); if(configFile.length() == 0) { printf("config file is null, use -r configFileName\n"); return 0; } ifstream fin(configFile.data()); string line; int i = 0; int angle; float x,y,z; while(std::getline(fin, line)) { stringstream ss; ss << line; if(i & 0x1) // tranls { ss >> x >> y >> z; translates.push_back(Vec3f(x,y,z)); }else //angle rot {
int main( int argc, char *argv[] ) { // parse command line options parsecommandline( argc, argv ); // OSG init osg::osgLog().setLogLevel(osg::LOG_WARNING); osg::osgInit(argc, argv); // disable display lists osg::FieldContainerPtr pProto= osg::Geometry::getClassType().getPrototype(); osg::GeometryPtr pGeoProto = osg::GeometryPtr::dcast(pProto); if ( pGeoProto != osg::NullFC ) pGeoProto->setDlistCache(false); // create the graph osg::NodePtr node; // root root = osg::Node::create(); beginEditCP(root); root->setCore( osg::Group::create() ); // beacon for camera and light osg::NodePtr beacon; beacon = osg::Node::create(); beginEditCP(beacon); beacon->setCore( osg::Group::create() ); endEditCP(beacon); // light light_node = osg::Node::create(); osg::DirectionalLightPtr light = osg::DirectionalLight::create(); beginEditCP( light_node ); light_node->setCore( light ); endEditCP( light_node ); root->addChild( light_node ); beginEditCP(light); light->setAmbient( .3, .3, .3, 1 ); light->setDiffuse( 1, 1, 1, 1 ); light->setDirection(0,0,1); light->setBeacon( beacon ); endEditCP(light); // transformation, parent of beacon node = osg::Node::create(); cam_trans = osg::Transform::create(); beginEditCP(node); node->setCore( cam_trans ); node->addChild( beacon ); endEditCP(node); root->addChild( node ); // finish scene graph endEditCP(root); // Camera osg::PerspectiveCameraPtr cam = osg::PerspectiveCamera::create(); cam->setBeacon( beacon ); cam->setFov( 50 ); cam->setNear( 0.1 ); cam->setFar( 10000 ); // Background osg::SolidBackgroundPtr background = osg::SolidBackground::create(); // Viewport osg::ViewportPtr vp = osg::Viewport::create(); vp->setCamera( cam ); vp->setBackground( background ); vp->setRoot( root ); vp->setSize( 0,0, 1,1 ); if ( with_window ) { // GLUT init glutInitWindowSize( 400, 400 ); // before glutInit so user can glutInitWindowPosition( 100, 100 ); // override with comannd line args glutInit(&argc, argv); glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE); int winid = glutCreateWindow("Polygon Intersection Check Test"); glutKeyboardFunc(key); glutVisibilityFunc(vis); glutReshapeFunc(reshape); glutDisplayFunc(display); glutMouseFunc(mouse); glutMotionFunc(motion); glutIdleFunc(display); glEnable( GL_DEPTH_TEST ); glEnable( GL_LIGHTING ); glEnable( GL_LIGHT0 ); // Window osg::GLUTWindowPtr gwin; GLint glvp[4]; glGetIntegerv( GL_VIEWPORT, glvp ); gwin = osg::GLUTWindow::create(); gwin->setId(winid); gwin->setSize( glvp[2], glvp[3] ); win = gwin; win->addPort( vp ); // Action render_action = osg::DrawAction::create(); // trackball Vec3f min(-1,-1,-1), max(1,1,1); // root->updateVolume(); // const osg::BoxVolume &vol = dynamic_cast<const osg::BoxVolume &>(root->getVolume()); // // in the long term, the abstract volume will be able to provide min/max // vol.getBounds( min, max ); trackball.setMode( osg::Trackball::OSGObject ); float d = max[2] + (max[2]-min[2])*1.5; trackball.setStartPosition( 0, 0, d, true ); trackball.setSum( true ); trackball.setTranslationMode( osg::Trackball::OSGFree ); // run... glutMainLoop(); } else { // run in batch mode int phase = 0; do testcase( &phase ); while ( phase > 0 ); } return 0; }
void SimulationEngine::createChildVisualEntity(osg::NodePtr parentNode, /*osg::TransformPtr trans,*/ const opal::ShapeData* data, const std::string& name, const std::string& materialName) { // Create an Ogre SceneNode for the Entity. osg::Matrix m; opal::Point3r offsetPos = data->offset.getPosition(); //Ogre::Vector3 translationOffset(offsetPos[0], offsetPos[1], //offsetPos[2]); opal::Quaternion offsetQuat = data->offset.getQuaternion(); //Ogre::Quaternion rotationOffset; //rotationOffset.x = offsetQuat.x; //rotationOffset.y = offsetQuat.y; //rotationOffset.z = offsetQuat.z; //rotationOffset.w = offsetQuat.w; //Ogre::SceneNode* newChildNode = NULL; //Ogre::Entity* e = NULL; // OSG covention: we need one new node and transformation osg::NodePtr newChildNode; //= osg::Node::create(); osg::TransformPtr newTransCore = osg::Transform::create(); osg::beginEditCP(newTransCore); m.setIdentity(); m.setTranslate( (osg::Real32)offsetPos[0], (osg::Real32)offsetPos[1], (osg::Real32)offsetPos[2]); m.setRotate( osg::Quaternion( osg::Vec3f( (osg::Real32)offsetQuat[1], (osg::Real32)offsetQuat[2], (osg::Real32)offsetQuat[3]), (osg::Real32)offsetQuat[0])); newTransCore->setMatrix(m); osg::endEditCP(newTransCore); switch(data->getType()) { case opal::BOX_SHAPE: { //newChildNode = parentNode->createChildSceneNode(name, //translationOffset, rotationOffset); // Scale the object according to the given dimensions. opal::Vec3r boxDim = static_cast<const opal::BoxShapeData*> (data)->dimensions; //Ogre::Vector3 dimensions(boxDim[0], boxDim[1], boxDim[2]); //newChildNode->scale(dimensions[0], dimensions[1], //dimensions[2]); //create the geometry which we will assign a texture to newChildNode = osg::makeBox((osg::Real32)boxDim[0], (osg::Real32)boxDim[1], (osg::Real32)boxDim[2],1,1,1); // Create an Ogre Entity using a cube mesh. This mesh must be // stored as a box with dimensions 1x1x1. //e = mOgreSceneMgr->createEntity(name, "cube.mesh"); //e->setMaterialName(materialName); // Keep the normals normalized even after scaling. //e->setNormaliseNormals(true); // Attach the Entity to the SceneNode. //newChildNode->attachObject(e); //osg::beginEditCP(parentNode, osg::Node::CoreFieldMask | osg::Node::ChildrenFieldMask); osg::beginEditCP(parentNode); parentNode->setCore(newTransCore); parentNode->addChild(newChildNode); osg::endEditCP(parentNode); //osg::endEditCP(parentNode, osg::Node::CoreFieldMask | osg::Node::ChildrenFieldMask); break; } case opal::SPHERE_SHAPE: { //newChildNode = parentNode->createChildSceneNode(name, //translationOffset, rotationOffset); // Scale the object according to the given dimensions. //Ogre::Real radius = static_cast<const opal::SphereShapeData*> //(data)->radius; //newChildNode->scale(radius, radius, radius); opal::real radius = static_cast<const opal::SphereShapeData*> (data)->radius; newChildNode = osg::makeSphere(3, (osg::Real32)radius); // Create an Ogre Entity using a sphere mesh. This mesh must be // stored as a sphere with radius 1. //e = mOgreSceneMgr->createEntity(name, "sphere.mesh"); //e->setMaterialName(materialName); // Keep the normals normalized even after scaling. //e->setNormaliseNormals(true); // Attach the Entity to the SceneNode. //newChildNode->attachObject(e); //osg::beginEditCP(parentNode, osg::Node::CoreFieldMask | osg::Node::ChildrenFieldMask); osg::beginEditCP(parentNode); parentNode->setCore(newTransCore); parentNode->addChild(newChildNode); osg::endEditCP(parentNode); //osg::endEditCP(parentNode, osg::Node::CoreFieldMask | osg::Node::ChildrenFieldMask); break; } case opal::CAPSULE_SHAPE: { osg::NodePtr capsule = osg::Node::create(); osg::NodePtr topcap = osg::Node::create(); osg::NodePtr botcap = osg::Node::create(); // Create an Ogre SceneNode for the cylinder Entity. std::string subObjectName = "cylinder" + name; //newChildNode = parentNode->createChildSceneNode( //subObjectName, translationOffset, rotationOffset); // Scale the object according to the given dimensions. This // will also scale the transforms for the child nodes, but // we disable the "inherit scale" option for child nodes // here so the shapes themselves don't get scaled. //Ogre::Real radius = static_cast<const opal::CapsuleShapeData*> //(data)->radius; opal::real radius = static_cast<const opal::CapsuleShapeData*> (data)->radius; //Ogre::Real length = static_cast<const opal::CapsuleShapeData*> //(data)->length; opal::real length = static_cast<const opal::CapsuleShapeData*> (data)->length; //newChildNode->scale(radius, radius, length); osg::NodePtr cyl = osg::makeCylinder((osg::Real32)length, (osg::Real32)radius, 40,true,false,false); // This mesh must be stored as a cylinder with length 1 and // radius 1. //e = mOgreSceneMgr->createEntity(subObjectName, "cylinder.mesh"); //e->setMaterialName(materialName); //e->setNormaliseNormals(true); //newChildNode->attachObject(e); // The spheres must use separate scene nodes that are offset // from the cylinder's scene node. // This mesh must be stored as a sphere with radius 1. subObjectName = "sphere0" + name; //Ogre::SceneNode* sphereNode = newChildNode->createChildSceneNode( //subObjectName); //sphereNode->setInheritScale(false); //sphereNode->translate(0, 0, -0.5); //sphereNode->scale(radius, radius, radius); //e = mOgreSceneMgr->createEntity(subObjectName, "sphere.mesh"); //e->setMaterialName(materialName); //e->setNormaliseNormals(true); //sphereNode->attachObject(e); osg::NodePtr topGeo = osg::makeSphere(3,(osg::Real32)radius); //one geometry and one transform node osg::TransformPtr topTr = osg::Transform::create(); osg::Matrix _m; //osg::beginEditCP(tChimney, osg::Transform::MatrixFieldMask); osg::beginEditCP(topTr); _m.setIdentity(); _m.setTranslate(0,(osg::Real32)length/2.0,0); topTr->setMatrix(_m); osg::endEditCP(topTr); //osg::endEditCP(tChimney, osg::Transform::MatrixFieldMask); //osg::beginEditCP(chimneyTrans, osg::Node::CoreFieldMask | osg::Node::ChildrenFieldMask); osg::beginEditCP(topcap); topcap->setCore(topTr); topcap->addChild(topGeo); osg::endEditCP(topcap); //osg::endEditCP(chimneyTrans, osg::Node::CoreFieldMask | osg::Node::ChildrenFieldMask); subObjectName = "sphere1" + name; //sphereNode = newChildNode->createChildSceneNode(subObjectName); //sphereNode->setInheritScale(false); //sphereNode->translate(0, 0, 0.5); //sphereNode->scale(radius, radius, radius); //e = mOgreSceneMgr->createEntity(subObjectName, "sphere.mesh"); //e->setMaterialName(materialName); //e->setNormaliseNormals(true); //sphereNode->attachObject(e); osg::NodePtr botGeo = osg::makeSphere(3,(osg::Real32)radius); osg::TransformPtr botTr = osg::Transform::create(); osg::Matrix _n; //osg::beginEditCP(tChimney, osg::Transform::MatrixFieldMask); osg::beginEditCP(botTr); _n.setIdentity(); _n.setTranslate(0,-(osg::Real32)length/2.0,0); botTr->setMatrix(_n); osg::endEditCP(botTr); //osg::endEditCP(tChimney, osg::Transform::MatrixFieldMask); //osg::beginEditCP(chimneyTrans, osg::Node::CoreFieldMask | osg::Node::ChildrenFieldMask); osg::beginEditCP(botcap); botcap->setCore(botTr); botcap->addChild(botGeo); osg::endEditCP(botcap); //osg::endEditCP(chimneyTrans, osg::Node::CoreFieldMask | osg::Node::ChildrenFieldMask); // Finally Compose everything to a Capsule!! osg::beginEditCP(capsule); capsule->setCore(osg::Group::create()); capsule->addChild(cyl); capsule->addChild(topcap); capsule->addChild(botcap); osg::endEditCP(capsule); // OK send to new scene noe newChildNode = capsule; //osg::beginEditCP(parentNode, osg::Node::CoreFieldMask | osg::Node::ChildrenFieldMask); osg::beginEditCP(parentNode); parentNode->setCore(newTransCore); parentNode->addChild(newChildNode); osg::endEditCP(parentNode); //osg::endEditCP(parentNode, osg::Node::CoreFieldMask | osg::Node::ChildrenFieldMask); break; } default: assert(false); break; } }
// No arguments: batch convert all vt* files // switch argument: batch convert all vt* files into one osb file with a switch // file argument: convert only the specified file int main (int argc, char const* argv[]) { vector<string> filenames; bool useSwitch = false; if (argc == 2) { if (string(argv[1]).find("switch") != string::npos) useSwitch = true; else filenames.push_back(string(argv[1])); } if (useSwitch || filenames.empty()) { const boost::regex e(".+\\.vt[a-z]"); directory_iterator end; for (directory_iterator it("./"); it != end; ++it) { string curFile = it->path().filename().string(); if (regex_match(curFile, e)) filenames.push_back(curFile); } } OSG::osgInit(0, NULL); vtkPolyDataMapper* mapper = vtkPolyDataMapper::New(); OSG::NodePtr switchNode = OSG::Node::create(); OSG::SwitchPtr switchCore = OSG::Switch::create(); beginEditCP(switchCore); switchCore->setChoice(0); endEditCP(switchCore); beginEditCP(switchNode); switchNode->setCore(switchCore); endEditCP(switchNode); for (vector<string>::const_iterator it = filenames.begin(); it != filenames.end(); ++it) { string filename(*it); cout << "Opening file " << filename << " ... " << endl << flush; string fileExt = getFileExt(filename); vtkXMLDataReader* reader = NULL; vtkGenericDataObjectReader* oldStyleReader = NULL; if (fileExt.find("vti") != string::npos) { reader = vtkXMLImageDataReader::New(); vtkSmartPointer<vtkImageDataGeometryFilter> geoFilter = vtkSmartPointer<vtkImageDataGeometryFilter>::New(); geoFilter->SetInputConnection(reader->GetOutputPort()); mapper->SetInputConnection(geoFilter->GetOutputPort()); } if (fileExt.find("vtr") != string::npos) { reader = vtkXMLRectilinearGridReader::New(); vtkSmartPointer<vtkGeometryFilter> geoFilter = vtkSmartPointer<vtkGeometryFilter>::New(); geoFilter->SetInputConnection(reader->GetOutputPort()); mapper->SetInputConnection(geoFilter->GetOutputPort()); } else if (fileExt.find("vts") != string::npos) { reader = vtkXMLStructuredGridReader::New(); vtkSmartPointer<vtkGeometryFilter> geoFilter = vtkSmartPointer<vtkGeometryFilter>::New(); geoFilter->SetInputConnection(reader->GetOutputPort()); mapper->SetInputConnection(geoFilter->GetOutputPort()); } else if (fileExt.find("vtp") != string::npos) { reader = vtkXMLPolyDataReader::New(); mapper->SetInputConnection(reader->GetOutputPort()); } else if (fileExt.find("vtu") != string::npos) { reader = vtkXMLUnstructuredGridReader::New(); vtkSmartPointer<vtkGeometryFilter> geoFilter = vtkSmartPointer<vtkGeometryFilter>::New(); geoFilter->SetInputConnection(reader->GetOutputPort()); mapper->SetInputConnection(geoFilter->GetOutputPort()); } else if (fileExt.find("vtk") != string::npos) { oldStyleReader = vtkGenericDataObjectReader::New(); oldStyleReader->SetFileName(filename.c_str()); oldStyleReader->Update(); if(oldStyleReader->IsFilePolyData()) mapper->SetInputConnection(oldStyleReader->GetOutputPort()); else { vtkSmartPointer<vtkGeometryFilter> geoFilter = vtkSmartPointer<vtkGeometryFilter>::New(); geoFilter->SetInputConnection(oldStyleReader->GetOutputPort()); mapper->SetInputConnection(geoFilter->GetOutputPort()); } } else { cout << "Not a valid vtk file ending (vti, vtr, vts, vtp, vtu, vtk)" << endl; return 1; } if (fileExt.find("vtk") == string::npos) { reader->SetFileName(filename.c_str()); reader->Update(); } vtkActor* actor = vtkActor::New(); actor->SetMapper(mapper); vtkOsgConverter converter(actor); converter.SetVerbose(true); //converter->SetMapper(mapper); converter.WriteAnActor(); OSG::NodePtr node = converter.GetOsgNode(); replaceExt(filename, "osb"); if (useSwitch) { beginEditCP(switchNode); switchNode->addChild(node); endEditCP(switchNode); } else OSG::SceneFileHandler::the().write(node, filename.c_str()); if (reader) reader->Delete(); if (oldStyleReader) oldStyleReader->Delete(); } if (useSwitch) { string filename(filenames[0]); replaceExt(filename, "osb"); OSG::SceneFileHandler::the().write(switchNode, filename.c_str()); } //mapper->Delete(); // TODO crashes OSG::osgExit(); cout << "File conversion finished" << endl; return 0; }
CameraPtr Camera::init() { // Create a transform to contain the location and orientation of the camera. mTransform = OSG::Transform::create(); OSG::NodePtr beacon = OSG::Node::create(); #if OSG_MAJOR_VERSION < 2 OSG::CPEditor be(beacon, OSG::Node::CoreFieldMask); #endif beacon->setCore(mTransform); mLeftTexture = tex_chunk_t::create(); #if OSG_MAJOR_VERSION < 2 OSG::CPEditor lte(mLeftTexture); mLeftTexture->setEnvMode(GL_MODULATE); #else mLeftTexEnv = OSG::TextureEnvChunk::create(); mLeftTexEnv->setEnvMode(GL_MODULATE); #endif mRightTexture = tex_chunk_t::create(); #if OSG_MAJOR_VERSION < 2 OSG::CPEditor rte(mRightTexture); mRightTexture->setEnvMode(GL_MODULATE); #else mRightTexEnv = OSG::TextureEnvChunk::create(); mRightTexEnv->setEnvMode(GL_MODULATE); #endif mCurrentTexture = mLeftTexture; #if OSG_MAJOR_VERSION >= 2 mCurrentTexEnv = mLeftTexEnv; #endif // setup camera mCamera = OSG::PerspectiveCamera::create(); #if OSG_MAJOR_VERSION < 2 OSG::CPEditor ce(mCamera); #endif mCamera->setFov( #if OSG_MAJOR_VERSION < 2 OSG::osgdegree2rad(60.0) #else OSG::osgDegree2Rad(60.0) #endif ); mCamera->setNear(0.01); mCamera->setFar(10000); mCamera->setBeacon(beacon); mLeftImage = OSG::Image::create(); mRightImage = OSG::Image::create(); OSG::ImagePtr img; // Set up FBO textures. img = mLeftImage; mLeftTexture->setMinFilter(GL_LINEAR); mLeftTexture->setMagFilter(GL_LINEAR); mLeftTexture->setTarget(GL_TEXTURE_2D); mLeftTexture->setInternalFormat(GL_RGBA8); mLeftTexture->setImage(img); img = mRightImage; mRightTexture->setMinFilter(GL_LINEAR); mRightTexture->setMagFilter(GL_LINEAR); mRightTexture->setTarget(GL_TEXTURE_2D); mRightTexture->setInternalFormat(GL_RGBA8); mRightTexture->setImage(img); mCurrentImage = mLeftImage; return shared_from_this(); }