def createPyramid(): pyramidGeode = osg.Geode() pyramidGeometry = osg.Geometry() pyramidGeode.addDrawable(pyramidGeometry) # Specify the vertices: pyramidVertices = osg.Vec3Array() pyramidVertices.append(osg.Vec3(0, 0, 0)) # front left pyramidVertices.append(osg.Vec3(2, 0, 0)) # front right pyramidVertices.append(osg.Vec3(2, 2, 0)) # back right pyramidVertices.append(osg.Vec3(0, 2, 0)) # back left pyramidVertices.append(osg.Vec3(1, 1, 2)) # peak # Associate this set of vertices with the geometry associated with the # geode we added to the scene. pyramidGeometry.setVertexArray(pyramidVertices) # Create a QUAD primitive for the base by specifying the # vertices from our vertex list that make up this QUAD: pyramidBase = osg.DrawElementsUInt(osg.PrimitiveSet.QUADS, 0) pyramidBase.append(3) pyramidBase.append(2) pyramidBase.append(1) pyramidBase.append(0) # Add this primitive to the geometry: # pyramidGeometry.addPrimitiveSet(pyramidBase) # code to create other faces goes here! pyramidGeometry.addPrimitiveSet(pyramidBase) # Repeat the same for each of the four sides. Again, vertices are specified in counter-clockwise order. pyramidFaceOne = osg.DrawElementsUInt(osg.PrimitiveSet.TRIANGLES, 0) pyramidFaceOne.append(0) pyramidFaceOne.append(1) pyramidFaceOne.append(4) pyramidGeometry.addPrimitiveSet(pyramidFaceOne) pyramidFaceTwo = osg.DrawElementsUInt(osg.PrimitiveSet.TRIANGLES, 0) pyramidFaceTwo.append(1) pyramidFaceTwo.append(2) pyramidFaceTwo.append(4) pyramidGeometry.addPrimitiveSet(pyramidFaceTwo) pyramidFaceThree = osg.DrawElementsUInt(osg.PrimitiveSet.TRIANGLES, 0) pyramidFaceThree.append(2) pyramidFaceThree.append(3) pyramidFaceThree.append(4) pyramidGeometry.addPrimitiveSet(pyramidFaceThree) pyramidFaceFour = osg.DrawElementsUInt(osg.PrimitiveSet.TRIANGLES, 0) pyramidFaceFour.append(3) pyramidFaceFour.append(0) pyramidFaceFour.append(4) pyramidGeometry.addPrimitiveSet(pyramidFaceFour) colors = osg.Vec4Array() colors.append(osg.Vec4(1.0, 0.0, 0.0, 1.0)) #index 0 red colors.append(osg.Vec4(0.0, 1.0, 0.0, 1.0)) #index 1 green colors.append(osg.Vec4(0.0, 0.0, 1.0, 1.0)) #index 2 blue colors.append(osg.Vec4(1.0, 1.0, 1.0, 1.0)) #index 3 white colors.append(osg.Vec4(1.0, 0.0, 0.0, 1.0)) #index 4 red pyramidGeometry.setColorArray(colors) pyramidGeometry.setColorBinding(osg.Geometry.BIND_PER_VERTEX) # Since the mapping from vertices to texture coordinates is 1:1, # we don't need to use an index array to map vertices to texture # coordinates. We can do it directly with the 'setTexCoordArray' # method of the Geometry class. # This method takes a variable that is an array of two dimensional # vectors (osg.Vec2). This variable needs to have the same # number of elements as our Geometry has vertices. Each array element # defines the texture coordinate for the cooresponding vertex in the # vertex array. texcoords = osg.Vec2Array(5) texcoords[0].set(0.00, 0.0) # tex coord for vertex 0 texcoords[1].set(0.25, 0.0) # tex coord for vertex 1 texcoords[2].set(0.50, 0.0) # "" texcoords[3].set(0.75, 0.0) # "" texcoords[4].set(0.50, 1.0) # "" pyramidGeometry.setTexCoordArray(0, texcoords) return pyramidGeode
animationPath = osg.AnimationPath() animationPath.insert(0.0,osg.AnimationPath.ControlPoint(bb.corner(0))) animationPath.insert(1.0,osg.AnimationPath.ControlPoint(bb.corner(1))) animationPath.insert(2.0,osg.AnimationPath.ControlPoint(bb.corner(2))) animationPath.insert(3.0,osg.AnimationPath.ControlPoint(bb.corner(3))) animationPath.insert(4.0,osg.AnimationPath.ControlPoint(bb.corner(4))) animationPath.insert(5.0,osg.AnimationPath.ControlPoint(bb.corner(5))) animationPath.insert(6.0,osg.AnimationPath.ControlPoint(bb.corner(6))) animationPath.insert(7.0,osg.AnimationPath.ControlPoint(bb.corner(7))) animationPath.insert(8.0,osg.AnimationPath.ControlPoint(bb.corner(0))) animationPath.setLoopMode(osg.AnimationPath.SWING) mt.setUpdateCallback(osg.AnimationPathCallback(animationPath)) # create marker for point light. marker = osg.Geometry() vertices = osg.Vec3Array() vertices.push_back(osg.Vec3(0.0,0.0,0.0)) marker.setVertexArray(vertices) marker.addPrimitiveSet(osg.DrawArrays(GL_POINTS,0,1)) stateset = osg.StateSet() point = osg.Point() point.setSize(4.0) stateset.setAttribute(point) marker.setStateSet(stateset) markerGeode = osg.Geode() markerGeode.addDrawable(marker)
createGrid = False if createGrid : grid = osg.HeightField() grid.allocate(numColumns,numRows) grid.setOrigin(origin) grid.setXInterval(size.x()/(float)(numColumns-1)) grid.setYInterval(size.y()/(float)(numRows-1)) for(r=0r<numRows++r) for(c=0c<numColumns++c) grid.setHeight(c,r,(vertex[r+c*numRows][2]-min_z)*scale_z) geode.addDrawable(osg.ShapeDrawable(grid)) else: geometry = osg.Geometry() v = *(osg.Vec3Array(numColumns*numRows)) t = *(osg.Vec2Array(numColumns*numRows)) color = *(osg.Vec4ubArray(1)) color[0].set(255,255,255,255) rowCoordDelta = size.y()/(float)(numRows-1) columnCoordDelta = size.x()/(float)(numColumns-1) rowTexDelta = 1.0/(float)(numRows-1) columnTexDelta = 1.0/(float)(numColumns-1) pos = origin tex = osg.Vec2(0.0,0.0)
vertices = osg.Vec3Array(numVertices) for(int j=0 j<_height ++j) for(int i=0 i<_width ++i) (*vertices)[i+j*_width].set(float(i),float(j),0.0) numIndices = (_width-1) * (_height-1) * 4 quads = osg.DrawElementsUShort(GL_QUADS) quads.reserve(numIndices) for(int j=0 j<_height-1 ++j) for(int i=0 i<_width-1 ++i) quads.push_back(i + j*_width) quads.push_back(i+1 + j*_width) quads.push_back(i+1 + (j+1)*_width) quads.push_back(i + (j+1)*_width) geometry = osg.Geometry() geometry.setVertexArray(vertices) geometry.addPrimitiveSet(quads) switch(_glObjectType) case(VERTEX_ARRAY): geometry.setUseDisplayList(False) geometry.setUseVertexBufferObjects(False) break case(DISPLAY_LIST): geometry.setUseDisplayList(True) geometry.setUseVertexBufferObjects(False) break case(VERTEX_BUFFER_OBJECT): geometry.setUseDisplayList(False) geometry.setUseVertexBufferObjects(True)
# same trick for shared normal. shared_normals = osg.Vec3Array() shared_normals.push_back(osg.Vec3(0.0,-1.0,0.0)) # Note on vertex ordering. # According to the OpenGL diagram vertices should be specified in a clockwise direction. # In reality you need to specify coords for polygons in a anticlockwise direction # for their front face to be pointing towards you get this wrong and you could # find back face culling removing the wrong faces of your models. The OpenGL diagram # is just plain wrong, but it's a nice diagram so we'll keep it for now not # create POLYGON # create Geometry object to store all the vertices and lines primitive. polyGeom = osg.Geometry() # this time we'll use C arrays to initialize the vertices. # note, anticlockwise ordering. # note II, OpenGL polygons must be convex, planar polygons, otherwise # undefined results will occur. If you have concave polygons or ones # that cross over themselves then use the osgUtil.Tessellator to fix # the polygons into a set of valid polygons. osg.Vec3 myCoords[] = osg.Vec3(-1.0464, 0.0, -0.193626), osg.Vec3(-1.0258, 0.0, -0.26778), osg.Vec3(-0.807461, 0.0, -0.181267), osg.Vec3(-0.766264, 0.0, -0.0576758), osg.Vec3(-0.980488, 0.0, -0.094753)
def createModel(shader, textureFileName, terrainFileName, dynamic, useVBO): geode = osg.Geode() geom = osg.Geometry() geode.addDrawable(geom) # dimensions for ~one million triangles :-) num_x = 708 num_y = 708 # set up state stateset = geom.getOrCreateStateSet() program = osg.Program() stateset.setAttribute(program) if shader=="simple" : vertex_shader = osg.Shader(osg.Shader.VERTEX, vertexShaderSource_simple) program.addShader(vertex_shader) coeff = osg.Uniform("coeff",osg.Vec4(1.0,-1.0,-1.0,1.0)) stateset.addUniform(coeff) if dynamic : coeff.setUpdateCallback(UniformVarying)() coeff.setDataVariance(osg.Object.DYNAMIC) stateset.setDataVariance(osg.Object.DYNAMIC) elif shader=="matrix" : vertex_shader = osg.Shader(osg.Shader.VERTEX, vertexShaderSource_matrix) program.addShader(vertex_shader) origin = osg.Uniform("origin",osg.Vec4(0.0,0.0,0.0,1.0)) stateset.addUniform(origin) coeffMatrix = osg.Uniform("coeffMatrix", osg.Matrix(1.0,0.0,1.0,0.0, 0.0,0.0,-1.0,0.0, 0.0,1.0,-1.0,0.0, 0.0,0.0,1.0,0.0)) stateset.addUniform(coeffMatrix) elif shader=="texture" : vertex_shader = osg.Shader(osg.Shader.VERTEX, vertexShaderSource_texture) program.addShader(vertex_shader) image = 0 if terrainFileName.empty() : image = osg.Image() tx = 38 ty = 39 image.allocateImage(tx,ty,1,GL_LUMINANCE,GL_FLOAT,1) for(unsigned int r=0r<ty++r) for(unsigned int c=0c<tx++c) *((float*)image.data(c,r)) = vertex[r+c*39][2]*0.1 num_x = tx num_y = tx
caption_text.setText(caption_) caption_text.setColor(osg.Vec4(1, 1, 1, 1)) caption_text.setAlignment(osgText.Text.CENTER_CENTER) caption_text.setFont("fonts/arial.ttf") caption_text.setCharacterSize(16) caption_text.setFontResolution(16, 16) caption_text.setPosition(osg.Vec3((rect_.x0 + rect_.x1) / 2, rect_.y1 - 15, zPos*2.0)) addDrawable(caption_text) rebuild_client_area(Rect(rect_.x0 + 4, rect_.y0 + 4, rect_.x1 - 4, rect_.y1 - 28)) osg.Geometry *Frame.build_quad( Rect rect, osg.Vec4 color, bool shadow, float z) shadow_space = 8 shadow_size = 10 geo = osg.Geometry() vx = osg.Vec3Array() vx.push_back(osg.Vec3(rect.x0, rect.y0, z)) vx.push_back(osg.Vec3(rect.x1, rect.y0, z)) vx.push_back(osg.Vec3(rect.x1, rect.y1, z)) vx.push_back(osg.Vec3(rect.x0, rect.y1, z)) if shadow : vx.push_back(osg.Vec3(rect.x0+shadow_space, rect.y0-shadow_size, z)) vx.push_back(osg.Vec3(rect.x1+shadow_size, rect.y0-shadow_size, z)) vx.push_back(osg.Vec3(rect.x1, rect.y0, z)) vx.push_back(osg.Vec3(rect.x0+shadow_space, rect.y0, z)) vx.push_back(osg.Vec3(rect.x1, rect.y1-shadow_space, z)) vx.push_back(osg.Vec3(rect.x1, rect.y0, z))
text = osgText.Text() geode.addDrawable( text ) text.setFont(timesFont) text.setPosition(position) text.setText("And finally set the Camera's RenderOrder to POST_RENDER\n" "to make sure it's drawn last.") position += delta bb = osg.BoundingBox() for(unsigned int i=0i<geode.getNumDrawables()++i) bb.expandBy(geode.getDrawable(i).getBound()) geom = osg.Geometry() vertices = osg.Vec3Array() depth = bb.zMin()-0.1 vertices.push_back(osg.Vec3(bb.xMin(),bb.yMax(),depth)) vertices.push_back(osg.Vec3(bb.xMin(),bb.yMin(),depth)) vertices.push_back(osg.Vec3(bb.xMax(),bb.yMin(),depth)) vertices.push_back(osg.Vec3(bb.xMax(),bb.yMax(),depth)) geom.setVertexArray(vertices) normals = osg.Vec3Array() normals.push_back(osg.Vec3(0.0,0.0,1.0)) geom.setNormalArray(normals, osg.Array.BIND_OVERALL) colors = osg.Vec4Array() colors.push_back(osg.Vec4(1.0,1.0,0.8,0.2))
class IntersectionUpdateCallback (osg.NodeCallback) : virtual void operator()(osg.Node* #node, osg.NodeVisitor* nv) if not root_ or not terrain_ or not ss_ or not intersectionGroup_ : osg.notify(osg.NOTICE), "IntersectionUpdateCallback not set up correctly." return #traverse(node,nv) frameCount_++ if frameCount_ > 200 : # first we need find the transformation matrix that takes # the terrain into the coordinate frame of the sphere segment. terrainLocalToWorld = osg.Matrixd() terrain_worldMatrices = terrain_.getWorldMatrices(root_) if terrain_worldMatrices.empty() : terrainLocalToWorld.makeIdentity() elif terrain_worldMatrices.size()==1 : terrainLocalToWorld = terrain_worldMatrices.front() else: osg.notify(osg.NOTICE), "IntersectionUpdateCallback: warning cannot interestect with multiple terrain instances, just uses first one." terrainLocalToWorld = terrain_worldMatrices.front() # sphere segment is easier as this callback is attached to the node, so the node visitor has the unique path to it already. ssWorldToLocal = osg.computeWorldToLocal(nv.getNodePath()) # now we can compute the terrain to ss transform possie = terrainLocalToWorld*ssWorldToLocal lines = ss_.computeIntersection(possie, terrain_) if not lines.empty() : if intersectionGroup_.valid() : # now we need to place the intersections which are in the SphereSegmenet's coordinate frame into # to the final position. mt = osg.MatrixTransform() mt.setMatrix(osg.computeLocalToWorld(nv.getNodePath())) intersectionGroup_.addChild(mt) # print "matrix = ", mt.getMatrix() geode = osg.Geode() mt.addChild(geode) geode.getOrCreateStateSet().setMode(GL_LIGHTING,osg.StateAttribute.OFF) for(osgSim.SphereSegment.LineList.iterator itr=lines.begin() not = lines.end() ++itr) geom = osg.Geometry() geode.addDrawable(geom) vertices = itr geom.setVertexArray(vertices) geom.addPrimitiveSet(osg.DrawArrays(GL_LINE_STRIP, 0, vertices.getNumElements())) else: osg.notify(osg.NOTICE), "No intersections found" frameCount_ = 0 root_ = osg.observer_ptr<osg.Group>() terrain_ = osg.observer_ptr<osg.Geode>() ss_ = osg.observer_ptr<osgSim.SphereSegment>() intersectionGroup_ = osg.observer_ptr<osg.Group>() frameCount_ = unsigned() class RotateUpdateCallback (osg.NodeCallback) : RotateUpdateCallback() i=0 virtual void operator()(osg.Node* node, osg.NodeVisitor* nv) ss = dynamic_cast<osgSim.SphereSegment *>(node) if ss : ss.setArea(osg.Vec3(cos(i/(2*osg.PI)),sin(i/(2*osg.PI)),0), osg.PI_2, osg.PI_2) i += 0.1 i = float() def createMovingModel(center, radius, terrainGeode, root, createMovingRadar): animationLength = 10.0 animationPath = createAnimationPath(center,radius,animationLength) model = osg.Group() glider = osgDB.readNodeFile("glider.osgt") if glider : bs = glider.getBound() size = radius/bs.radius()*0.3 positioned = osg.MatrixTransform() positioned.setDataVariance(osg.Object.STATIC) positioned.setMatrix(osg.Matrix.translate(-bs.center())* osg.Matrix.scale(size,size,size)* osg.Matrix.rotate(osg.inDegrees(-90.0),0.0,0.0,1.0)) positioned.addChild(glider) xform = osg.PositionAttitudeTransform() xform.getOrCreateStateSet().setMode(GL_NORMALIZE, osg.StateAttribute.ON) xform.setUpdateCallback(osg.AnimationPathCallback(animationPath,0.0,1.0)) xform.addChild(positioned) model.addChild(xform) if createMovingRadar : # The IntersectionUpdateCallback has to have a safe place to put all its generated geometry into, # and this group can't be in the parental chain of the callback otherwise we will end up invalidating # traversal iterators. intersectionGroup = osg.Group() root.addChild(intersectionGroup) xform = osg.PositionAttitudeTransform() xform.setUpdateCallback(osg.AnimationPathCallback(animationPath,0.0,1.0)) ss = osgSim.SphereSegment(osg.Vec3d(0.0,0.0,0.0), 700.0, # radius osg.DegreesToRadians(135.0), osg.DegreesToRadians(240.0), osg.DegreesToRadians(-60.0), osg.DegreesToRadians(-40.0), 60) iuc = IntersectionUpdateCallback() iuc.frameCount_ = 0 iuc.root_ = root iuc.terrain_ = terrainGeode iuc.ss_ = ss iuc.intersectionGroup_ = intersectionGroup ss.setUpdateCallback(iuc) ss.setAllColors(osg.Vec4(1.0,1.0,1.0,0.5)) ss.setSideColor(osg.Vec4(0.5,1.0,1.0,0.1)) xform.addChild(ss) model.addChild(xform) cessna = osgDB.readNodeFile("cessna.osgt") if cessna : bs = cessna.getBound() text = osgText.Text() size = radius/bs.radius()*0.3 text.setPosition(bs.center()) text.setText("Cessna") text.setAlignment(osgText.Text.CENTER_CENTER) text.setAxisAlignment(osgText.Text.SCREEN) text.setCharacterSize(40.0) text.setCharacterSizeMode(osgText.Text.OBJECT_COORDS) geode = osg.Geode() geode.addDrawable(text) lod = osg.LOD() lod.setRangeMode(osg.LOD.PIXEL_SIZE_ON_SCREEN) lod.setRadius(cessna.getBound().radius()) lod.addChild(geode,0.0,100.0) lod.addChild(cessna,100.0,10000.0) positioned = osg.MatrixTransform() positioned.getOrCreateStateSet().setMode(GL_NORMALIZE, osg.StateAttribute.ON) positioned.setDataVariance(osg.Object.STATIC) positioned.setMatrix(osg.Matrix.translate(-bs.center())* osg.Matrix.scale(size,size,size)* osg.Matrix.rotate(osg.inDegrees(180.0),0.0,0.0,1.0)) #positioned.addChild(cessna) positioned.addChild(lod) xform = osg.MatrixTransform() xform.setUpdateCallback(osg.AnimationPathCallback(animationPath,0.0,2.0)) xform.addChild(positioned) model.addChild(xform) return model def createOverlay(center, radius): group = osg.Group() # create a grid of lines. geom = osg.Geometry() num_rows = 10 left = center+osg.Vec3(-radius,-radius,0.0) right = center+osg.Vec3(radius,-radius,0.0) delta_row = osg.Vec3(0.0,2.0*radius/float(num_rows-1),0.0) top = center+osg.Vec3(-radius,radius,0.0) bottom = center+osg.Vec3(-radius,-radius,0.0) delta_column = osg.Vec3(2.0*radius/float(num_rows-1),0.0,0.0) vertices = osg.Vec3Array() for(unsigned int i=0 i<num_rows ++i) vertices.push_back(left) vertices.push_back(right) left += delta_row right += delta_row vertices.push_back(top) vertices.push_back(bottom) top += delta_column bottom += delta_column geom.setVertexArray(vertices) color = *(osg.Vec4ubArray(1)) color[0].set(0,0,0,255) geom.setColorArray(color, osg.Array.BIND_OVERALL) geom.addPrimitiveSet(osg.DrawArrays(GL_LINES,0,vertices.getNumElements())) geom.getOrCreateStateSet().setMode(GL_LIGHTING,osg.StateAttribute.OFF) geode = osg.Geode() geode.addDrawable(geom) group.addChild(geode) return group def computeTerrainIntersection(subgraph, x, y): bs = subgraph.getBound() zMax = bs.center().z()+bs.radius() zMin = bs.center().z()-bs.radius() intersector = osgUtil.LineSegmentIntersector(osg.Vec3(x,y,zMin),osg.Vec3(x,y,zMax)) iv = osgUtil.IntersectionVisitor(intersector) subgraph.accept(iv) if intersector.containsIntersections() : return intersector.getFirstIntersection().getWorldIntersectPoint() return osg.Vec3(x,y,0.0) ####################################### # MAIN SCENE GRAPH BUILDING FUNCTION ####################################### def build_world(root, testCase, useOverlay, technique): # create terrain terrainGeode = 0 terrainGeode = osg.Geode() stateset = osg.StateSet() image = osgDB.readImageFile("Images/lz.rgb") if image : texture = osg.Texture2D() texture.setImage(image) stateset.setTextureAttributeAndModes(0,texture,osg.StateAttribute.ON) terrainGeode.setStateSet( stateset ) numColumns = 38 numRows = 39 unsigned int r, c origin = osg.Vec3(0.0,0.0,0.0) size = osg.Vec3(1000.0,1000.0,250.0) geometry = osg.Geometry() v = *(osg.Vec3Array(numColumns*numRows)) tc = *(osg.Vec2Array(numColumns*numRows)) color = *(osg.Vec4ubArray(1)) color[0].set(255,255,255,255) rowCoordDelta = size.y()/(float)(numRows-1) columnCoordDelta = size.x()/(float)(numColumns-1) rowTexDelta = 1.0/(float)(numRows-1) columnTexDelta = 1.0/(float)(numColumns-1) # compute z range of z values of grid data so we can scale it. min_z = FLT_MAX max_z = -FLT_MAX for(r=0r<numRows++r) for(c=0c<numColumns++c) min_z = osg.minimum(min_z,vertex[r+c*numRows][2]) max_z = osg.maximum(max_z,vertex[r+c*numRows][2]) scale_z = size.z()/(max_z-min_z) pos = origin tex = osg.Vec2(0.0,0.0) vi = 0 for(r=0r<numRows++r) pos.x() = origin.x() tex.x() = 0.0 for(c=0c<numColumns++c) v[vi].set(pos.x(),pos.y(),pos.z()+(vertex[r+c*numRows][2]-min_z)*scale_z) tc[vi] = tex pos.x()+=columnCoordDelta tex.x()+=columnTexDelta ++vi pos.y() += rowCoordDelta tex.y() += rowTexDelta geometry.setVertexArray(v) geometry.setTexCoordArray(0, tc) geometry.setColorArray(color, osg.Array.BIND_OVERALL) for(r=0r<numRows-1++r) drawElements = *(osg.DrawElementsUShort(GL_QUAD_STRIP,2*numColumns)) geometry.addPrimitiveSet(drawElements) ei = 0 for(c=0c<numColumns++c) drawElements[ei++] = (r+1)*numColumns+c drawElements[ei++] = (r)*numColumns+c smoother = osgUtil.SmoothingVisitor() smoother.smooth(*geometry) terrainGeode.addDrawable(geometry) # create sphere segment ss = 0 terrainToSS = osg.Matrix() switch(testCase) case(0): ss = osgSim.SphereSegment( computeTerrainIntersection(terrainGeode,550.0,780.0), # center 510.0, # radius osg.DegreesToRadians(135.0), osg.DegreesToRadians(240.0), osg.DegreesToRadians(-10.0), osg.DegreesToRadians(30.0), 60) root.addChild(ss) break case(1): ss = osgSim.SphereSegment( computeTerrainIntersection(terrainGeode,550.0,780.0), # center 510.0, # radius osg.DegreesToRadians(45.0), osg.DegreesToRadians(240.0), osg.DegreesToRadians(-10.0), osg.DegreesToRadians(30.0), 60) root.addChild(ss) break case(2): ss = osgSim.SphereSegment( computeTerrainIntersection(terrainGeode,550.0,780.0), # center 510.0, # radius osg.DegreesToRadians(5.0), osg.DegreesToRadians(355.0), osg.DegreesToRadians(-10.0), osg.DegreesToRadians(30.0), 60) root.addChild(ss) break case(3): ss = osgSim.SphereSegment( computeTerrainIntersection(terrainGeode,550.0,780.0), # center 510.0, # radius osg.DegreesToRadians(0.0), osg.DegreesToRadians(360.0), osg.DegreesToRadians(-10.0), osg.DegreesToRadians(30.0), 60) root.addChild(ss) break case(4): ss = osgSim.SphereSegment(osg.Vec3d(0.0,0.0,0.0), 700.0, # radius osg.DegreesToRadians(135.0), osg.DegreesToRadians(240.0), osg.DegreesToRadians(-60.0), osg.DegreesToRadians(-40.0), 60) mt = osg.MatrixTransform() mt.setMatrix(osg.Matrix(-0.851781, 0.156428, -0.5, 0, -0.180627, -0.983552, -6.93889e-18, 0, -0.491776, 0.0903136, 0.866025, 0, 598.217, 481.957, 100, 1)) mt.addChild(ss) terrainToSS.invert(mt.getMatrix()) root.addChild(mt) break case(5): ss = osgSim.SphereSegment(osg.Vec3d(0.0,0.0,0.0), 700.0, # radius osg.DegreesToRadians(35.0), osg.DegreesToRadians(135.0), osg.DegreesToRadians(-60.0), osg.DegreesToRadians(-40.0), 60) mt = osg.MatrixTransform() mt.setMatrix(osg.Matrix(-0.851781, 0.156428, -0.5, 0, -0.180627, -0.983552, -6.93889e-18, 0, -0.491776, 0.0903136, 0.866025, 0, 598.217, 481.957, 100, 1)) mt.addChild(ss) terrainToSS.invert(mt.getMatrix()) root.addChild(mt) break case(6): ss = osgSim.SphereSegment(osg.Vec3d(0.0,0.0,0.0), 700.0, # radius osg.DegreesToRadians(-45.0), osg.DegreesToRadians(45.0), osg.DegreesToRadians(-60.0), osg.DegreesToRadians(-40.0), 60) mt = osg.MatrixTransform() mt.setMatrix(osg.Matrix(-0.851781, 0.156428, -0.5, 0, -0.180627, -0.983552, -6.93889e-18, 0, -0.491776, 0.0903136, 0.866025, 0, 598.217, 481.957, 100, 1)) mt.addChild(ss) terrainToSS.invert(mt.getMatrix()) root.addChild(mt) break case(7): ss = osgSim.SphereSegment( computeTerrainIntersection(terrainGeode,550.0,780.0), # center 510.0, # radius osg.DegreesToRadians(-240.0), osg.DegreesToRadians(-135.0), osg.DegreesToRadians(-10.0), osg.DegreesToRadians(30.0), 60) ss.setUpdateCallback(RotateUpdateCallback()) root.addChild(ss) break if ss.valid() : ss.setAllColors(osg.Vec4(1.0,1.0,1.0,0.5)) ss.setSideColor(osg.Vec4(0.0,1.0,1.0,0.1)) if not ss.getParents().empty() : ss.getParent(0).addChild(ss.computeIntersectionSubgraph(terrainToSS, terrainGeode)) if useOverlay : overlayNode = osgSim.OverlayNode(technique) overlayNode.getOrCreateStateSet().setTextureAttribute(1, osg.TexEnv(osg.TexEnv.DECAL)) bs = terrainGeode.getBound() overlaySubgraph = createOverlay(bs.center(), bs.radius()*0.5) overlaySubgraph.addChild(ss) overlayNode.setOverlaySubgraph(overlaySubgraph) overlayNode.setOverlayTextureSizeHint(1024) overlayNode.setOverlayBaseHeight(0.0) overlayNode.addChild(terrainGeode) root.addChild(overlayNode) else: root.addChild(terrainGeode) # create particle effects position = computeTerrainIntersection(terrainGeode,100.0,100.0) explosion = osgParticle.ExplosionEffect(position, 10.0) smoke = osgParticle.SmokeEffect(position, 10.0) fire = osgParticle.FireEffect(position, 10.0) root.addChild(explosion) root.addChild(smoke) root.addChild(fire) # create particle effects position = computeTerrainIntersection(terrainGeode,200.0,100.0) explosion = osgParticle.ExplosionEffect(position, 1.0) smoke = osgParticle.SmokeEffect(position, 1.0) fire = osgParticle.FireEffect(position, 1.0) root.addChild(explosion) root.addChild(smoke) root.addChild(fire) createMovingRadar = True # create the moving models. root.addChild(createMovingModel(osg.Vec3(500.0,500.0,500.0),100.0, terrainGeode, root, createMovingRadar)) ####################################### # main() ####################################### def main(argv): # use an ArgumentParser object to manage the program arguments. arguments = osg.ArgumentParser(argv) # set up the usage document, in case we need to print out how to use this program. arguments.getApplicationUsage().setDescription(arguments.getApplicationName()+" is the example which demonstrates use of particle systems.") arguments.getApplicationUsage().setCommandLineUsage(arguments.getApplicationName()+" [options] image_file_left_eye image_file_right_eye") arguments.getApplicationUsage().addCommandLineOption("-h or --help","Display this information") # construct the viewer. viewer = osgViewer.Viewer(arguments) # if user request help write it out to cout. testCase = 0 while arguments.read("-t", testCase) : useOverlay = False technique = osgSim.OverlayNode.OBJECT_DEPENDENT_WITH_ORTHOGRAPHIC_OVERLAY while arguments.read("--object") : useOverlay = True technique = osgSim.OverlayNode.OBJECT_DEPENDENT_WITH_ORTHOGRAPHIC_OVERLAY while arguments.read("--ortho") or arguments.read("--orthographic") : useOverlay = True technique = osgSim.OverlayNode.VIEW_DEPENDENT_WITH_ORTHOGRAPHIC_OVERLAY while arguments.read("--persp") or arguments.read("--perspective") : useOverlay = True technique = osgSim.OverlayNode.VIEW_DEPENDENT_WITH_PERSPECTIVE_OVERLAY # if user request help write it out to cout. if arguments.read("-h") or arguments.read("--help") : arguments.getApplicationUsage().write(std.cout) return 1 # any option left unread are converted into errors to write out later. arguments.reportRemainingOptionsAsUnrecognized() # report any errors if they have occurred when parsing the program arguments. if arguments.errors() : arguments.writeErrorMessages(std.cout) return 1 root = osg.Group() build_world(root, testCase, useOverlay, technique) # add a viewport to the viewer and attach the scene graph. viewer.setSceneData(root) return viewer.run() if __name__ == "__main__": main(sys.argv)
colours = osg.Vec4Array(1) (*colours)[0] = osg.Vec4d(1.0,1.0,1.0,1.0) unitCircle.setColorArray(colours, osg.Array.BIND_OVERALL) n_points = 1024 coords = osg.Vec3Array(n_points) dx = 2.0*osg.PI/n_points double s,c for (unsigned int j=0 j<n_points ++j) s = sin(dx*j) c = cos(dx*j) (*coords)[j].set(osg.Vec3d(c,s,0.0)) unitCircle.setVertexArray(coords) unitCircle.getOrCreateStateSet().setMode(GL_LIGHTING,osg.StateAttribute.OFF) unitCircle.addPrimitiveSet(osg.DrawArrays(osg.PrimitiveSet.LINE_LOOP,0,n_points)) axes = osg.Geometry() colours = osg.Vec4Array(1) (*colours)[0] = osg.Vec4d(1.0,0.0,0.0,1.0) axes.setColorArray(colours, osg.Array.BIND_OVERALL) coords = osg.Vec3Array(6) (*coords)[0].set(osg.Vec3d(0.0, 0.0, 0.0)) (*coords)[1].set(osg.Vec3d(0.5, 0.0, 0.0)) (*coords)[2].set(osg.Vec3d(0.0, 0.0, 0.0)) (*coords)[3].set(osg.Vec3d(0.0, 0.5, 0.0)) (*coords)[4].set(osg.Vec3d(0.0, 0.0, 0.0)) (*coords)[5].set(osg.Vec3d(0.0, 0.0, 0.5)) axes.setVertexArray(coords) axes.getOrCreateStateSet().setMode(GL_LIGHTING,osg.StateAttribute.OFF) axes.addPrimitiveSet(osg.DrawArrays(osg.PrimitiveSet.LINES,0,6)) # Earth orbit
def createRectangle(bb, filename): top_left = osg.Vec3(bb.xMin(),bb.yMax(),bb.zMax()) bottom_left = osg.Vec3(bb.xMin(),bb.yMax(),bb.zMin()) bottom_right = osg.Vec3(bb.xMax(),bb.yMax(),bb.zMin()) top_right = osg.Vec3(bb.xMax(),bb.yMax(),bb.zMax()) # create geometry geom = osg.Geometry() vertices = osg.Vec3Array(4) (*vertices)[0] = top_left (*vertices)[1] = bottom_left (*vertices)[2] = bottom_right (*vertices)[3] = top_right geom.setVertexArray(vertices) texcoords = osg.Vec2Array(4) (*texcoords)[0].set(0.0, 0.0) (*texcoords)[1].set(1.0, 0.0) (*texcoords)[2].set(1.0, 1.0) (*texcoords)[3].set(0.0, 1.0) geom.setTexCoordArray(0,texcoords) normals = osg.Vec3Array(1) (*normals)[0].set(0.0,-1.0,0.0) geom.setNormalArray(normals, osg.Array.BIND_OVERALL) colors = osg.Vec4Array(1) (*colors)[0].set(1.0,1.0,1.0,1.0) geom.setColorArray(colors, osg.Array.BIND_OVERALL) geom.addPrimitiveSet(osg.DrawArrays(GL_QUADS, 0, 4)) # disable display list so our modified tex coordinates show up geom.setUseDisplayList(False) # load image img = osgDB.readImageFile(filename) # setup texture texture = osg.TextureRectangle(img) texmat = osg.TexMat() texmat.setScaleByTextureRectangleSize(True) # setup state state = geom.getOrCreateStateSet() state.setTextureAttributeAndModes(0, texture, osg.StateAttribute.ON) state.setTextureAttributeAndModes(0, texmat, osg.StateAttribute.ON) # turn off lighting state.setMode(GL_LIGHTING, osg.StateAttribute.OFF) # install 'update' callback geode = osg.Geode() geode.addDrawable(geom) geode.setUpdateCallback(TexturePanCallback(texmat)) return geode
#include <osg/BlendFunc> #include <osg/StateAttribute> #include <osg/Point> #include <osg/Geometry> #include <osg/Texture2D> #include <osg/TexEnv> #include <osg/GLExtensions> #include <osg/TexEnv> #include <osgDB/ReadFile> #include <osgViewer/Viewer> osg.Geode *makeGalaxy(unsigned nvertices) geode = osg.Geode() galaxy = osg.Geometry() vertices = osg.Vec3Array() colors = osg.Vec4Array() ini = osg.Vec4(1,1,0,1) fin = osg.Vec4(0,0,1,1) #* Formula for the two spirals for (unsigned i=0i<nvertices/2i++) val = (i*2/(float)nvertices * 2 * 3.14159265359) modx1 = rand() / (float)RAND_MAX*2 mody1 = rand() / (float)RAND_MAX*2 modx2 = rand() / (float)RAND_MAX*2 mody2 = rand() / (float)RAND_MAX*2 modz1 = ((rand()-RAND_MAX/2) / (float)(RAND_MAX))*3/(val+1) modz2 = ((rand()-RAND_MAX/2) / (float)(RAND_MAX))*3/(val+1) vertices.push_back(osg.Vec3(cos(val)*val+modx1, sin(val)*val+mody1, modz1))
#!/bin/env python # Translated into python from C++ tutorial at # http:#trac.openscenegraph.org/projects/osg/wiki/Support/Tutorials/BasicGeometry from osgpypp import osg, osgViewer # The following section of code sets up a viewer to see the scene we create, a 'group' instance to serve as the root of the scene graph, a geometry node (geode) to collect drawables, and a geometry instance to associate vertices and vertex data. (In this case the shape to render is a four-sided pyramid.) root = osg.Group() pyramidGeode = osg.Geode() pyramidGeometry = osg.Geometry() # Next we need to associate the pyramid geometry with the pyramid geode and add the pyramid geode to the root node of the scene graph. pyramidGeode.addDrawable(pyramidGeometry) root.addChild(pyramidGeode) # Declare an array of vertices. Each vertex will be represented by a triple -- an instances of the vec3 class. An instance of osg.Vec3Array can be used to store these triples. Since osg.Vec3Array is derived from the STL vector class, we can use the append method to add array elements. Push back adds elements to the end of the vector, thus the index of first element entered is zero, the second entries index is 1, etc. # Using a right-handed coordinate system with 'z' up, array elements zero..four below represent the 5 points required to create a simple pyramid. pyramidVertices = osg.Vec3Array() pyramidVertices.append(osg.Vec3(0, 0, 0)) # front left pyramidVertices.append(osg.Vec3(10, 0, 0)) # front right pyramidVertices.append(osg.Vec3(10, 10, 0)) # back right pyramidVertices.append(osg.Vec3(0, 10, 0)) # back left pyramidVertices.append(osg.Vec3(5, 5, 10)) # peak # Associate this set of vertices with the geometry associated with the geode we added to the scene. pyramidGeometry.setVertexArray(pyramidVertices) # Next, create a primitive set and add it to the pyramid geometry. Use the first four points of the pyramid to define the base using an instance of the DrawElementsUint class. Again this class is derived from the STL vector, so the append method will add elements in sequential order. To ensure proper backface cullling, vertices should be specified in counterclockwise order. The arguments for the constructor are the enumerated type for the primitive (same as the OpenGL primitive enumerated types), and the index in the vertex array to start from. pyramidBase = osg.DrawElementsUInt(osg.PrimitiveSet.QUADS, 0) pyramidBase.append(3) pyramidBase.append(2) pyramidBase.append(1) pyramidBase.append(0) pyramidGeometry.addPrimitiveSet(pyramidBase)
def createDomeDistortionMesh(origin, widthVector, heightVector, arguments): sphere_radius = 1.0 if arguments.read("--radius", sphere_radius) : collar_radius = 0.45 if arguments.read("--collar", collar_radius) : center = osg.Vec3d(0.0,0.0,0.0) eye = osg.Vec3d(0.0,0.0,0.0) distance = sqrt(sphere_radius*sphere_radius - collar_radius*collar_radius) if arguments.read("--distance", distance) : centerProjection = False projector = eye - osg.Vec3d(0.0,0.0, distance) osg.notify(osg.NOTICE), "Projector position = ", projector osg.notify(osg.NOTICE), "distance = ", distance # create the quad to visualize. geometry = osg.Geometry() geometry.setSupportsDisplayList(False) xAxis = osg.Vec3(widthVector) width = widthVector.length() xAxis /= width yAxis = osg.Vec3(heightVector) height = heightVector.length() yAxis /= height noSteps = 50 vertices = osg.Vec3Array() texcoords = osg.Vec3Array() colors = osg.Vec4Array() bottom = origin dx = xAxis*(width/((float)(noSteps-1))) dy = yAxis*(height/((float)(noSteps-1))) screenCenter = origin + widthVector*0.5 + heightVector*0.5 screenRadius = heightVector.length() * 0.5 int i,j if centerProjection : for(i=0i<noSteps++i) cursor = bottom+dy*(float)i for(j=0j<noSteps++j) delta = osg.Vec2(cursor.x() - screenCenter.x(), cursor.y() - screenCenter.y()) theta = atan2(-delta.y(), delta.x()) phi = osg.PI_2 * delta.length() / screenRadius if phi > osg.PI_2 : phi = osg.PI_2 phi *= 2.0 # osg.notify(osg.NOTICE), "theta = ", theta, "phi=", phi texcoord = osg.Vec3(sin(phi) * cos(theta), sin(phi) * sin(theta), cos(phi)) vertices.push_back(cursor) colors.push_back(osg.Vec4(1.0,1.0,1.0,1.0)) texcoords.push_back(texcoord) cursor += dx
def createPyramid(): pyramidGeode = osg.Geode() pyramidGeometry = osg.Geometry() pyramidGeode.addDrawable(pyramidGeometry) pyramidVertices = osg.Vec3Array() pyramidVertices.append( osg.Vec3(0, 0, 0) ) # front left pyramidVertices.append( osg.Vec3(2, 0, 0) ) # front right pyramidVertices.append( osg.Vec3(2, 2, 0) ) # back right pyramidVertices.append( osg.Vec3( 0,2, 0) ) # back left pyramidVertices.append( osg.Vec3( 1, 1,2) ) # peak # Associate this set of vertices with the geometry associated with the # geode we added to the scene. pyramidGeometry.setVertexArray( pyramidVertices ) pyramidBase = osg.DrawElementsUInt(osg.PrimitiveSet.QUADS, 3) pyramidBase.append(3) pyramidBase.append(2) pyramidBase.append(1) pyramidBase.append(0) pyramidGeometry.addPrimitiveSet(pyramidBase) pyramidFaceOne = osg.DrawElementsUInt(osg.PrimitiveSet.TRIANGLES, 0) pyramidFaceOne.append(0) pyramidFaceOne.append(1) pyramidFaceOne.append(4) pyramidGeometry.addPrimitiveSet(pyramidFaceOne) pyramidFaceTwo = osg.DrawElementsUInt(osg.PrimitiveSet.TRIANGLES, 0) pyramidFaceTwo.append(1) pyramidFaceTwo.append(2) pyramidFaceTwo.append(4) pyramidGeometry.addPrimitiveSet(pyramidFaceTwo) pyramidFaceThree = osg.DrawElementsUInt(osg.PrimitiveSet.TRIANGLES, 0) pyramidFaceThree.append(2) pyramidFaceThree.append(3) pyramidFaceThree.append(4) pyramidGeometry.addPrimitiveSet(pyramidFaceThree) pyramidFaceFour = osg.DrawElementsUInt(osg.PrimitiveSet.TRIANGLES, 0) pyramidFaceFour.append(3) pyramidFaceFour.append(0) pyramidFaceFour.append(4) pyramidGeometry.addPrimitiveSet(pyramidFaceFour) colors = osg.Vec4Array() colors.append(osg.Vec4(1.0, 0.0, 0.0, 1.0) ) #index 0 red colors.append(osg.Vec4(0.0, 1.0, 0.0, 1.0) ) #index 1 green colors.append(osg.Vec4(0.0, 0.0, 1.0, 1.0) ) #index 2 blue colors.append(osg.Vec4(1.0, 1.0, 1.0, 1.0) ) #index 3 white colorIndexArray = osg.UIntArray() colorIndexArray.append(0) # vertex 0 assigned color array element 0 colorIndexArray.append(1) # vertex 1 assigned color array element 1 colorIndexArray.append(2) # vertex 2 assigned color array element 2 colorIndexArray.append(3) # vertex 3 assigned color array element 3 colorIndexArray.append(0) # vertex 4 assigned color array element 0 pyramidGeometry.setColorArray(colors) pyramidGeometry.setColorIndices(colorIndexArray) pyramidGeometry.setColorBinding(osg.Geometry.BIND_PER_VERTEX) texcoords = osg.Vec2Array(5) texcoords[0].set(0.00,0.0) texcoords[1].set(0.25,0.0) texcoords[2].set(0.50,0.0) texcoords[3].set(0.75,0.0) texcoords[4].set(0.50,1.0) pyramidGeometry.setTexCoordArray(0,texcoords) return pyramidGeode
def createDistortionSubgraph(subgraph, clearColour): distortionNode = osg.Group() tex_width = 1024 tex_height = 1024 texture = osg.Texture2D() texture.setTextureSize(tex_width, tex_height) texture.setInternalFormat(GL_RGBA) texture.setFilter(osg.Texture2D.MIN_FILTER,osg.Texture2D.LINEAR) texture.setFilter(osg.Texture2D.MAG_FILTER,osg.Texture2D.LINEAR) # set up the render to texture camera. camera = osg.Camera() # set clear the color and depth buffer camera.setClearColor(clearColour) camera.setClearMask(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT) # just inherit the main cameras view camera.setReferenceFrame(osg.Transform.RELATIVE_RF) camera.setProjectionMatrix(osg.Matrixd.identity()) camera.setViewMatrix(osg.Matrixd.identity()) # set viewport camera.setViewport(0,0,tex_width,tex_height) # set the camera to render before the main camera. camera.setRenderOrder(osg.Camera.PRE_RENDER) # tell the camera to use OpenGL frame buffer object where supported. camera.setRenderTargetImplementation(osg.Camera.FRAME_BUFFER_OBJECT) # attach the texture and use it as the color buffer. camera.attach(osg.Camera.COLOR_BUFFER, texture) # add subgraph to render camera.addChild(subgraph) distortionNode.addChild(camera) # set up the hud camera # create the quad to visualize. polyGeom = osg.Geometry() polyGeom.setSupportsDisplayList(False) origin = osg.Vec3(0.0,0.0,0.0) xAxis = osg.Vec3(1.0,0.0,0.0) yAxis = osg.Vec3(0.0,1.0,0.0) height = 1024.0 width = 1280.0 noSteps = 50 vertices = osg.Vec3Array() texcoords = osg.Vec2Array() colors = osg.Vec4Array() bottom = origin dx = xAxis*(width/((float)(noSteps-1))) dy = yAxis*(height/((float)(noSteps-1))) bottom_texcoord = osg.Vec2(0.0,0.0) dx_texcoord = osg.Vec2(1.0/(float)(noSteps-1),0.0) dy_texcoord = osg.Vec2(0.0,1.0/(float)(noSteps-1)) int i,j for(i=0i<noSteps++i) cursor = bottom+dy*(float)i texcoord = bottom_texcoord+dy_texcoord*(float)i for(j=0j<noSteps++j)
# reset the object color to white to allow the texture to set the colour. sSpaceSphere.setColor( osg.Vec4(1.0,1.0,1.0,1.0) ) geodeSpace = osg.Geode() geodeSpace.setName( name ) geodeSpace.addDrawable( sSpaceSphere ) return( geodeSpace ) # end SolarSystem.createSpace osg.Geode* SolarSystem.createPlanet( double radius, str name, osg.Vec4 color , str textureName) # create a container that makes the sphere drawable sPlanetSphere = osg.Geometry() # set the single colour so bind overall colours = osg.Vec4Array(1) (*colours)[0] = color sPlanetSphere.setColorArray(colours, osg.Array.BIND_OVERALL) # now set up the coords, normals and texcoords for geometry numX = 100 numY = 50 numVertices = numX*numY coords = osg.Vec3Array(numVertices) sPlanetSphere.setVertexArray(coords)
geode.addDrawable( text ) text.setFont(timesFont) text.setText("Picking in Head Up Displays is simple not ") text.setPosition(position) position += delta for (int i=0 i<5 i++) dy = osg.Vec3(0.0,-30.0,0.0) dx = osg.Vec3(120.0,0.0,0.0) geode = osg.Geode() stateset = geode.getOrCreateStateSet() char *opts[]="One", "Two", "Three", "January", "Feb", "2003" quad = osg.Geometry() stateset.setMode(GL_LIGHTING,osg.StateAttribute.OFF) stateset.setMode(GL_DEPTH_TEST,osg.StateAttribute.OFF) name = "subOption" name += " " name += str(opts[i]) geode.setName(name) vertices = osg.Vec3Array(4) # 1 quad colors = osg.Vec4Array() colors = osg.Vec4Array() colors.push_back(osg.Vec4(0.8-0.1*i,0.1*i,0.2*i, 1.0)) quad.setColorArray(colors, osg.Array.BIND_OVERALL) (*vertices)[0]=position (*vertices)[1]=position+dx (*vertices)[2]=position+dx+dy (*vertices)[3]=position+dy
quad_geode = osg.Geode() quad_coords = osg.Vec3Array() # vertex coords # counter-clockwise quad_coords.push_back(osg.Vec3d(0, 0, -1)) quad_coords.push_back(osg.Vec3d(1, 0, -1)) quad_coords.push_back(osg.Vec3d(1, 1, -1)) quad_coords.push_back(osg.Vec3d(0, 1, -1)) quad_tcoords = osg.Vec2Array() # texture coords quad_tcoords.push_back(osg.Vec2(0, 0)) quad_tcoords.push_back(osg.Vec2(tex_width, 0)) quad_tcoords.push_back(osg.Vec2(tex_width, tex_height)) quad_tcoords.push_back(osg.Vec2(0, tex_height)) quad_geom = osg.Geometry() quad_da = osg.DrawArrays(osg.PrimitiveSet.QUADS,0,4) quad_colors = osg.Vec4Array() quad_colors.push_back(osg.Vec4(1.0,1.0,1.0,1.0)) quad_geom.setVertexArray(quad_coords) quad_geom.setTexCoordArray(0, quad_tcoords) quad_geom.addPrimitiveSet(quad_da) quad_geom.setColorArray(quad_colors, osg.Array.BIND_OVERALL) stateset = quad_geom.getOrCreateStateSet() stateset.setMode(GL_LIGHTING,osg.StateAttribute.OFF) stateset.addUniform(osg.Uniform("width", (int)tex_width))
def createScene(): # create the Geode (Geometry Node) to contain all our osg.Geometry objects. geode = osg.Geode() # following are separate blocks for creating POINTS, LINES, LINE_STRIP, LINE_LOOP, POLYGON, QUADS, # QUAD_STRIP, TRIANGLES, TRIANGLE_STRIP and TRIANGLE_FAN primitives. An image of these primitives # is provided in the distribution: OpenSceneGraph-Data/Images/primitives.gif. # create POINTS # create Geometry object to store all the vertices and points primitive. pointsGeom = osg.Geometry() # create a Vec3Array and add to it all my coordinates. # Like all the *Array variants (see include/osg/Array) , Vec3Array is derived from both osg.Array # and std.vector<>. osg.Array's are reference counted and hence sharable, # which std.vector<> provides all the convenience, flexibility and robustness # of the most popular of all STL containers. vertices = osg.Vec3Array() vertices.push_back(osg.Vec3(-1.02168, -2.15188e-09, 0.885735)) vertices.push_back(osg.Vec3(-0.976368, -2.15188e-09, 0.832179)) vertices.push_back(osg.Vec3(-0.873376, 9.18133e-09, 0.832179)) vertices.push_back(osg.Vec3(-0.836299, -2.15188e-09, 0.885735)) vertices.push_back(osg.Vec3(-0.790982, 9.18133e-09, 0.959889)) # pass the created vertex array to the points geometry object. pointsGeom.setVertexArray(vertices) # create the color of the geometry, one single for the whole geometry. # for consistency of design even one single color must added as an element # in a color array. colors = osg.Vec4Array() # add a white color, colors take the form r,g,b,a with 0.0 off, 1.0 full on. colors.push_back(osg.Vec4(1.0,1.0,0.0,1.0)) # pass the color array to points geometry, note the binding to tell the geometry # that only use one color for the whole object. pointsGeom.setColorArray(colors, osg.Array.BIND_OVERALL) # set the normal in the same way color. normals = osg.Vec3Array() normals.push_back(osg.Vec3(0.0,-1.0,0.0)) pointsGeom.setNormalArray(normals, osg.Array.BIND_OVERALL) # create and add a DrawArray Primitive (see include/osg/Primitive). The first # parameter passed to the DrawArrays constructor is the Primitive.Mode which # in this case is POINTS (which has the same value GL_POINTS), the second # parameter is the index position into the vertex array of the first point # to draw, and the third parameter is the number of points to draw. pointsGeom.addPrimitiveSet(osg.DrawArrays(osg.PrimitiveSet.POINTS,0,vertices.size())) # add the points geometry to the geode. geode.addDrawable(pointsGeom) # create LINES # create Geometry object to store all the vertices and lines primitive. linesGeom = osg.Geometry() # this time we'll preallocate the vertex array to the size we # need and then simple set them as array elements, 8 points # makes 4 line segments. vertices = osg.Vec3Array(8) (*vertices)[0].set(-1.13704, -2.15188e-09, 0.40373) (*vertices)[1].set(-0.856897, -2.15188e-09, 0.531441) (*vertices)[2].set(-0.889855, -2.15188e-09, 0.444927) (*vertices)[3].set(-0.568518, -2.15188e-09, 0.40373) (*vertices)[4].set(-1.00933, -2.15188e-09, 0.370773) (*vertices)[5].set(-0.716827, -2.15188e-09, 0.292498) (*vertices)[6].set(-1.07936, 9.18133e-09, 0.317217) (*vertices)[7].set(-0.700348, 9.18133e-09, 0.362533) # pass the created vertex array to the points geometry object. linesGeom.setVertexArray(vertices) # set the colors as before, plus using the above colors = osg.Vec4Array() colors.push_back(osg.Vec4(1.0,1.0,0.0,1.0)) linesGeom.setColorArray(colors, osg.Array.BIND_OVERALL) # set the normal in the same way color. normals = osg.Vec3Array() normals.push_back(osg.Vec3(0.0,-1.0,0.0)) linesGeom.setNormalArray(normals, osg.Array.BIND_OVERALL) # This time we simply use primitive, and hardwire the number of coords to use # since we know up front, linesGeom.addPrimitiveSet(osg.DrawArrays(osg.PrimitiveSet.LINES,0,8)) # add the points geometry to the geode. geode.addDrawable(linesGeom) # create LINE_STRIP # create Geometry object to store all the vertices and lines primitive. linesGeom = osg.Geometry() # this time we'll preallocate the vertex array to the size # and then use an iterator to fill in the values, a bit perverse # but does demonstrate that we have just a standard std.vector underneath. vertices = osg.Vec3Array(5) vitr = vertices.begin() (vitr++).set(-0.0741545, -2.15188e-09, 0.416089) (vitr++).set(0.234823, -2.15188e-09, 0.259541) (vitr++).set(0.164788, -2.15188e-09, 0.366653) (vitr++).set(-0.0288379, -2.15188e-09, 0.333695) (vitr++).set(-0.0453167, -2.15188e-09, 0.280139) # pass the created vertex array to the points geometry object. linesGeom.setVertexArray(vertices) # set the colors as before, plus using the above colors = osg.Vec4Array() colors.push_back(osg.Vec4(1.0,1.0,0.0,1.0)) linesGeom.setColorArray(colors, osg.Array.BIND_OVERALL) # set the normal in the same way color. normals = osg.Vec3Array() normals.push_back(osg.Vec3(0.0,-1.0,0.0)) linesGeom.setNormalArray(normals, osg.Array.BIND_OVERALL) # This time we simply use primitive, and hardwire the number of coords to use # since we know up front, linesGeom.addPrimitiveSet(osg.DrawArrays(osg.PrimitiveSet.LINE_STRIP,0,5)) # add the points geometry to the geode. geode.addDrawable(linesGeom) # create LINE_LOOP # create Geometry object to store all the vertices and lines primitive. linesGeom = osg.Geometry() # this time we'll a C arrays to initialize the vertices. osg.Vec3 myCoords[] = osg.Vec3(0.741546, -2.15188e-09, 0.453167), osg.Vec3(0.840418, -2.15188e-09, 0.304858), osg.Vec3(1.12468, -2.15188e-09, 0.300738), osg.Vec3(1.03816, 9.18133e-09, 0.453167), osg.Vec3(0.968129, -2.15188e-09, 0.337815), osg.Vec3(0.869256, -2.15188e-09, 0.531441)
def createOccluder(v1, v2, v3, v4, holeRatio): # create an occluder which will sit alongside the loaded model. occluderNode = osg.OccluderNode() # create the convex planar occluder cpo = osg.ConvexPlanarOccluder() # attach it to the occluder node. occluderNode.setOccluder(cpo) occluderNode.setName("occluder") # set the occluder up for the front face of the bounding box. occluder = cpo.getOccluder() occluder.add(v1) occluder.add(v2) occluder.add(v3) occluder.add(v4) # create a hole at the center of the occluder if needed. if holeRatio>0.0 : # create hole. ratio = holeRatio one_minus_ratio = 1-ratio center = (v1+v2+v3+v4)*0.25 v1dash = v1*ratio + center*one_minus_ratio v2dash = v2*ratio + center*one_minus_ratio v3dash = v3*ratio + center*one_minus_ratio v4dash = v4*ratio + center*one_minus_ratio hole = osg.ConvexPlanarPolygon() hole.add(v1dash) hole.add(v2dash) hole.add(v3dash) hole.add(v4dash) cpo.addHole(hole) # create a drawable for occluder. geom = osg.Geometry() coords = osg.Vec3Array(occluder.getVertexList().begin(),occluder.getVertexList().end()) geom.setVertexArray(coords) colors = osg.Vec4Array(1) (*colors)[0].set(1.0,1.0,1.0,0.5) geom.setColorArray(colors, osg.Array.BIND_OVERALL) geom.addPrimitiveSet(osg.DrawArrays(osg.PrimitiveSet.QUADS,0,4)) geode = osg.Geode() geode.addDrawable(geom) stateset = osg.StateSet() stateset.setMode(GL_LIGHTING,osg.StateAttribute.OFF) stateset.setMode(GL_BLEND,osg.StateAttribute.ON) stateset.setRenderingHint(osg.StateSet.TRANSPARENT_BIN) geom.setStateSet(stateset) # add the occluder geode as a child of the occluder, # as the occluder can't self occlude its subgraph the # geode will never be occluded by this occluder. occluderNode.addChild(geode) return occluderNode