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 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.
# pass the created vertex array to the points geometry object.
polyGeom.setVertexArray(osg.Vec3Array(numCoords,myCoords))
colors = osg.Vec4Array()
colors.push_back(osg.Vec4(1.0,1.0,1.0,1.0))
polyGeom.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))
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,
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 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
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)
vertices.push_back(cursor)
texcoords.push_back(osg.Vec2((sin(texcoord.x()*osg.PI-osg.PI*0.5)+1.0)*0.5,(sin(texcoord.y()*osg.PI-osg.PI*0.5)+1.0)*0.5))
colors.push_back(osg.Vec4(1.0,1.0,1.0,1.0))
cursor += dx
texcoord += dx_texcoord
# pass the created vertex array to the points geometry object.
polyGeom.setVertexArray(vertices)
polyGeom.setColorArray(colors, osg.Array.BIND_PER_VERTEX)
polyGeom.setTexCoordArray(0,texcoords)
for(i=0i<noSteps-1++i)
elements = osg.DrawElementsUShort(osg.PrimitiveSet.QUAD_STRIP)
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()
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)
t[vi].set(tex.x(),tex.y())
pos.x()+=columnCoordDelta
tex.x()+=columnTexDelta
++vi
pos.y() += rowCoordDelta
tex.y() += rowTexDelta
geometry.setVertexArray(v)
geometry.setColorArray(color, osg.Array.BIND_OVERALL)
# 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)
class PosterPrinter (osg.Referenced) :
typedef std.pair<unsigned int, unsigned int> TilePosition
typedef std.map< TilePosition, osg.Image > TileImages
PosterPrinter()
#* Set to output each sub-image-tile to disk
def setOutputTiles(b):
_outputTiles = b
def getOutputTiles():
return _outputTiles
#* Set the output sub-image-tile extension, e.g. bmp
def setOutputTileExtension(ext):
_outputTileExt = ext
def getOutputTileExtension():
return _outputTileExt
#* Set the output poster name, e.g. output.bmp
def setOutputPosterName(name):
_outputPosterName = name
def getOutputPosterName():
return _outputPosterName
#* Set the size of each sub-image-tile, e.g. 640x480
def setTileSize(w, h):
_tileSize.set(w, h)
def getTileSize():
return _tileSize
#* Set the final size of the high-res poster, e.g. 6400x4800
def setPosterSize(w, h):
_posterSize.set(w, h)
def getPosterSize():
return _posterSize
#* Set the capturing camera
def setCamera(camera):
_camera = camera
def getCamera():
return _camera
#* Set the final poster image, should be already allocated
def setFinalPoster(image):
_finalPoster = image
def getFinalPoster():
return _finalPoster
def getPosterVisitor():
return _visitor
def getPosterVisitor():
return _visitor
def done():
return not _isRunning and not _isFinishing
init = void( osg.Camera* camera )
init = void( osg.Matrixd view, osg.Matrixd proj )
frame = void( osg.FrameStamp* fs, osg.Node* node )
virtual ~PosterPrinter()
addCullCallbacks = bool( osg.FrameStamp* fs, osg.Node* node )
removeCullCallbacks = void( osg.Node* node )
bindCameraToImage = void( osg.Camera* camera, int row, int col )
recordImages = void()
_outputTiles = bool()
_outputTileExt = str()
_outputPosterName = str()
_tileSize = osg.Vec2()
_posterSize = osg.Vec2()
_isRunning = bool()
_isFinishing = bool()
_lastBindingFrame = unsigned int()
_tileRows = int()
_tileColumns = int()
_currentRow = int()
_currentColumn = int()
_intersector = PosterIntersector()
_visitor = PosterVisitor()
_currentViewMatrix = osg.Matrixd()
_currentProjectionMatrix = osg.Matrixd()
_camera = osg.Camera()
_finalPoster = osg.Image()
_images = TileImages()
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)
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
bottom_texcoord+=dv_texcoord
