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
