def createSquare(textureCoordMax):
# set up the Geometry.
geom = osg.Geometry()
coords = osg.Vec3Array(4)
(*coords)[0].set(-1.0,0.0,1.0)
(*coords)[1].set(-1.0,0.0,-1.0)
(*coords)[2].set(1.0,0.0,-1.0)
(*coords)[3].set(1.0,0.0,1.0)
geom.setVertexArray(coords)
norms = osg.Vec3Array(1)
(*norms)[0].set(0.0,-1.0,0.0)
geom.setNormalArray(norms, osg.Array.BIND_OVERALL)
tcoords = osg.Vec2Array(4)
(*tcoords)[0].set(0.0,textureCoordMax)
(*tcoords)[1].set(0.0,0.0)
(*tcoords)[2].set(textureCoordMax,0.0)
(*tcoords)[3].set(textureCoordMax,textureCoordMax)
geom.setTexCoordArray(0,tcoords)
geom.addPrimitiveSet(osg.DrawArrays(osg.PrimitiveSet.QUADS,0,4))
return geom
def createTextureQuad(texture):
vertices = osg.Vec3Array()
vertices.push_back(osg.Vec3(-0.8, 0.0, -0.8))
vertices.push_back(osg.Vec3(0.8, 0.0, -0.8))
vertices.push_back(osg.Vec3(0.8, 0.0, 0.8))
vertices.push_back(osg.Vec3(-0.8, 0.0, 0.8))
texcoord = osg.Vec2Array()
texcoord.push_back(osg.Vec2(0.0, 0.0))
texcoord.push_back(osg.Vec2(1.0, 0.0))
texcoord.push_back(osg.Vec2(1.0, 1.0))
texcoord.push_back(osg.Vec2(0.0, 1.0))
geom = osg.Geometry()
geom.setVertexArray(vertices)
geom.setTexCoordArray(0, texcoord)
geom.addPrimitiveSet(osg.DrawArrays(GL_QUADS, 0, 4))
geode = osg.Geode()
geode.addDrawable(geom)
geode.getOrCreateStateSet().setTextureAttributeAndModes(0, texture, osg.StateAttribute.ON)
return geode
def createTexturedQuadGeometry(corner, widthVec, heightVec, l, b, r, t):
g = osg.Geometry()
# Create vertex array
vertices = osg.Vec3Array()
vertices.append(corner + widthVec)
vertices.append(corner)
vertices.append(corner + heightVec)
vertices.append(corner + widthVec + heightVec)
g.setVertexArray(vertices)
# Create texcoord array
texcoords = osg.Vec2Array()
texcoords.append(osg.Vec2f(l, t))
texcoords.append(osg.Vec2f(l, b))
texcoords.append(osg.Vec2f(r, b))
texcoords.append(osg.Vec2f(r, t))
g.setTexCoordArray(0, texcoords)
# Create color array (single value, white)
colors = osg.Vec4Array()
colors.append(osg.Vec4f(1, 1, 1, 1))
g.setColorArray(colors)
g.colorBinding = osg.Geometry.BIND_OVERALL
# Create normal array (single value for all vertices)
normals = osg.Vec3Array()
normals.append(osg.Vec3f(0, -1, 0))
g.setNormalArray(normals)
g.normalBinding = osg.Geometry.BIND_OVERALL
# Add primitive set
g.addPrimitiveSet(osg.DrawArrays(osg.PrimitiveSet.QUADS, 0, 4))
return g
def createMirrorSurface(xMin,xMax,yMin,yMax,z):
#// set up the drawstate.
#// set up the Geometry.
geom = osg.Geometry();
coords = osg.Vec3Array();
coords.append(osg.Vec3f(xMin,yMax,z))
coords.append(osg.Vec3f(xMin,yMin,z))
coords.append(osg.Vec3f(xMax,yMin,z))
coords.append(osg.Vec3f(xMax,yMax,z))
geom.setVertexArray(coords);
norms = osg.Vec3Array();
norms.append(osg.Vec3f(0.0,0.0,1.0))
geom.setNormalArray(norms);
geom.normalBinding = osg.Geometry.BIND_OVERALL
tcoords = osg.Vec2Array()
tcoords.append(osg.Vec2f(0.0,1.0))
tcoords.append(osg.Vec2f(0.0,0.0))
tcoords.append(osg.Vec2f(1.0,0.0))
tcoords.append(osg.Vec2f(1.0,1.0))
geom.setTexCoordArray(0,tcoords);
colours = osg.Vec4Array();
colours.append(osg.Vec4f(1.0,1.0,1.0,1.0))
geom.setColorArray(colours);
geom.colorBinding = osg.Geometry.BIND_OVERALL;
geom.addPrimitiveSet(osg.DrawArrays(osg.PrimitiveSet.QUADS,0,4));
return geom;
def createMirrorSurface(xMin, xMax, yMin, yMax, z):
# set up the drawstate.
# set up the Geometry.
geom = osg.Geometry()
coords = osg.Vec3Array(4)
(*coords)[0].set(xMin,yMax,z)
(*coords)[1].set(xMin,yMin,z)
(*coords)[2].set(xMax,yMin,z)
(*coords)[3].set(xMax,yMax,z)
geom.setVertexArray(coords)
norms = osg.Vec3Array(1)
(*norms)[0].set(0.0,0.0,1.0)
geom.setNormalArray(norms, osg.Array.BIND_OVERALL)
tcoords = osg.Vec2Array(4)
(*tcoords)[0].set(0.0,1.0)
(*tcoords)[1].set(0.0,0.0)
(*tcoords)[2].set(1.0,0.0)
(*tcoords)[3].set(1.0,1.0)
geom.setTexCoordArray(0,tcoords)
colours = osg.Vec4Array(1)
(*colours)[0].set(1.0,1.0,1.0,1.0)
geom.setColorArray(colours, osg.Array.BIND_OVERALL)
geom.addPrimitiveSet(osg.DrawArrays(osg.PrimitiveSet.QUADS,0,4))
return geom
def createSquare(corner, width, height, image):
# set up the Geometry.
geom = osg.Geometry()
coords = osg.Vec3Array(4)
(*coords)[0] = corner
(*coords)[1] = corner+width
(*coords)[2] = corner+width+height
(*coords)[3] = corner+height
geom.setVertexArray(coords)
norms = osg.Vec3Array(1)
(*norms)[0] = width^height
(*norms)[0].normalize()
geom.setNormalArray(norms, osg.Array.BIND_OVERALL)
tcoords = osg.Vec2Array(4)
(*tcoords)[0].set(0.0,0.0)
(*tcoords)[1].set(1.0,0.0)
(*tcoords)[2].set(1.0,1.0)
(*tcoords)[3].set(0.0,1.0)
geom.setTexCoordArray(0,tcoords)
colours = osg.Vec4Array(1)
(*colours)[0].set(1.0,1.0,1.0,1.0)
geom.setColorArray(colours, osg.Array.BIND_OVERALL)
geom.addPrimitiveSet(osg.DrawArrays(osg.PrimitiveSet.QUADS,0,4))
if image :
stateset = osg.StateSet()
texture = osg.Texture2D()
texture.setImage(image)
stateset.setTextureAttributeAndModes(0,texture,osg.StateAttribute.ON)
stateset.setMode(GL_LIGHTING, osg.StateAttribute.OFF)
stateset.setMode(GL_BLEND, osg.StateAttribute.ON)
stateset.setRenderingHint(osg.StateSet.TRANSPARENT_BIN)
geom.setStateSet(stateset)
return geom
def createSectorForImage(image, texmat, s, t, radius, height, length):
flip = image.getOrigin()==osg.Image.TOP_LEFT
numSegments = 20
Theta = length/radius
dTheta = Theta/(float)(numSegments-1)
ThetaZero = height*s/(t*radius)
# set up the texture.
texture = osg.Texture2D()
texture.setFilter(osg.Texture2D.MIN_FILTER,osg.Texture2D.LINEAR)
texture.setFilter(osg.Texture2D.MAG_FILTER,osg.Texture2D.LINEAR)
texture.setWrap(osg.Texture2D.WRAP_S,osg.Texture2D.CLAMP_TO_BORDER)
texture.setWrap(osg.Texture2D.WRAP_T,osg.Texture2D.CLAMP_TO_BORDER)
texture.setResizeNonPowerOfTwoHint(False)
texture.setImage(image)
# set up the drawstate.
dstate = osg.StateSet()
dstate.setMode(GL_CULL_FACE,osg.StateAttribute.OFF)
dstate.setMode(GL_LIGHTING,osg.StateAttribute.OFF)
dstate.setTextureAttributeAndModes(0, texture,osg.StateAttribute.ON)
dstate.setTextureAttribute(0, texmat)
# set up the geoset.
geom = osg.Geometry()
geom.setStateSet(dstate)
coords = osg.Vec3Array()
tcoords = osg.Vec2Array()
i = int()
angle = -Theta/2.0
for(i=0
i<numSegments
++i, angle+=dTheta)
coords.push_back(osg.Vec3(sinf(angle)*radius,cosf(angle)*radius,height*0.5)) # top
coords.push_back(osg.Vec3(sinf(angle)*radius,cosf(angle)*radius,-height*0.5)) # bottom.
tcoords.push_back(osg.Vec2(angle/ThetaZero+0.5, 0.0 if (flip) else 1.0)) # top
tcoords.push_back(osg.Vec2(angle/ThetaZero+0.5, 1.0 if (flip) else 0.0)) # bottom.
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
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)
vi = 0
for(r=0r<numRows++r)
pos.x() = origin.x()
# The quad geometry is used by the render to texture camera to generate multiple textures.
def createRTTQuad(tex_width, tex_height, useHDR):
top_group = osg.Group()
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)
(*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)
normals = osg.Vec3Array(numVertices)
sPlanetSphere.setNormalArray(normals, osg.Array.BIND_PER_VERTEX)
texcoords = osg.Vec2Array(numVertices)
sPlanetSphere.setTexCoordArray(0,texcoords)
sPlanetSphere.setTexCoordArray(1,texcoords)
delta_elevation = osg.PI / (double)(numY-1)
delta_azim = 2.0*osg.PI / (double)(numX-1)
delta_tx = 1.0 / (float)(numX-1)
delta_ty = 1.0 / (float)(numY-1)
elevation = -osg.PI*0.5
ty = 0.0
vert = 0
j = unsigned()
for(j=0
j<numY
++j, elevation+=delta_elevation, ty+=delta_ty )
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)
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,0.0,1.0)
zAxis = osg.Vec3(0.0,-1.0,0.0)
height = 100.0
width = 200.0
noSteps = 20
vertices = osg.Vec3Array()
bottom = origin
top = origin top.z()+= height
dv = xAxis*(width/((float)(noSteps-1)))
texcoords = osg.Vec2Array()
# note, when we use TextureRectangle we have to scale the tex coords up to compensate.
bottom_texcoord = osg.Vec2(0.0,0.0)
top_texcoord = osg.Vec2(0.0, tex_height if (useTextureRectangle) else 1.0)
dv_texcoord = tex_width if (osg.Vec2((useTextureRectangle) else 1.0)/(float)(noSteps-1),0.0)
for(int i=0i<noSteps++i)
vertices.push_back(top)
vertices.push_back(bottom)
top+=dv
bottom+=dv
texcoords.push_back(top_texcoord)
texcoords.push_back(bottom_texcoord)
top_texcoord+=dv_texcoord
coords = osg.Vec3Array(4)
if not dr._backPage :
(*coords)[0] = dr._center - halfWidthVector + halfHeightVector
(*coords)[1] = dr._center - halfWidthVector - halfHeightVector
(*coords)[2] = dr._center + halfWidthVector - halfHeightVector
(*coords)[3] = dr._center + halfWidthVector + halfHeightVector
else:
(*coords)[3] = dr._center - halfWidthVector + halfHeightVector
(*coords)[2] = dr._center - halfWidthVector - halfHeightVector
(*coords)[1] = dr._center + halfWidthVector - halfHeightVector
(*coords)[0] = dr._center + halfWidthVector + halfHeightVector
geom.setVertexArray(coords)
tcoords = osg.Vec2Array(4)
(*tcoords)[0].set(0.0,1.0)
(*tcoords)[1].set(0.0,0.0)
(*tcoords)[2].set(1.0,0.0)
(*tcoords)[3].set(1.0,1.0)
geom.setTexCoordArray(0,tcoords)
colours = osg.Vec4Array(1)
(*colours)[0].set(1.0,1.0,1.0,1.0)
geom.setColorArray(colours, osg.Array.BIND_OVERALL)
geom.addPrimitiveSet(osg.DrawArrays(osg.PrimitiveSet.QUADS,0,4))
# set up the geode.
geode = osg.Geode()
geode.addDrawable(geom)
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)
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
if _showAllLayers :
tileSpan /= numTiles
tileOffsetX = tileSpan * (layerNumber%numTiles)
tileOffsetY = 1 - tileSpan * (1 + layerNumber/numTiles)
vertices = osg.Vec3Array()
vertices.push_back(osg.Vec3f(tileOffsetX , tileOffsetY , 0))
vertices.push_back(osg.Vec3f(tileOffsetX , tileOffsetY + tileSpan, 0))
vertices.push_back(osg.Vec3f(tileOffsetX + tileSpan, tileOffsetY + tileSpan, 0))
vertices.push_back(osg.Vec3f(tileOffsetX + tileSpan, tileOffsetY , 0))
colors = osg.Vec3Array()
colors.push_back(osg.Vec3(1, 1, 1))
texcoords = osg.Vec2Array()
texcoords.push_back(osg.Vec2f(0, 0))
texcoords.push_back(osg.Vec2f(0, 1))
texcoords.push_back(osg.Vec2f(1, 1))
texcoords.push_back(osg.Vec2f(1, 0))
geometry = osg.Geometry()
geometry.setVertexArray(vertices)
geometry.setTexCoordArray(0, texcoords)
geometry.setColorArray(colors, osg.Array.BIND_OVERALL)
geometry.addPrimitiveSet(osg.DrawArrays(GL_QUADS, 0, 4))
geode = osg.Geode()
geode.addDrawable(geometry)
normals = osg.Vec3Array()
normals.push_back(osg.Vec3(0.0,-1.0,0.0))
polyGeom.setNormalArray(normals, osg.Array.BIND_OVERALL)
osg.Vec2 myTexCoords[] =
osg.Vec2(0,1),
osg.Vec2(0,0),
osg.Vec2(1,0),
osg.Vec2(1,1)
numTexCoords = sizeof(myTexCoords)/sizeof(osg.Vec2)
# pass the created tex coord array to the points geometry object,
# and use it to set texture unit 0.
polyGeom.setTexCoordArray(0,osg.Vec2Array(numTexCoords,myTexCoords))
# well use indices and DrawElements to define the primitive this time.
unsigned short myIndices[] =
0,
1,
3,
2
numIndices = sizeof(myIndices)/sizeof(unsigned short)
# There are three variants of the DrawElements osg.Primitive, UByteDrawElements which
# contains unsigned char indices, UShortDrawElements which contains unsigned short indices,
# and UIntDrawElements which contains ... unsigned int indices.
# The first parameter to DrawElements is
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
