AppState::AppState(osgViewer::Viewer* viewer_) : displayScene(true), invertRange(true), currentConfig(0), viewer(viewer_), zNear(0.03125) { sw = new Switch; string fontName("fonts/arial.ttf"); // Text description of current config configText = new osgText::Text; configText->setDataVariance(Object::DYNAMIC); configText->setFont(fontName); configText->setPosition(Vec3(50.0f, 50.0f, 0.0f)); configText->setColor(Vec4(1.0, 1.0, 1.0, 1.0)); Geode* textGeode = new Geode; textGeode->addDrawable(configText.get()); // Text for the near plane distance zNearText = new osgText::Text; zNearText->setDataVariance(Object::DYNAMIC); zNearText->setFont(fontName); zNearText->setPosition(Vec3(1230.0f, 50.0f, 0.0f)); zNearText->setColor(Vec4(1.0, 1.0, 1.0, 1.0)); zNearText->setAlignment(osgText::Text::RIGHT_BASE_LINE); textGeode->addDrawable(zNearText.get()); // Projection that lets the text be placed in pixels. textProjection = new Projection; textProjection->setMatrix(Matrix::ortho2D(0,1280,0,1024)); textProjection->addChild(textGeode); // "texture not available" text displayed when the user trys to // display the depth texture while multisampling. osgText::Text* noCanDo = new osgText::Text; noCanDo->setFont(fontName); noCanDo->setPosition(Vec3(512.0f, 384.0f, 0.0f)); noCanDo->setColor(Vec4(1.0, 0.0, 0.0, 1.0)); noCanDo->setText("not available"); textNotAvailable = new Geode; textNotAvailable->addDrawable(noCanDo); textProjection->addChild(textNotAvailable.get()); // Is the depth test inverted? osgText::Text* inverted = new osgText::Text; inverted->setFont(fontName); inverted->setPosition(Vec3(512.0f, 50.0f, 0.0f)); inverted->setColor(Vec4(1.0, 1.0, 1.0, 1.0)); inverted->setText("inverted depth test"); textInverted = new Geode; textInverted->addDrawable(inverted); textInverted->setNodeMask(~0u); textProjection->addChild(textInverted.get()); textProjection->getOrCreateStateSet()->setRenderBinDetails(11, "RenderBin"); }
/*************************************************************** * Function: createText() ***************************************************************/ Geode *CAVEGroupReferenceAxis::createText3D(osgText::Text3D **text) { Geode *textGeode = new Geode; *text = new osgText::Text3D; textGeode->addDrawable(*text); (*text)->setFont(CAVEGeode::getDataDir() + "Fonts/TN.ttf"); (*text)->setCharacterSize(gCharSize, 0.7); (*text)->setCharacterDepth(gCharDepth); (*text)->setPosition(Vec3(0, 0, 0)); (*text)->setAlignment(osgText::Text3D::CENTER_BOTTOM); (*text)->setDrawMode(osgText::Text3D::TEXT); (*text)->setAxisAlignment(osgText::Text3D::XZ_PLANE); (*text)->setRenderMode(osgText::Text3D::PER_GLYPH); (*text)->setText(""); Material *material = new Material; material->setDiffuse(Material::FRONT_AND_BACK, Vec4(0, 1, 0, 1)); material->setAmbient(Material::FRONT_AND_BACK, Vec4(0, 1, 0, 1)); material->setAlpha(Material::FRONT_AND_BACK, 1.0f); StateSet *stateset = textGeode->getOrCreateStateSet(); stateset->setAttributeAndModes(material, StateAttribute::OVERRIDE | StateAttribute::ON); stateset->setMode(GL_BLEND, StateAttribute::OVERRIDE | StateAttribute::ON ); stateset->setRenderingHint(StateSet::TRANSPARENT_BIN); return textGeode; }
Geode* createTextureQuad(Texture2D *texture) { Vec3Array *vertices = new Vec3Array; vertices->push_back(Vec3(-1.0, -1.0, 0.0)); vertices->push_back(Vec3(1.0, -1.0, 0.0)); vertices->push_back(Vec3(1.0, 1.0, 0.0)); vertices->push_back(Vec3(-1.0, 1.0, 0.0)); Vec2Array *texcoord = new Vec2Array; texcoord->push_back(Vec2(0.0, 0.0)); texcoord->push_back(Vec2(1.0, 0.0)); texcoord->push_back(Vec2(1.0, 1.0)); texcoord->push_back(Vec2(0.0, 1.0)); Geometry *geom = new Geometry; geom->setVertexArray(vertices); geom->setTexCoordArray(0, texcoord); geom->addPrimitiveSet(new DrawArrays(GL_QUADS, 0, 4)); Geode *geode = new Geode; geode->addDrawable(geom); geode->getOrCreateStateSet()->setTextureAttributeAndModes(0, texture, StateAttribute::ON); return geode; }
void _dwobj::buildDrawable(Group *grp, const osgDB::ReaderWriter::Options *options) { // current DWobject complete; make a drawable, and add it to a osg::Group if (nfaces>0) { if (themat->isType(dwmaterial::PointLight) || themat->isType(dwmaterial::SpotLight)) { Vec4 pos; pos.set(0.0f,0.0f,0.0f,0.0f); for (int i=0; i<nverts; i++) { pos[0]+=verts[i].x(); pos[1]+=verts[i].y(); pos[2]+=verts[i].z(); } pos/=nverts; pos[3]=1.0f; LightSource *ls=themat->makeLight(pos); grp->addChild(ls); } else { Geode *geode = new Geode; int nfnvf=0; // number of vertices for faces plus holes int i; // a general counter for (i=0; i<nfaces; i++) { // for each face faces[i].setnorm(verts); // set its normal and any hole normals nfnvf+=faces[i].getallverts(); // get total vertices in object, defines dimensions of NEW arrays } GLUtesselator* ts=gluNewTess(); gluTessCallback(ts, GLU_TESS_BEGIN, (GLU_TESS_CALLBACK) myFaceBegin); gluTessCallback(ts, GLU_TESS_VERTEX, (GLU_TESS_CALLBACK) myVertex); gluTessCallback(ts, GLU_TESS_END, (GLU_TESS_CALLBACK) myFaceEnd); gluTessCallback(ts, GLU_TESS_ERROR, (GLU_TESS_CALLBACK) error); gluTessCallback(ts, GLU_TESS_COMBINE_DATA, (GLU_TESS_CALLBACK) combineCallback); // for (int nvf=0; nvf<6; nvf++) { // for each length of face // for Geometry we dont need to collect prim types individually // prd.setmode(nvf , nfnvf); // filter out only this type of tessellated face prd=new prims; prd->settmat(tmat.get()); osg::Geometry *gset = new osg::Geometry; prd->setGeometry(gset); StateSet *dstate=themat->make(options); gset->setStateSet( dstate ); grp->addChild( geode ); // add to the world outside geode->addDrawable(gset); // each face adds a primitive to the geometry, after it is tessellated for (i=0; i<nfaces; i++) { // for each face, collect up prd->tessellate(faces[i],verts, themat, ts, this); } for (i=0; i<nopens; i++) { // for each hole, join up front & back with Quads if (fc1 && fc2) { faces[fc1[i]].link(openings[i*2], &faces[fc2[i]],openings[i*2+1],verts, themat); } } // for each opening prd->buildGeometry(); gluDeleteTess(ts); delete prd; } } // nfaces>0 verts.clear(); }
Geode* ChessUtils::createRectangleWithTexture(Vec3 centerPosition, Image* image, int width, int height, Vec4 color) { int halfWidth = width / 2; int halfHeight = height / 2; Vec3Array* vertices = new Vec3Array(); vertices->push_back(Vec3(centerPosition.x() - halfWidth, centerPosition.y() - halfHeight, centerPosition.z())); vertices->push_back(Vec3(centerPosition.x() + halfWidth, centerPosition.y() - halfHeight, centerPosition.z())); vertices->push_back(Vec3(centerPosition.x() + halfWidth, centerPosition.y() + halfHeight, centerPosition.z())); vertices->push_back(Vec3(centerPosition.x() - halfWidth, centerPosition.y() + halfHeight, centerPosition.z())); Vec3Array* normals = new Vec3Array(); normals->push_back(Vec3(0.0f, 0.0f, 1.0f)); Vec2Array* texcoords = new Vec2Array(); texcoords->push_back(Vec2(0.0f, 0.0f)); texcoords->push_back(Vec2(1.0f, 0.0f)); texcoords->push_back(Vec2(1.0f, 1.0f)); texcoords->push_back(Vec2(0.0f, 1.0f)); Vec4Array* colors = new Vec4Array(); colors->push_back(color); Geometry* quad = new Geometry(); quad->setVertexArray(vertices); quad->setNormalArray(normals); quad->setNormalBinding(osg::Geometry::BIND_OVERALL); quad->setColorArray(colors); quad->setColorBinding(osg::Geometry::BIND_OVERALL); quad->setTexCoordArray(0, texcoords); quad->addPrimitiveSet(new osg::DrawArrays(GL_QUADS, 0, 4)); Texture2D* texture = new Texture2D(); if (image != NULL) { texture->setImage(image); } Geode* geode = new Geode(); geode->addDrawable(quad); osg::BlendFunc* blendFunc = new osg::BlendFunc(); blendFunc->setFunction(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); osg::TexEnv* blendTexEnv = new osg::TexEnv(); blendTexEnv->setMode(osg::TexEnv::BLEND); osg::StateSet* geodeStateset = geode->getOrCreateStateSet(); geodeStateset->setAttributeAndModes(blendFunc); geodeStateset->setTextureAttribute(0, blendTexEnv); geodeStateset->setTextureAttributeAndModes(0, texture); geodeStateset->setRenderingHint(osg::StateSet::TRANSPARENT_BIN); return geode; }
Geode *Marker::createBox(Vec4 &color) { Geode *geode = new Geode(); TessellationHints *hints = new TessellationHints(); hints->setDetailRatio(0.3f); Vec3 boxCenter(0.0f, 0.0f, 0.0f); _boxShape = new Box(boxCenter, 1.0f); _shapeDrawable = new ShapeDrawable(_boxShape); _shapeDrawable->setTessellationHints(hints); _shapeDrawable->setColor(color); geode->addDrawable(_shapeDrawable); _shapeDrawable->setUseDisplayList(false); // allow changes to color and shape return geode; }
OpenRAVE::GraphHandlePtr OSGViewer::plot3(const float* ppoints, int numPoints, int stride, float pointsize, const float* colors, int drawstyle, bool bhasalpha) { osg::Geometry* geom = new osg::Geometry; int floats_per_pt = stride / sizeof(float); Vec3Array* osgPts = new Vec3Array; osgPts->reserve(numPoints); for (int i=0; i < numPoints; ++i) { const float* p = ppoints + i*floats_per_pt; if (isfinite(p[0])) osgPts->push_back(osg::Vec3(p[0], p[1], p[2])); } osg::StateSet* ss = geom->getOrCreateStateSet(); osg::Point *point = new osg::Point(); point->setSize(pointsize); ss->setAttribute(point); ss->setMode(GL_LIGHTING, osg::StateAttribute::OFF); osg::BlendFunc* blendFunc = new osg::BlendFunc; blendFunc->setFunction(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); ss->setAttributeAndModes(blendFunc); ss->setMode(GL_BLEND, osg::StateAttribute::ON); geom->setVertexArray(osgPts); geom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::POINTS,0,osgPts->size())); // // if (colors != NULL) { // Vec4Array* osgCols = new Vec4Array; // for (int i=0; i < numPoints; ++i) { // float* p = colors + i; // osgCols->push_back(osg::Vec4(p[0], p[1], p[2],1)); // } // geom->setColorArray(osgCols); // geom->setColorBinding(osg::Geometry::BIND_PER_VERTEX); // } Geode* geode = new osg::Geode(); geode->addDrawable(geom); return GraphHandlePtr(new OsgGraphHandle(geode, m_root.get())); }
Geode *Marker::createSphere(Vec4 &color) { Geode *geode = new Geode(); // setDetailRatio is a factor to multiply the default values for // numSegments (40) and numRows (10). // They won't go below the minimum values of MIN_NUM_SEGMENTS = 5, MIN_NUM_ROWS = 3 TessellationHints *hints = new TessellationHints(); hints->setDetailRatio(0.3f); Vec3 sphereCenter(0.0f, 0.0f, 0.0f); _sphereShape = new Sphere(sphereCenter, 1.0f); _shapeDrawable = new ShapeDrawable(_sphereShape); _shapeDrawable->setTessellationHints(hints); _shapeDrawable->setColor(color); geode->addDrawable(_shapeDrawable); _shapeDrawable->setUseDisplayList(false); // allow changes to color and shape return geode; }
void World::addDrawable(Drawable::Drawable *drawable, Transform *transform, std::string name) { // adding all to top-level group for now Geode *geo = new Geode; geo->addDrawable(drawable); if(transform) { transform->addChild(geo); _root->addChild(transform); } else { _root->addChild(geo); } if(!name.empty()) { _names[name] = drawable; } //notifyViews(); }
PositionAttitudeTransform *VideoGeode::createVideoSphere(float size, bool texRepeat) { Geode *sphere = new Geode(); sphere->addDrawable(new ShapeDrawable(new Sphere(Vec3(0, 0, 4), size))); // assign the material to the sphere StateSet *sphereStateSet = sphere->getOrCreateStateSet(); sphereStateSet->ref(); sphereStateSet->setAttribute(_material); try { sphereStateSet->setTextureAttributeAndModes(0, createVideoTexture(texRepeat), StateAttribute::ON); } catch (char *e) { throw e; } PositionAttitudeTransform *sphereTransform = new PositionAttitudeTransform(); sphereTransform->addChild(sphere); return sphereTransform; }
Geode *Marker::createCone(Vec4 &color) { Geode *geode = new Geode(); // setDetailRatio is a factor to multiply the default values for // numSegments (40) and numRows (10). // They won't go below the minimum values of MIN_NUM_SEGMENTS = 5, MIN_NUM_ROWS = 3 TessellationHints *hints = new TessellationHints(); hints->setDetailRatio(0.3f); // Create cone geometry: _coneShape = new Cone(Vec3(0, 0, 0), 0.1f, 0.5f); // center, radius, height _shapeDrawable = new ShapeDrawable(_coneShape); _shapeDrawable->setTessellationHints(hints); _shapeDrawable->setColor(color); _shapeDrawable->setUseDisplayList(false); // allow changes to color and shape geode->addDrawable(_shapeDrawable); return geode; }
Group* CreateBomb() { MatrixTransform *matrix_trans = new MatrixTransform(); Matrix *matrix = new Matrix(); Geode *node = new Geode(); float radius = 10; //创建精细度对象,精细度越高,细分就越多 osg::TessellationHints* hints = new osg::TessellationHints; //设置精细度为0.5f hints->setDetailRatio(0.5f); //添加一个球体,第一个参数是预定义几何体对象,第二个是精细度,默认为0 node->addDrawable(new osg::ShapeDrawable(new osg::Sphere(osg::Vec3(0, 100, 300), radius),hints)); matrix_trans->addChild(node); matrix_trans->setUpdateCallback(new BombCallback(Vec3(0,100,300))); //matrix_trans->setDataVariance(osg::Object::DYNAMIC); return matrix_trans; }
TFColorWidget::TFColorWidget(Interaction *interaction, Measure *b, int size) : Widget() , Events() { _interaction = interaction; Geode *geode = new Geode(); _geom = new Geometry(); _geom->setUseDisplayList(false); _vertices = new Vec3Array(); _vertices->push_back(Vec3(0, 0, 0)); _vertices->push_back(Vec3(0, 0, .2)); _vector = (*_vertices)[1] - (*_vertices)[0]; _vector.normalize(); _geom->setVertexArray(_vertices); DrawElementsUInt *line = new DrawElementsUInt(osg::PrimitiveSet::LINES, 0); line->push_back(0); line->push_back(1); _geom->addPrimitiveSet(line); _colors = new Vec4Array(1); (*_colors)[0].set(0.0, 0.0, 0.0, 1.0); _geom->setColorArray(_colors); _geom->setColorBinding(osg::Geometry::BIND_OVERALL); geode->addDrawable(_geom); _node->addChild(geode); LineWidth *width = new LineWidth(); width->setWidth(size); StateSet *state = _geom->getOrCreateStateSet(); state->setAttribute(width, osg::StateAttribute::ON); state->setMode(GL_LIGHTING, StateAttribute::OFF); _interaction->addListener(this, this); }
OpenRAVE::GraphHandlePtr OSGViewer::drawlinelist(const float *ppoints, int numPoints, int stride, float fwidth, const RaveVectorf &color) { osg::Geometry* geom = new osg::Geometry; int floats_per_pt = stride / sizeof(float); Vec3Array* osgPts = new Vec3Array; osgPts->reserve(numPoints); for (int i=0; i < numPoints; ++i) { const float* p = ppoints + i*floats_per_pt; if (isfinite(p[0])) osgPts->push_back(osg::Vec3(p[0], p[1], p[2])); } osg::StateSet* ss = geom->getOrCreateStateSet(); osg::LineWidth *lw= new osg::LineWidth; lw->setWidth(fwidth); ss->setAttribute(lw); ss->setMode(GL_LIGHTING, osg::StateAttribute::OFF); osg::BlendFunc* blendFunc = new osg::BlendFunc; blendFunc->setFunction(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); ss->setAttributeAndModes(blendFunc); ss->setMode(GL_BLEND, osg::StateAttribute::ON); osg::Vec4Array* osgColor = new osg::Vec4Array(); osgColor->push_back( osg::Vec4( color[0], color[1], color[2], color[3] ) ); geom->setColorArray(osgColor); geom->setColorBinding(osg::Geometry::BIND_OVERALL); geom->setVertexArray(osgPts); geom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::LINES,0,osgPts->size())); Geode* geode = new osg::Geode(); geode->addDrawable(geom); return GraphHandlePtr(new OsgGraphHandle(geode, m_root.get())); }
Geode *ClipPlanePlugin::loadPlane() { // *5---*6---*7 // | | | // *3--------*4 // | | | // *0---*1---*2 float w = cover->getSceneSize() * 0.1; // width of plane Vec3Array *lineCoords = new Vec3Array(12); (*lineCoords)[0].set(-w, -0.01, -w); (*lineCoords)[1].set(w, -0.01, -w); (*lineCoords)[2].set(-w, -0.01, 0.0f); (*lineCoords)[3].set(w, -0.01, 0.0f); (*lineCoords)[4].set(-w, -0.01, w); (*lineCoords)[5].set(w, -0.01, w); (*lineCoords)[6].set(-w, -0.01, -w); (*lineCoords)[7].set(-w, -0.01, w); (*lineCoords)[8].set(0.0f, -0.01, -w); (*lineCoords)[9].set(0.0f, -0.01, w); (*lineCoords)[10].set(w, -0.01, -w); (*lineCoords)[11].set(w, -0.01, w); DrawArrayLengths *primitives = new DrawArrayLengths(PrimitiveSet::LINE_STRIP); for (int i = 0; i < 6; i++) { primitives->push_back(2); } Vec3Array *lineColors = new Vec3Array(12); for (int i = 0; i < 12; i++) { (*lineColors)[i].set(Vec3(1.0f, 1.0f, 1.0f)); } Geometry *geoset = new Geometry(); geoset->setVertexArray(lineCoords); geoset->addPrimitiveSet(primitives); geoset->setColorArray(lineColors); Material *mtl = new Material; mtl->setColorMode(Material::AMBIENT_AND_DIFFUSE); mtl->setAmbient(Material::FRONT_AND_BACK, Vec4(0.2f, 0.2f, 0.2f, 1.0f)); mtl->setDiffuse(Material::FRONT_AND_BACK, Vec4(0.9f, 0.9f, 0.9f, 1.0f)); mtl->setSpecular(Material::FRONT_AND_BACK, Vec4(0.9f, 0.9f, 0.9f, 1.0f)); mtl->setEmission(Material::FRONT_AND_BACK, Vec4(0.0f, 0.0f, 0.0f, 1.0f)); mtl->setShininess(Material::FRONT_AND_BACK, 16.0f); Geode *geode = new Geode; geode->setName("ClipPlane"); geode->addDrawable(geoset); StateSet *geostate = geode->getOrCreateStateSet(); geostate->setAttributeAndModes(mtl, StateAttribute::ON); geostate->setMode(GL_LIGHTING, StateAttribute::OFF); LineWidth *lineWidth = new LineWidth(3.0); geostate->setAttributeAndModes(lineWidth, StateAttribute::ON); geode->setStateSet(geostate); return geode; }
/*************************************************************** * Function: createFloorplanGeometry() ***************************************************************/ void VirtualScenicHandler::createFloorplanGeometry(const int numPages, CAVEAnimationModeler::ANIMPageEntry **pageEntryArray) { if (numPages <= 0) { return; } for (int i = 0; i < numPages; i++) { // create floorplan geometry float length = pageEntryArray[i]->mLength; float width = pageEntryArray[i]->mWidth; float altitude = pageEntryArray[i]->mAlti; Geode *floorplanGeode = new Geode; Geometry *floorplanGeometry = new Geometry; Vec3Array* vertices = new Vec3Array; Vec3Array* normals = new Vec3Array; Vec2Array* texcoords = new Vec2Array(4); vertices->push_back(Vec3(-length / 2, width / 2, altitude)); (*texcoords)[0].set(0, 1); vertices->push_back(Vec3(-length / 2, -width / 2, altitude)); (*texcoords)[1].set(0, 0); vertices->push_back(Vec3( length / 2, -width / 2, altitude)); (*texcoords)[2].set(1, 0); vertices->push_back(Vec3( length / 2, width / 2, altitude)); (*texcoords)[3].set(1, 1); for (int k = 0; k < 4; k++) { normals->push_back(Vec3(0, 0, 1)); } DrawElementsUInt* rectangle = new DrawElementsUInt(PrimitiveSet::POLYGON, 0); rectangle->push_back(0); rectangle->push_back(1); rectangle->push_back(2); rectangle->push_back(3); floorplanGeometry->addPrimitiveSet(rectangle); floorplanGeometry->setVertexArray(vertices); floorplanGeometry->setNormalArray(normals); floorplanGeometry->setTexCoordArray(0, texcoords); floorplanGeometry->setNormalBinding(Geometry::BIND_PER_VERTEX); floorplanGeode->addDrawable(floorplanGeometry); mFloorplanSwitch->addChild(floorplanGeode); /* load floorplan images */ Material *transmaterial = new Material; transmaterial->setDiffuse(Material::FRONT_AND_BACK, Vec4(1, 1, 1, 1)); transmaterial->setAlpha(Material::FRONT_AND_BACK, 1.0f); Image* imgFloorplan = osgDB::readImageFile(pageEntryArray[i]->mTexFilename); Texture2D* texFloorplan = new Texture2D(imgFloorplan); StateSet *floorplanStateSet = floorplanGeode->getOrCreateStateSet(); floorplanStateSet->setTextureAttributeAndModes(0, texFloorplan, StateAttribute::ON); floorplanStateSet->setMode(GL_BLEND, StateAttribute::OVERRIDE | StateAttribute::ON ); floorplanStateSet->setRenderingHint(StateSet::TRANSPARENT_BIN); floorplanStateSet->setAttributeAndModes(transmaterial, StateAttribute::OVERRIDE | StateAttribute::ON); } }
Node *makeSky( void ) { int i, j; float lev[] = { -5, -1.0, 1.0, 15.0, 30.0, 60.0, 90.0 }; float cc[][4] = { { 0.0, 0.0, 0.15 }, { 0.0, 0.0, 0.15 }, { 0.4, 0.4, 0.7 }, { 0.2, 0.2, 0.6 }, { 0.1, 0.1, 0.6 }, { 0.1, 0.1, 0.6 }, { 0.1, 0.1, 0.6 }, }; float x, y, z; float alpha, theta; float radius = 20.0f; int nlev = sizeof( lev )/sizeof(float); Geometry *geom = new Geometry; Vec3Array& coords = *(new Vec3Array(19*nlev)); Vec4Array& colors = *(new Vec4Array(19*nlev)); Vec2Array& tcoords = *(new Vec2Array(19*nlev)); int ci = 0; for( i = 0; i < nlev; i++ ) { for( j = 0; j <= 18; j++ ) { alpha = osg::DegreesToRadians(lev[i]); theta = osg::DegreesToRadians((float)(j*20)); x = radius * cosf( alpha ) * cosf( theta ); y = radius * cosf( alpha ) * -sinf( theta ); z = radius * sinf( alpha ); coords[ci][0] = x; coords[ci][1] = y; coords[ci][2] = z; colors[ci][0] = cc[i][0]; colors[ci][1] = cc[i][1]; colors[ci][2] = cc[i][2]; colors[ci][3] = 1.0; tcoords[ci][0] = (float)j/18.0; tcoords[ci][1] = (float)i/(float)(nlev-1); ci++; } } for( i = 0; i < nlev-1; i++ ) { DrawElementsUShort* drawElements = new DrawElementsUShort(PrimitiveSet::TRIANGLE_STRIP); drawElements->reserve(38); for( j = 0; j <= 18; j++ ) { drawElements->push_back((i+1)*19+j); drawElements->push_back((i+0)*19+j); } geom->addPrimitiveSet(drawElements); } geom->setVertexArray( &coords ); geom->setTexCoordArray( 0, &tcoords ); geom->setColorArray( &colors ); geom->setColorBinding( Geometry::BIND_PER_VERTEX ); Texture2D *tex = new Texture2D; tex->setImage(osgDB::readImageFile("Images/white.rgb")); StateSet *dstate = new StateSet; dstate->setTextureAttributeAndModes(0, tex, StateAttribute::OFF ); dstate->setTextureAttribute(0, new TexEnv ); dstate->setMode( GL_LIGHTING, StateAttribute::OFF ); dstate->setMode( GL_CULL_FACE, StateAttribute::ON ); // clear the depth to the far plane. osg::Depth* depth = new osg::Depth; depth->setFunction(osg::Depth::ALWAYS); depth->setRange(1.0,1.0); dstate->setAttributeAndModes(depth,StateAttribute::ON ); dstate->setRenderBinDetails(-2,"RenderBin"); geom->setStateSet( dstate ); Geode *geode = new Geode; geode->addDrawable( geom ); geode->setName( "Sky" ); return geode; }
/*************************************************************** * Function: ANIMCreateVirtualSphere() * ***************************************************************/ void ANIMCreateVirtualSphere(osg::PositionAttitudeTransform** xformScaleFwd, osg::PositionAttitudeTransform** xformScaleBwd) { // create sphere geometry *xformScaleFwd = new PositionAttitudeTransform; *xformScaleBwd = new PositionAttitudeTransform; Geode* sphereGeode = new Geode(); Sphere* virtualSphere = new Sphere(); Drawable* sphereDrawable = new ShapeDrawable(virtualSphere); virtualSphere->setRadius(ANIM_VIRTUAL_SPHERE_RADIUS); sphereGeode->addDrawable(sphereDrawable); (*xformScaleFwd)->addChild(sphereGeode); (*xformScaleBwd)->addChild(sphereGeode); osg::StateSet* stateset; // highlights /* Sphere* highlightSphere = new Sphere(); ShapeDrawable* highlightDrawable = new ShapeDrawable(highlightSphere); Geode* highlightGeode = new Geode(); highlightSphere->setRadius(ANIM_VIRTUAL_SPHERE_RADIUS * 1.3); highlightDrawable->setColor(osg::Vec4(0,0,1,0.3)); highlightGeode->addDrawable(highlightDrawable); (*xformScaleFwd)->addChild(highlightGeode); (*xformScaleBwd)->addChild(highlightGeode); stateset = highlightDrawable->getOrCreateStateSet(); stateset->setMode(GL_BLEND, StateAttribute::ON); stateset->setMode(GL_CULL_FACE, StateAttribute::ON); stateset->setMode(GL_LIGHTING, osg::StateAttribute::OFF); stateset->setRenderingHint(StateSet::TRANSPARENT_BIN); */ // set up the forward / backward scale animation path AnimationPath* animationPathScaleFwd = new AnimationPath; AnimationPath* animationPathScaleBwd = new AnimationPath; animationPathScaleFwd->setLoopMode(AnimationPath::NO_LOOPING); animationPathScaleBwd->setLoopMode(AnimationPath::NO_LOOPING); osg::Vec3 pos(-1.5, 0, 0); Vec3 scaleFwd, scaleBwd; float step = 1.f / ANIM_VIRTUAL_SPHERE_NUM_SAMPS; for (int i = 0; i < ANIM_VIRTUAL_SPHERE_NUM_SAMPS + 1; i++) { float val = i * step; scaleFwd = Vec3(val, val, val); scaleBwd = Vec3(1-val, 1-val, 1-val); animationPathScaleFwd->insert(val, AnimationPath::ControlPoint(pos, Quat(), scaleFwd)); animationPathScaleBwd->insert(val, AnimationPath::ControlPoint(pos, Quat(), scaleBwd)); } AnimationPathCallback *animCallbackFwd = new AnimationPathCallback(animationPathScaleFwd, 0.0, 1.f / ANIM_VIRTUAL_SPHERE_LAPSE_TIME); AnimationPathCallback *animCallbackBwd = new AnimationPathCallback(animationPathScaleBwd, 0.0, 1.f / ANIM_VIRTUAL_SPHERE_LAPSE_TIME); (*xformScaleFwd)->setUpdateCallback(animCallbackFwd); (*xformScaleBwd)->setUpdateCallback(animCallbackBwd); /* apply shaders to geode stateset */ stateset = new StateSet(); stateset->setMode(GL_BLEND, StateAttribute::OVERRIDE | StateAttribute::ON ); stateset->setRenderingHint(StateSet::TRANSPARENT_BIN); //sphereGeode->setStateSet(stateset); sphereDrawable->setStateSet(stateset); Program* shaderProg = new Program; stateset->setAttribute(shaderProg); shaderProg->addShader(Shader::readShaderFile(Shader::VERTEX, ANIMDataDir() + "Shaders/VirtualSphere.vert")); shaderProg->addShader(Shader::readShaderFile(Shader::FRAGMENT, ANIMDataDir() + "Shaders/VirtualSphere.frag")); Image* envMap = osgDB::readImageFile(ANIMDataDir() + "Textures/EnvMap.JPG"); Texture2D* envTex = new Texture2D(envMap); stateset->setTextureAttributeAndModes(0, envTex, StateAttribute::ON); Uniform* envMapSampler = new Uniform("EnvMap", 0); stateset->addUniform(envMapSampler); Uniform* baseColorUniform = new Uniform("BaseColor", Vec3(0.2, 1.0, 0.2)); stateset->addUniform(baseColorUniform); Uniform* lightPosUniform = new Uniform("LightPos", Vec4(1.0, 0.0, 0.2, 0.0)); stateset->addUniform(lightPosUniform); }
/*************************************************************** * Function: ANIMCreateSingleShapeSwitchAnimation() ***************************************************************/ void ANIMCreateSingleShapeSwitchAnimation(ANIMShapeSwitchEntry **shapeEntry, const CAVEGeodeShape::Type &typ) { PositionAttitudeTransform *flipUpFwdTrans = new PositionAttitudeTransform; PositionAttitudeTransform *flipDownFwdTrans = new PositionAttitudeTransform; PositionAttitudeTransform *flipUpBwdTrans = new PositionAttitudeTransform; PositionAttitudeTransform *flipDownBwdTrans = new PositionAttitudeTransform; (*shapeEntry)->mSwitch->addChild(flipUpFwdTrans); // child #0 (*shapeEntry)->mSwitch->addChild(flipDownFwdTrans); // child #1 (*shapeEntry)->mSwitch->addChild(flipUpBwdTrans); // child #2 (*shapeEntry)->mSwitch->addChild(flipDownBwdTrans); // child #3 (*shapeEntry)->mSwitch->setAllChildrenOff(); osg::Vec3 pos(0, 0, 0); /* create shape geode based on 'ANIMShapeSwitchEntry::Type' */ Geode *shapeGeode = new Geode; if (typ == CAVEGeodeShape::BOX) { Box *box = new Box(osg::Vec3(), ANIM_VIRTUAL_SPHERE_RADIUS / 0.9); shapeGeode->addDrawable(new ShapeDrawable(box)); } else if (typ == CAVEGeodeShape::CYLINDER) { float r = ANIM_VIRTUAL_SPHERE_RADIUS / 1.5; Cylinder *cylinder = new Cylinder(osg::Vec3(), r, r * 2); shapeGeode->addDrawable(new ShapeDrawable(cylinder)); } flipUpFwdTrans->addChild(shapeGeode); flipDownFwdTrans->addChild(shapeGeode); flipUpBwdTrans->addChild(shapeGeode); flipDownBwdTrans->addChild(shapeGeode); /* set up flip up / flip down animation paths for shape switch */ AnimationPath* animationFlipUpFwd = new AnimationPath; AnimationPath* animationFlipDownFwd = new AnimationPath; AnimationPath* animationFlipUpBwd = new AnimationPath; AnimationPath* animationFlipDownBwd = new AnimationPath; animationFlipUpFwd->setLoopMode(AnimationPath::NO_LOOPING); animationFlipDownFwd->setLoopMode(AnimationPath::NO_LOOPING); animationFlipUpBwd->setLoopMode(AnimationPath::NO_LOOPING); animationFlipDownBwd->setLoopMode(AnimationPath::NO_LOOPING); Vec3 scaleUpVect, scaleDownVect; Quat flipUpFwdQuat, flipDownFwdQuat, flipUpBwdQuat, flipDownBwdQuat; float timestep = ANIM_GEOMETRY_CREATOR_SHAPE_FLIP_TIME / ANIM_GEOMETRY_CREATOR_SHAPE_FLIP_SAMPS; float scalestep = 1.f / ANIM_GEOMETRY_CREATOR_SHAPE_FLIP_SAMPS; float anglestep = M_PI * 0.5 / ANIM_GEOMETRY_CREATOR_SHAPE_FLIP_SAMPS; if (typ == CAVEGeodeShape::BOX) pos[2] -= 0.5; else if (typ == CAVEGeodeShape::CYLINDER) pos[2] -= 1.0; osg::Vec3 diff, startPos(0,0,0), fwd, bwd; for (int i = 0; i < ANIM_GEOMETRY_CREATOR_SHAPE_FLIP_SAMPS + 1; i++) { float t = i * timestep; float val = i * scalestep; scaleUpVect = Vec3(val, val, val); scaleDownVect = Vec3(1.f-val, 1.f-val, 1.f-val); flipUpFwdQuat = Quat(i * anglestep - M_PI / 2, Vec3(1, 0, 0)); flipDownFwdQuat = Quat(i * anglestep, Vec3(1, 0, 0)); flipUpBwdQuat = Quat(i * anglestep - M_PI / 2, Vec3(-1, 0, 0)); flipDownBwdQuat = Quat(i * anglestep, Vec3(-1, 0, 0)); diff = startPos - pos; for (int j = 0; j < 3; ++j) diff[j] *= val; fwd = startPos - diff; bwd = pos + diff; animationFlipUpFwd->insert(t, AnimationPath::ControlPoint(fwd, flipUpFwdQuat, scaleUpVect)); animationFlipDownFwd->insert(t, AnimationPath::ControlPoint(fwd, flipDownFwdQuat, scaleUpVect)); animationFlipUpBwd->insert(t, AnimationPath::ControlPoint(bwd, flipUpBwdQuat, scaleDownVect)); animationFlipDownBwd->insert(t, AnimationPath::ControlPoint(bwd, flipDownBwdQuat, scaleDownVect)); } AnimationPathCallback *animCallbackFlipUpFwd = new AnimationPathCallback(animationFlipUpFwd, 0.0, 1.f / ANIM_GEOMETRY_CREATOR_SHAPE_FLIP_TIME); AnimationPathCallback *animCallbackFlipDownFwd = new AnimationPathCallback(animationFlipDownFwd, 0.0, 1.f / ANIM_GEOMETRY_CREATOR_SHAPE_FLIP_TIME); AnimationPathCallback *animCallbackFlipUpBwd = new AnimationPathCallback(animationFlipUpBwd, 0.0, 1.f / ANIM_GEOMETRY_CREATOR_SHAPE_FLIP_TIME); AnimationPathCallback *animCallbackFlipDownBwd = new AnimationPathCallback(animationFlipDownBwd, 0.0, 1.f / ANIM_GEOMETRY_CREATOR_SHAPE_FLIP_TIME); flipUpFwdTrans->setUpdateCallback(animCallbackFlipUpFwd); flipDownFwdTrans->setUpdateCallback(animCallbackFlipDownFwd); flipUpBwdTrans->setUpdateCallback(animCallbackFlipUpBwd); flipDownBwdTrans->setUpdateCallback(animCallbackFlipDownBwd); /* write into shape switch entry array record*/ (*shapeEntry)->mFlipUpFwdAnim = animCallbackFlipUpFwd; (*shapeEntry)->mFlipDownFwdAnim = animCallbackFlipDownFwd; (*shapeEntry)->mFlipUpBwdAnim = animCallbackFlipUpBwd; (*shapeEntry)->mFlipDownBwdAnim = animCallbackFlipDownBwd; }
/*************************************************************** * Function: ANIMCreateRefSkyDome() * ***************************************************************/ MatrixTransform *ANIMCreateRefSkyDome(StateSet **stateset) { /* sky dome geometry */ Sphere *skyShape = new Sphere(); ShapeDrawable* skyDrawable = new ShapeDrawable(skyShape); Geode* skyGeode = new Geode(); MatrixTransform *skyDomeTrans = new MatrixTransform; //osg::Matrix m; //m.makeRotate(osg::Quat(M_PI/2, osg::Vec3(0, 1, 0))); //skyDomeTrans->setMatrix(m); skyShape->setRadius(ANIM_SKYDOME_RADIUS); skyGeode->addDrawable(skyDrawable); skyDomeTrans->addChild(skyGeode); // apply simple colored materials Material* material = new Material; material->setDiffuse(Material::FRONT_AND_BACK, Vec4(1.0f, 1.0f, 1.0f, 1.0f)); material->setAlpha(Material::FRONT_AND_BACK, 1.0f); (*stateset) = new StateSet(); (*stateset)->setAttributeAndModes(material, StateAttribute::OVERRIDE | StateAttribute::ON); (*stateset)->setMode(GL_BLEND, StateAttribute::OVERRIDE | StateAttribute::ON ); (*stateset)->setRenderingHint(StateSet::TRANSPARENT_BIN); skyGeode->setStateSet(*stateset); // skyGeode->setNodeMask(0xFFFFFF & ~(0x2 | 0x3)); // load sky dome shader Uniform* sunrUniform = new Uniform("hazeRadisuMin", 0.975f); (*stateset)->addUniform(sunrUniform); Uniform* sunRUniform = new Uniform("hazeRadisuMax", 0.995f); (*stateset)->addUniform(sunRUniform); Uniform* sunDirUniform = new Uniform("sundir", Vec4(0.0, 0.0, 1.0, 1.0)); (*stateset)->addUniform(sunDirUniform); Uniform* suncolorUniform = new Uniform("suncolor", Vec4(1.0, 1.0, 1.0, 1.0)); (*stateset)->addUniform(suncolorUniform); Uniform* skycolorUniform = new Uniform("skycolor", Vec4(0.5, 0.5, 1.0, 1.0)); (*stateset)->addUniform(skycolorUniform); Uniform* skyfadingcolorUniform = new Uniform("skyfadingcolor", Vec4(0.8, 0.8, 0.8, 1.0)); (*stateset)->addUniform(skyfadingcolorUniform); Uniform* skymaskingcolorUniform = new Uniform("skymaskingcolor", Vec4(1.0, 1.0, 1.0, 1.0)); (*stateset)->addUniform(skymaskingcolorUniform); Uniform *matShaderToWorldUniform = new Uniform("shaderToWorldMat", Matrixd()); (*stateset)->addUniform(matShaderToWorldUniform); Image* imageSky = osgDB::readImageFile(ANIMDataDir() + "Textures/NightSky.JPG"); Texture2D* textureSky = new Texture2D(imageSky); (*stateset)->setTextureAttributeAndModes(0, textureSky, StateAttribute::ON); Image* imagePara = osgDB::readImageFile(ANIMDataDir() + "Textures/Paramounts/Paramount00.JPG"); Texture2D* texturePara = new Texture2D(imagePara); (*stateset)->setTextureAttributeAndModes(1, texturePara, StateAttribute::ON); Uniform* skyNightSampler = new Uniform("texNightSky", 0); (*stateset)->addUniform(skyNightSampler); Uniform* paraImageTextureSampler = new Uniform("texParamount", 1); (*stateset)->addUniform(paraImageTextureSampler); Program* programSky = new Program; (*stateset)->setAttribute(programSky); programSky->addShader(Shader::readShaderFile(Shader::VERTEX, ANIMDataDir() + "Shaders/EnvSky.vert")); programSky->addShader(Shader::readShaderFile(Shader::FRAGMENT, ANIMDataDir() + "Shaders/EnvSky.frag")); return skyDomeTrans; }
void Lwo2Layer::GenerateGeode( Geode& geode, short tags_count, DrawableToTagMapping& tag_mapping) { OSG_DEBUG; // variable used to track using textures bool have_texture_coords; // create diffirent geomerty for each tag for (short current_tag = 0; current_tag < tags_count; current_tag++) { have_texture_coords = false; // new geometry ref_ptr<Geometry> geometry = new Geometry; // create coords array ref_ptr<Vec3Array> coords = new Vec3Array; // create texture array ref_ptr<Vec2Array> texcoords = new Vec2Array; // selecting polygons for current layer only int polygon_index = 0; PolygonsList polygons; IteratorPolygonsList polygon_iterator; for (polygon_iterator = _polygons.begin(); polygon_iterator != _polygons.end(); polygon_iterator++, polygon_index++) { // *polygon_iterator it's a PolygonsList // polygons of current tag only if (_polygons_tag[polygon_index] == current_tag) { // reset point_index member for later comparing poins data PointsList points_list = *polygon_iterator; for (unsigned int i = 0; i < points_list.size(); i++) { points_list[i].point_index = 0; } polygons.push_back(*polygon_iterator); } } // find and compose triangle fans PolygonsList triangle_fans; _find_triangle_fans(polygons, triangle_fans); // find and compose triangle strips PolygonsList triangle_strips; _find_triangle_strips(polygons, triangle_strips); // polygons of current layer polygon_index = 0; for (polygon_iterator = polygons.begin(); polygon_iterator != polygons.end(); polygon_iterator++, polygon_index++) { if ((*polygon_iterator)[0].point_index != -1) { // all points of polygon for (IteratorPoint itr = (*polygon_iterator).begin(); itr != (*polygon_iterator).end(); itr++) { // *itr - it's a PointData // polygons data (*coords).push_back((*itr).coord); (*texcoords).push_back((*itr).texcoord); if ((*itr).texcoord.x() != -1.0f || (*itr).texcoord.y() != -1.0f) { have_texture_coords = true; } } unsigned int points_start = (*coords).size() - (*polygon_iterator).size(); unsigned int points_count = (*polygon_iterator).size(); if (points_count == 3) { geometry->addPrimitiveSet(new DrawArrays(PrimitiveSet::TRIANGLES, points_start, points_count)); } else if (points_count == 4) { geometry->addPrimitiveSet(new DrawArrays(PrimitiveSet::QUADS, points_start, points_count)); } else { geometry->addPrimitiveSet(new DrawArrays(PrimitiveSet::POLYGON, points_start, points_count)); } } } // triangle fans of current layer polygon_index = 0; for (polygon_iterator = triangle_fans.begin(); polygon_iterator != triangle_fans.end(); polygon_iterator++, polygon_index++) { // all points of polygon for (IteratorPoint itr = (*polygon_iterator).begin(); itr != (*polygon_iterator).end(); itr++) { // *itr - it's a PointData // polygons data (*coords).push_back((*itr).coord); (*texcoords).push_back((*itr).texcoord); if ((*itr).texcoord.x() != -1.0f || (*itr).texcoord.y() != -1.0f) { have_texture_coords = true; } } unsigned int points_start = (*coords).size() - (*polygon_iterator).size(); unsigned int points_count = (*polygon_iterator).size(); geometry->addPrimitiveSet(new DrawArrays(PrimitiveSet::TRIANGLE_FAN, points_start, points_count)); } // triangle strips of current layer polygon_index = 0; for (polygon_iterator = triangle_strips.begin(); polygon_iterator != triangle_strips.end(); polygon_iterator++, polygon_index++) { // all points of polygon for (IteratorPoint itr = (*polygon_iterator).begin(); itr != (*polygon_iterator).end(); itr++) { // *itr - it's a PointData // polygons data (*coords).push_back((*itr).coord); (*texcoords).push_back((*itr).texcoord); if ((*itr).texcoord.x() != -1.0f || (*itr).texcoord.y() != -1.0f) { have_texture_coords = true; } } unsigned int points_start = (*coords).size() - (*polygon_iterator).size(); unsigned int points_count = (*polygon_iterator).size(); geometry->addPrimitiveSet(new DrawArrays(PrimitiveSet::TRIANGLE_STRIP, points_start, points_count)); } // add geometry if it contains any points if (coords->size() != 0) { geometry->setVertexArray(coords.get()); // assign texture array if (have_texture_coords) { geometry->setTexCoordArray(0, texcoords.get()); } // generate normals osgUtil::SmoothingVisitor smoother; smoother.smooth(*(geometry.get())); geode.addDrawable(geometry.get()); OSG_DEBUG << " inserting tag " << geode.getNumDrawables() - 1 << ":" << current_tag << std::endl; tag_mapping.insert(PairDrawableToTag(geode.getNumDrawables() - 1, current_tag)); } } }
Node *makeTank( void ) { Geode *geode = new Geode; getDatabaseCenterRadius( dbcenter, &dbradius ); Matrix mat( 0.05, 0, 0, 0, 0, 0.05, 0, 0, 0, 0, 0.05, 0, 1.5999 - 0.3, 3.1474, dbcenter[2] + 0.6542 - 0.09, 1 ); // 42 required for sides, 22 for the top. Vec3Array& vc = *(new Vec3Array(42+22)); Vec2Array& tc = *(new Vec2Array(42+22)); Geometry *gset = new Geometry; gset->setVertexArray( &vc ); gset->setTexCoordArray( 0, &tc ); // create the sides of the tank. unsigned int i, c = 0; for( i = 0; i <= 360; i += 18 ) { float x, y, z; float s, t; float theta = osg::DegreesToRadians((float)i); s = (float)i/90.0; t = 1.0; x = radius * cosf( theta ); y = radius * sinf( theta ); z = 1.0; vc[c][0] = x; vc[c][1] = y; vc[c][2] = z; tc[c][0] = s; tc[c][1] = t; c++; t = 0.0; z = 0.0; vc[c][0] = x; vc[c][1] = y; vc[c][2] = z; tc[c][0] = s; tc[c][1] = t; c++; } gset->addPrimitiveSet( new DrawArrays(PrimitiveSet::TRIANGLE_STRIP,0,c) ); // create the top of the tank. int prev_c = c; vc[c][0] = 0.0f; vc[c][1] = 0.0f; vc[c][2] = 1.0f; tc[c][0] = 0.0f; tc[c][1] = 0.0f; c++; for( i = 0; i <= 360; i += 18 ) { float x, y, z; float s, t; float theta = osg::DegreesToRadians((float)i); // s = (float)i/360.0; // t = 1.0; s = cosf( theta ); t = sinf( theta ); x = radius * cosf( theta ); y = radius * sinf( theta ); z = 1.0; vc[c][0] = x; vc[c][1] = y; vc[c][2] = z; tc[c][0] = s; tc[c][1] = t; c++; } for( i = 0; i < c; i++ ) conv( vc[i], mat, vc[i] ); gset->addPrimitiveSet(new DrawArrays(PrimitiveSet::TRIANGLE_FAN,prev_c,c-prev_c)); Texture2D *tex = new Texture2D; tex->setWrap( Texture2D::WRAP_S, Texture2D::REPEAT ); tex->setWrap( Texture2D::WRAP_T, Texture2D::REPEAT ); tex->setImage(osgDB::readImageFile("Images/tank.rgb")); StateSet *dstate = new StateSet; dstate->setTextureAttributeAndModes(0, tex, StateAttribute::ON ); dstate->setTextureAttribute(0, new TexEnv ); gset->setStateSet( dstate ); geode->addDrawable( gset ); return geode; }
osg::Node *JTOpenPlugin::createShape(JtkShape *partShape, const char *objName) { //cout << "JtkSHAPE\n"; Geode *geode = new Geode(); ref_ptr<Geometry> geom = new Geometry(); StateSet *geoState = geode->getOrCreateStateSet(); Vec3Array *vert = new Vec3Array; Vec3Array *normalArray = new Vec3Array(); Vec3Array *colorArray = new Vec3Array(); Vec2Array *tcArray = new Vec2Array(); DrawArrayLengths *primitives = NULL; if (partShape->typeID() == JtkEntity::JtkPOLYGONSET) { primitives = new DrawArrayLengths(PrimitiveSet::POLYGON); } else if (partShape->typeID() == JtkEntity::JtkLINESTRIPSET) { primitives = new DrawArrayLengths(PrimitiveSet::LINE_STRIP); } else if (partShape->typeID() == JtkEntity::JtkTRISTRIPSET) { primitives = new DrawArrayLengths(PrimitiveSet::TRIANGLE_STRIP); } else { cerr << "unknown partShape->typeID " << partShape->typeID() << endl; } geode->setName(objName); if (primitives) { for (int set = 0; set < partShape->numOfSets(); set++) { float *vertex = NULL, *normal = NULL, *color = NULL, *texture = NULL; int vertexCount = -1, normCount = -1, colorCount = -1, textCount = -1; partShape->getInternal(vertex, vertexCount, normal, normCount, color, colorCount, texture, textCount, set); primitives->push_back(vertexCount); // backFaceCulling nur dann, wenn es im CoviseConfig enabled ist /*if(backFaceCulling && (mask & Viewer::MASK_SOLID)) { CullFace *cullFace = new CullFace(); // da viele Modelle backface Culling nicht vertragen (nicht richtig modelliert sind) cullFace->setMode(CullFace::BACK); geoState->setAttributeAndModes(cullFace, StateAttribute::ON); } // already done in updateMaterial() #if 0 if(Blended) { BlendFunc *blendFunc = new BlendFunc(); blendFunc->setFunction(BlendFunc::SRC_ALPHA, BlendFunc::ONE_MINUS_SRC_ALPHA); geoState->setAttributeAndModes(blendFunc, StateAttribute::ON); #if 1 AlphaFunc *alphaFunc = new AlphaFunc(); alphaFunc->setFunction(AlphaFunc::ALWAYS,1.0); geoState->setAttributeAndModes(alphaFunc, StateAttribute::OFF); #endif } #endif #ifdef HAVE_OSGNV if((strncmp(d_currentObject->node->name(),"combineTextures",15)==0)||(strncmp(objName,"combineTextures",15)==0)) { geoState->setAttributeAndModes(combineTextures.get(), StateAttribute::ON); } if((strncmp(d_currentObject->node->name(),"combineEnvTextures",15)==0)||(strncmp(objName,"combineEnvTextures",15)==0)) { geoState->setAttributeAndModes(combineEnvTextures.get(), StateAttribute::ON); } #endif*/ if (vertex && (vertexCount > 0)) { for (int elems = 0; elems < vertexCount; elems++) { vert->push_back(Vec3(vertex[elems * 3 + 0], vertex[elems * 3 + 1], vertex[elems * 3 + 2])); } JtkEntityFactory::deleteMemory(vertex); } if (normal && (normCount > 0)) { for (int elems = 0; elems < normCount; elems++) { normalArray->push_back(Vec3(normal[elems * 3 + 0], normal[elems * 3 + 1], normal[elems * 3 + 2])); } if (normCount == vertexCount) { } else { //geom->setNormalBinding(Geometry::BIND_PER_PRIMITIVE); std::cerr << "JTOpen: normals per primitive not supported" << std::endl; } JtkEntityFactory::deleteMemory(normal); } else // generate normals { } if (color && (colorCount > 0)) { for (int elems = 0; elems < colorCount; elems++) { colorArray->push_back(Vec3(color[elems * 3 + 0], color[elems * 3 + 1], color[elems * 3 + 2])); } if (colorCount == vertexCount) { } else { //geom->setColorBinding(Geometry::BIND_PER_PRIMITIVE); std::cerr << "JTOpen: colors per primitive not supported" << std::endl; } JtkEntityFactory::deleteMemory(color); } if (texture && (textCount > 0)) { for (int elems = 0; elems < textCount; elems++) { tcArray->push_back(Vec2(texture[elems * 2 + 0], texture[elems * 2 + 1])); } JtkEntityFactory::deleteMemory(texture); } /* if(!(mask & Viewer::MASK_CONVEX)) { osgUtil::Tesselator *tess = new osgUtil::Tesselator; tess->retesselatePolygons(*geom); //delete[] tess; }*/ // if enabled, generate tri strips, but not for animated objects // if(genStrips && strncmp(objName, "Animated", 8)) { // d_stripper->stripify(*geom); } } geom->setVertexArray(vert); geom->addPrimitiveSet(primitives); if (normalArray->size() > 0) { geom->setNormalArray(normalArray); geom->setNormalBinding(Geometry::BIND_PER_VERTEX); } if (colorArray->size() > 0) { geom->setColorArray(colorArray); geom->setColorBinding(Geometry::BIND_PER_VERTEX); } if (tcArray->size() > 0) geom->setTexCoordArray(0, tcArray); if (normalArray->size() == 0) { osgUtil::SmoothingVisitor::smooth(*(geom.get()), 40.0 / 180.0 * M_PI); } geode->addDrawable(geom.get()); geode->setStateSet(geoState); return geode; } return NULL; }
void OsgChromosome::renderChromosome(char * file){ Sphere * mysphere; ShapeDrawable * mydrawable; Geode* mygeode = new Geode(); osg::ref_ptr<osg::Material> pMaterial; ifstream myReadFile; SceneObject * so = new SceneObject(file, true, true, true, true, false); PluginHelper::registerSceneObject(so); so->attachToScene(); so->setNavigationOn(true); so->addMoveMenuItem(); so->addNavigationMenuItem(); // open file to read myReadFile.open(file); string chr, start, end, comp, x, y, z, output; Vec3 prev, curr; Vec4 color; bool isFirst = true; if (myReadFile.is_open()) { printf("is open\n"); // get rid of top line getline(myReadFile, output); // read each table entry while (!myReadFile.eof()) { myReadFile >> chr; myReadFile >> start; myReadFile >> end; myReadFile >> comp; myReadFile >> x; myReadFile >> y; myReadFile >> z; curr = Vec3(atof(x.c_str()), atof(y.c_str()), atof(z.c_str())); mysphere = new Sphere(curr, .02); mydrawable = new ShapeDrawable(mysphere); mygeode = new Geode(); mygeode->addDrawable(mydrawable); so->addChild(mygeode); //root->addChild(mygeode); // determine the color of the segment pMaterial = new osg::Material; if (comp.compare("A") == 0) color = Vec4(1,0,0,1); else if (comp.compare("B") == 0) color = Vec4(0,0,1,1); else color = Vec4(0,1,0,1); // set the color of the sphere pMaterial->setDiffuse( osg::Material::FRONT, color); mygeode->getOrCreateStateSet()->setAttribute( pMaterial, osg::StateAttribute::OVERRIDE ); // draw the cylinder bewtween spheres if (!isFirst) { //mygeode = new Geode(); AddCylinderBetweenPoints(prev, curr, (float) .02, color, so/*(Group *) root*/); //root->addChild(mygeode); } prev = curr; isFirst = false; } printf("get attached is %d, number of children is %d\n", so->getAttached(), so->getNumChildObjects()); }
PositionAttitudeTransform *VideoGeode::createVideoPlane(float sizeX, float sizeY, bool texRepeat) { // vertex array Vec3Array *vertexArray = new Vec3Array(); sizeX /= 2.0; sizeY /= 2.0; vertexArray->push_back(Vec3(-sizeX, 0, -sizeY)); vertexArray->push_back(Vec3(sizeX, 0, -sizeY)); vertexArray->push_back(Vec3(sizeX, 0, sizeY)); vertexArray->push_back(Vec3(-sizeX, 0, sizeY)); /*vertexArray->push_back(Vec3(-sizeX, -sizeY, 0)); vertexArray->push_back(Vec3(sizeX, -sizeY, 0)); vertexArray->push_back(Vec3(sizeX, sizeY, 0)); vertexArray->push_back(Vec3(-sizeX, sizeY, 0));*/ // face array DrawElementsUInt *faceArray = new DrawElementsUInt(PrimitiveSet::TRIANGLES, 0); faceArray->push_back(0); // face 1 faceArray->push_back(1); faceArray->push_back(2); faceArray->push_back(2); // face 2 faceArray->push_back(3); faceArray->push_back(0); // normal array Vec3Array *normalArray = new Vec3Array(); normalArray->push_back(Vec3(0, 0, 1)); // normal index TemplateIndexArray<unsigned int, Array::UIntArrayType, 24, 4> *normalIndexArray; normalIndexArray = new TemplateIndexArray<unsigned int, Array::UIntArrayType, 24, 4>(); normalIndexArray->push_back(0); normalIndexArray->push_back(0); normalIndexArray->push_back(0); normalIndexArray->push_back(0); // texture coordinates Vec2Array *texCoords = new Vec2Array(); texCoords->push_back(Vec2(0.0f, 0.0f)); texCoords->push_back(Vec2(1.0f, 0.0f)); texCoords->push_back(Vec2(1.0f, 1.0f)); texCoords->push_back(Vec2(0.0f, 1.0f)); Geometry *geometry = new Geometry(); geometry->setVertexArray(vertexArray); geometry->setNormalArray(normalArray); geometry->setNormalIndices(normalIndexArray); geometry->setNormalBinding(Geometry::BIND_PER_VERTEX); geometry->setTexCoordArray(0, texCoords); geometry->addPrimitiveSet(faceArray); Geode *plane = new Geode(); plane->addDrawable(geometry); // assign the material to the sphere StateSet *planeStateSet = plane->getOrCreateStateSet(); planeStateSet->ref(); planeStateSet->setAttribute(_material); try { planeStateSet->setTextureAttributeAndModes(0, createVideoTexture(texRepeat), StateAttribute::ON); } catch (char *e) { throw e; } PositionAttitudeTransform *planeTransform = new PositionAttitudeTransform(); planeTransform->addChild(plane); return planeTransform; }
Node *makeTerrain( void ) { int m, n; int i, j; float dbcenter[3]; float dbradius; getDatabaseCenterRadius( dbcenter, &dbradius ); m = (sizeof( vertex ) /(sizeof( float[3])))/39; n = 39; Vec3Array& v = *(new Vec3Array(m*n)); Vec2Array& t = *(new Vec2Array(m*n)); Vec4Array& col = *(new Vec4Array(1)); col[0][0] = col[0][1] = col[0][2] = col[0][3] = 1.0f; for( i = 0; i < m * n; i++ ) { float* vc = vertex[i]; v[i][0] = vc[0] - dbcenter[0]; v[i][1] = vc[1] - dbcenter[1]; v[i][2] = vc[2]; float* tc = texcoord[i]; t[i][0] = tc[0]; t[i][1] = tc[1]; } Geometry *geom = new Geometry; geom->setVertexArray( &v ); geom->setTexCoordArray( 0, &t ); geom->setColorArray( &col, Array::BIND_OVERALL ); for( i = 0; i < m-2; i++ ) { DrawElementsUShort* elements = new DrawElementsUShort(PrimitiveSet::TRIANGLE_STRIP); elements->reserve(39*2); for( j = 0; j < n; j++ ) { elements->push_back((i+0)*n+j); elements->push_back((i+1)*n+j); } geom->addPrimitiveSet(elements); } Texture2D *tex = new Texture2D; tex->setImage(osgDB::readRefImageFile("Images/lz.rgb")); StateSet *dstate = new StateSet; dstate->setMode( GL_LIGHTING, StateAttribute::OFF ); dstate->setTextureAttributeAndModes(0, tex, StateAttribute::ON ); dstate->setTextureAttribute(0, new TexEnv ); geom->setStateSet( dstate ); Geode *geode = new Geode; geode->addDrawable( geom ); return geode; }