PhysicsBodyDrawWrapper(const NodeUnrecPtr node, const PhysicsBodyUnrecPtr body, MaterialUnrecPtr mat) : _node(node),_body(body), _mat(mat) { if(_mat == NULL) { _mat = getDefaultUnlitMaterial(); } }
static void drop(DrawActionBase *action, const BoxVolume &volume, Color3f col) #endif { VolumeDrawWrapper * vdw = new VolumeDrawWrapper(volume, col); Material::DrawFunctor func; func = osgTypedMethodFunctor1ObjPtr(vdw, &VolumeDrawWrapper::draw); RenderAction *ra = dynamic_cast<RenderAction*>(action); ra->dropFunctor(func, getCPtr(getDefaultUnlitMaterial())); }
Action::ResultE SkeletonSkinningAlgorithm::renderEnter(Action *action) { Action::ResultE res = Action::Continue; RenderAction *ract = boost::polymorphic_downcast<RenderAction *>(action); SkinnedGeometry *skinGeo = getSkin(); Skeleton *skel = skinGeo->getSkeleton(); skel->renderEnter(action, skinGeo); const Skeleton::MFJointsType *joints = skel->getMFJoints(); const Skeleton::MFParentJointsType *parentJoints = skel->getMFParentJoints(); const Skeleton::MFJointMatricesType *jointMats = skel->getMFJointMatrices(); UInt32 numJoints = joints->size32(); #ifndef OSG_SKELETON_SKINNING_ALGO_DRAW_AXIS _mfDrawPositions.resize(numJoints); _mfDrawIndex .clear ( ); for(UInt32 i = 0; i < numJoints; ++i) { (*jointMats)[i].mult(Pnt3f(0.f, 0.f, 0.f), _mfDrawPositions[i] ); if((*parentJoints)[i] != NULL) { _mfDrawIndex.push_back(i ); _mfDrawIndex.push_back((*parentJoints)[i]->getJointId()); } } #else Real32 axisLen = 1.f; _mfDrawPositions.resize(4 * numJoints); _mfDrawIndex .clear ( ); for(UInt32 i = 0; i < numJoints; ++i) { (*jointMats)[i].mult(Pnt3f(0.f, 0.f, 0.f), _mfDrawPositions[4 * i + 0]); if((*parentJoints)[i] != NULL) { _mfDrawIndex.push_back(4 * i + 0); _mfDrawIndex.push_back(4 * (*parentJoints)[i]->getJointId() + 0); Vec3f vec = _mfDrawPositions[4 * i + 0] - _mfDrawPositions[4 * (*parentJoints)[i]->getJointId() + 0]; axisLen = 0.2f * vec.length(); axisLen = 1.f; } else { axisLen = 1.f; } (*jointMats)[i].mult( Pnt3f(axisLen, 0.f, 0.f ), _mfDrawPositions[4 * i + 1]); (*jointMats)[i].mult( Pnt3f(0.f, axisLen, 0.f ), _mfDrawPositions[4 * i + 2]); (*jointMats)[i].mult( Pnt3f(0.f, 0.f, axisLen), _mfDrawPositions[4 * i + 3]); _mfDrawIndex.push_back(4 * i + 0); _mfDrawIndex.push_back(4 * i + 1); _mfDrawIndex.push_back(4 * i + 0); _mfDrawIndex.push_back(4 * i + 2); _mfDrawIndex.push_back(4 * i + 0); _mfDrawIndex.push_back(4 * i + 3); } #endif // #ifndef OSG_SKELETON_SKINNING_ALGO_DRAW_AXIS DrawEnv::DrawFunctor drawFuncSkinAlgo = boost::bind(&SkeletonSkinningAlgorithm::drawFunc, this, _1); PrimeMaterial *skelMat = getDefaultUnlitMaterial(); State *state = skelMat->getState (); ract->dropFunctor(drawFuncSkinAlgo, state, skelMat->getSortKey()); return res; }
// 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 /* Geometry data in OpenSG is stored in several separate vectors. These vectors are not a direct part of the Geometry Core but rather split up into multiple separate classes. These classes, the GeoProperties, contain a single field containg their values, which can be accessed directly, see the docs for GeoProperty for the whole interface. */ /* The first part: the primtive types. These are taken from OpenGL, any values that can be passed to glBegin(); are legal. Different types can be freely mixed. All properties have only one field, which has the same name for every property, thus the mask is also called the same for each property. */ GeoPTypesPtr type = GeoPTypesUI8::create(); beginEditCP(type, GeoPTypesUI8::GeoPropDataFieldMask); { type->addValue(GL_POLYGON ); type->addValue(GL_TRIANGLES); type->addValue(GL_QUADS ); } endEditCP (type, GeoPTypesUI8::GeoPropDataFieldMask); /* The second part: the primtive lengths. These define the number of vertices to be passed to OpenGL for each primitive. Thus there have to be at least as many entries as in the types property. */ GeoPLengthsPtr lens = GeoPLengthsUI32::create(); beginEditCP(lens, GeoPLengthsUI32::GeoPropDataFieldMask); { lens->addValue(4); lens->addValue(6); lens->addValue(8); } endEditCP (lens, GeoPLengthsUI32::GeoPropDataFieldMask); /* The third part: the vertex positions. OpenSG uses different types for vectors and points. Points (e.g. Pnt3f) are just positions in space, they have a limited set of operations they can handle. Vectors (e.g. Vec3f) are the more general kind. */ GeoPositions3fPtr pnts = GeoPositions3f::create(); beginEditCP(pnts, GeoPositions3f::GeoPropDataFieldMask); { // the 4 points of the polygon pnts->addValue(Pnt3f(-1, -1, -1)); pnts->addValue(Pnt3f(-1, -1, 1)); pnts->addValue(Pnt3f( 1, -1, 1)); pnts->addValue(Pnt3f( 1, -1, -1)); // the 6 points of the two triangles pnts->addValue(Pnt3f( 1, 0, -1)); pnts->addValue(Pnt3f(-1, 0, -1)); pnts->addValue(Pnt3f( 0, 1, -1)); pnts->addValue(Pnt3f(-1, 0, 1)); pnts->addValue(Pnt3f( 1, 0, 1)); pnts->addValue(Pnt3f( 0, 1, 1)); // the 8 points of the two quads pnts->addValue(Pnt3f(-1, -1, 1)); pnts->addValue(Pnt3f( 1, -1, 1)); pnts->addValue(Pnt3f( 1, 0, 1)); pnts->addValue(Pnt3f(-1, 0, 1)); pnts->addValue(Pnt3f( 1, -1, -1)); pnts->addValue(Pnt3f(-1, -1, -1)); pnts->addValue(Pnt3f(-1, 0, -1)); pnts->addValue(Pnt3f( 1, 0, -1)); } endEditCP (pnts, GeoPositions3f::GeoPropDataFieldMask); /* Put it all together into a Geometry NodeCore. */ geo=Geometry::create(); beginEditCP(geo, Geometry::TypesFieldMask | Geometry::LengthsFieldMask | Geometry::PositionsFieldMask | Geometry::MaterialFieldMask ); { geo->setTypes (type); geo->setLengths (lens); geo->setPositions(pnts); // assign a material to the geometry to make it visible. The details // of materials are defined later. geo->setMaterial(getDefaultUnlitMaterial()); } endEditCP (geo, Geometry::TypesFieldMask | Geometry::LengthsFieldMask | Geometry::PositionsFieldMask | Geometry::MaterialFieldMask ); // put the geometry core into a node NodePtr n = Node::create(); beginEditCP(n, Node::CoreFieldMask); { n->setCore(geo); } endEditCP (n, Node::CoreFieldMask); // add a transformation to make it move NodePtr scene = Node::create(); trans = Transform::create(); beginEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask ); { scene->setCore(trans); scene->addChild(n); } 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; }
// 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 scene = Node::create(); GroupPtr grcore = Group::create(); beginEditCP(scene); scene->setCore(grcore); // Add a Torus for background scene->addChild(makeTorus(.2, 2, 16, 16)); // The actual creation of the functors is a little complicated. // Mainly because the braindead M$ compiler has problems with, you have to // explicitly create the functor for the right combination of return value // type, number of arguments and argument types (values, pointers, // references, etc.) and whether it is a function, a static method or an // instance method. // Given that the signatures of the draw and volumeUpdate functions are // fixed, the three variants shown here should cover all the bases // Add the DrawFunctor node for standard functions NodePtr df = Node::create(); DrawFunctorCorePtr func = DrawFunctorCore::create(); beginEditCP(func); func->setMaterial(getDefaultUnlitMaterial()); func->setDraw( osgTypedFunctionFunctor1Ptr< Action::ResultE, DrawActionBase >(draw)); func->setVolumeUpdate( osgTypedFunctionVoidFunctor1Ptr< Volume >(volUpdate)); endEditCP(func); beginEditCP(df); df->setCore(func); endEditCP(df); scene->addChild(df); // Some transparent material // Even though the DrawFunctorCore can do any kind of OpenGL functions, the // Material of the Core is used to decide whether the node should be sorted // and rendered last SimpleMaterialPtr transmat = SimpleMaterial::create(); beginEditCP(transmat); transmat->setTransparency(0.1); // The actual value is overriden by the draw // anyway, but it has to be != 0 to be // considered transparent transmat->setLit(false); endEditCP(transmat); // Add the DrawFunctor node for static methods of a class // Static methods are pretty much the same as functions NodePtr dfsm = Node::create(); DrawFunctorCorePtr funcsm = DrawFunctorCore::create(); beginEditCP(funcsm); funcsm->setMaterial(transmat); funcsm->setDraw( osgTypedFunctionFunctor1Ptr< Action::ResultE, DrawActionBase >( &SWrapper::draw)); funcsm->setVolumeUpdate( osgTypedFunctionVoidFunctor1Ptr< Volume >(&SWrapper::volUpdate)); endEditCP(funcsm); beginEditCP(dfsm); dfsm->setCore(funcsm); endEditCP(dfsm); scene->addChild(dfsm); // Add the DrawFunctor node for methods // The functor creation functions need the type of the object for which // methods should be called. Wrapper wrap(Color4f(0,1,0,.3)); NodePtr dfm = Node::create(); DrawFunctorCorePtr funcm = DrawFunctorCore::create(); beginEditCP(funcm); funcm->setMaterial(transmat); funcm->setDraw( osgTypedMethodFunctor1ObjPtr< Action::ResultE, Wrapper, DrawActionBase >( &wrap, &Wrapper::draw)); funcm->setVolumeUpdate( osgTypedMethodVoidFunctor1ObjPtr< Wrapper, Volume >( &wrap, &Wrapper::volUpdate)); endEditCP(funcm); beginEditCP(dfm); dfm->setCore(funcm); endEditCP(dfm); scene->addChild(dfm); // Add a Sphere, just for fun scene->addChild(makeLatLongSphere(16,16,.4)); endEditCP(scene); // 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; }