def main(argv):
arguments = osg.ArgumentParser(argv)
# construct the viewer.
viewer = osgViewer.Viewer(arguments)
# set up the camera manipulators.
keyswitchManipulator = osgGA.KeySwitchMatrixManipulator()
keyswitchManipulator.addMatrixManipulator( ord("1"), "Trackball", osgGA.TrackballManipulator() )
keyswitchManipulator.addMatrixManipulator( ord("2"), "Flight", osgGA.FlightManipulator() )
keyswitchManipulator.addMatrixManipulator( ord("3"), "Drive", osgGA.DriveManipulator() )
keyswitchManipulator.addMatrixManipulator( ord("4"), "Terrain", osgGA.TerrainManipulator() )
pathfile = str()
keyForAnimationPath = ord("5")
while arguments.read("-p",pathfile) :
apm = osgGA.AnimationPathManipulator(pathfile)
if apm or not apm.valid() :
num = keyswitchManipulator.getNumMatrixManipulators()
keyswitchManipulator.addMatrixManipulator( keyForAnimationPath, "Path", apm )
keyswitchManipulator.selectMatrixManipulator(num)
++keyForAnimationPath
viewer.setCameraManipulator( keyswitchManipulator )
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().setApplicationName(arguments.getApplicationName())
arguments.getApplicationUsage().setDescription(arguments.getApplicationName()+" example provides an interactive viewer for visualising point clouds..")
arguments.getApplicationUsage().setCommandLineUsage(arguments.getApplicationName()+" [options] filename ...")
arguments.getApplicationUsage().addCommandLineOption("-h or --help","Display this information")
arguments.getApplicationUsage().addCommandLineOption("--snow <density>","Set the snow with a density between 0 and 1.0")
arguments.getApplicationUsage().addCommandLineOption("--rain <density>","")
arguments.getApplicationUsage().addCommandLineOption("--particleSize <size>","")
arguments.getApplicationUsage().addCommandLineOption("--particleColour <red> <green> <blue> <alpha>","")
arguments.getApplicationUsage().addCommandLineOption("--wind <x> <y> <z>","Set the wind speed in model coordinates")
arguments.getApplicationUsage().addCommandLineOption("--particleSpeed <float>","Set the particle speed")
arguments.getApplicationUsage().addCommandLineOption("--nearTransition <distance>","Set the near transistion distance")
arguments.getApplicationUsage().addCommandLineOption("--farTransition <distance>","Set the far transistion distance")
arguments.getApplicationUsage().addCommandLineOption("--particleDensity <density>","Set the particle density")
arguments.getApplicationUsage().addCommandLineOption("--cellSize <x> <y> <z>","Set the cell size in model coordinates")
arguments.getApplicationUsage().addCommandLineOption("--fogDensity <density>","Set the fog density")
arguments.getApplicationUsage().addCommandLineOption("--fogColour <red> <green> <blue> <alpha>","Set fog colour.")
arguments.getApplicationUsage().addCommandLineOption("-useFarLineSegments","Switch on the use of line segments")
# construct the viewer.
viewer = osgViewer.Viewer()
# set up the camera manipulators.
keyswitchManipulator = osgGA.KeySwitchMatrixManipulator()
keyswitchManipulator.addMatrixManipulator( ord("1"), "Trackball", osgGA.TrackballManipulator() )
keyswitchManipulator.addMatrixManipulator( ord("2"), "Flight", osgGA.FlightManipulator() )
keyswitchManipulator.addMatrixManipulator( ord("3"), "Drive", osgGA.DriveManipulator() )
keyswitchManipulator.addMatrixManipulator( ord("4"), "Terrain", osgGA.TerrainManipulator() )
pathfile = str()
keyForAnimationPath = ord("5")
while arguments.read("-p",pathfile) :
apm = osgGA.AnimationPathManipulator(pathfile)
if apm or not apm.valid() :
num = keyswitchManipulator.getNumMatrixManipulators()
keyswitchManipulator.addMatrixManipulator( keyForAnimationPath, "Path", apm )
keyswitchManipulator.selectMatrixManipulator(num)
++keyForAnimationPath
viewer.setCameraManipulator( keyswitchManipulator )
def main(argv):
# use an ArgumentParser object to manage the program arguments.
arguments = osg.ArgumentParser(argv)
# read the scene from the list of file specified commandline args.
scene = osgDB.readNodeFiles(arguments)
if not scene and arguments.read("--relative-camera-scene") :
# Create a test scene with a camera that has a relative reference frame.
group = osg.Group()
sphere = osg.Geode()
sphere.setName("Sphere")
sphere.addDrawable(osg.ShapeDrawable(osg.Sphere()))
cube = osg.Geode()
cube.setName("Cube")
cube.addDrawable(osg.ShapeDrawable(osg.Box()))
camera = osg.Camera()
camera.setRenderOrder(osg.Camera.POST_RENDER)
camera.setClearMask(GL_DEPTH_BUFFER_BIT)
camera.setReferenceFrame(osg.Transform.RELATIVE_RF)
camera.setViewMatrix(osg.Matrix.translate(-2, 0, 0))
xform = osg.MatrixTransform(osg.Matrix.translate(1, 1, 1))
xform.addChild(camera)
group.addChild(sphere)
group.addChild(xform)
camera.addChild(cube)
scene = group
# if not loaded assume no arguments passed in, try use default mode instead.
if not scene : scene = osgDB.readNodeFile("fountain.osgt")
group = dynamic_cast<osg.Group*>(scene)
if not group :
group = osg.Group()
group.addChild(scene)
updateText = osgText.Text()
# add the HUD subgraph.
group.addChild(createHUD(updateText))
if arguments.read("--CompositeViewer") :
view = osgViewer.View()
# add the handler for doing the picking
view.addEventHandler(PickHandler(updateText))
# set the scene to render
view.setSceneData(group)
view.setUpViewAcrossAllScreens()
viewer = osgViewer.CompositeViewer()
viewer.addView(view)
return viewer.run()
else:
viewer = osgViewer.Viewer()
# add all the camera manipulators
keyswitchManipulator = osgGA.KeySwitchMatrixManipulator()
keyswitchManipulator.addMatrixManipulator( ord("1"), "Trackball", osgGA.TrackballManipulator() )
keyswitchManipulator.addMatrixManipulator( ord("2"), "Flight", osgGA.FlightManipulator() )
keyswitchManipulator.addMatrixManipulator( ord("3"), "Drive", osgGA.DriveManipulator() )
num = keyswitchManipulator.getNumMatrixManipulators()
keyswitchManipulator.addMatrixManipulator( ord("4"), "Terrain", osgGA.TerrainManipulator() )
pathfile = str()
keyForAnimationPath = ord("5")
while arguments.read("-p",pathfile) :
apm = osgGA.AnimationPathManipulator(pathfile)
if apm or not apm.valid() :
num = keyswitchManipulator.getNumMatrixManipulators()
keyswitchManipulator.addMatrixManipulator( keyForAnimationPath, "Path", apm )
++keyForAnimationPath
keyswitchManipulator.selectMatrixManipulator(num)
viewer.setCameraManipulator( keyswitchManipulator )
# add the handler for doing the picking
viewer.addEventHandler(PickHandler(updateText))
# set the scene to render
viewer.setSceneData(group)
return viewer.run()
def main(argv):
# use an ArgumentParser object to manage the program arguments.
arguments = osg.ArgumentParser(argv)
# construct the viewer.
viewer = osgViewer.Viewer()
# load the nodes from the commandline arguments.
loadedModel = osgDB.readNodeFiles(arguments)
# if not loaded assume no arguments passed in, try use default mode instead.
if not loadedModel : loadedModel = osgDB.readNodeFile("cow.osgt")
if not loadedModel :
print arguments.getApplicationName(), ": No data loaded"
return 1
if arguments.read("--dome") or arguments.read("--puffer") :
setDomeCorrection(viewer, arguments)
viewer.setSceneData( loadedModel )
elif arguments.read("--faces") :
setDomeFaces(viewer, arguments)
viewer.setSceneData( loadedModel )
else:
distortionNode = createDistortionSubgraph( loadedModel, viewer.getCamera().getClearColor())
viewer.setSceneData( distortionNode )
while arguments.read("--sky-light") :
viewer.setLightingMode(osg.View.SKY_LIGHT)
if viewer.getLightingMode()==osg.View.HEADLIGHT :
viewer.getLight().setPosition(osg.Vec4(0.0,0.0,0.0,1.0))
# load the nodes from the commandline arguments.
if not viewer.getSceneData() :
osg.notify(osg.NOTICE), "Please specify a model filename on the command line."
return 1
# set up the camera manipulators.
keyswitchManipulator = osgGA.KeySwitchMatrixManipulator()
keyswitchManipulator.addMatrixManipulator( ord("1"), "Trackball", osgGA.TrackballManipulator() )
keyswitchManipulator.addMatrixManipulator( ord("2"), "Flight", osgGA.FlightManipulator() )
keyswitchManipulator.addMatrixManipulator( ord("3"), "Drive", osgGA.DriveManipulator() )
keyswitchManipulator.addMatrixManipulator( ord("4"), "Terrain", osgGA.TerrainManipulator() )
pathfile = str()
keyForAnimationPath = ord("5")
while arguments.read("-p",pathfile) :
apm = osgGA.AnimationPathManipulator(pathfile)
if apm or not apm.valid() :
num = keyswitchManipulator.getNumMatrixManipulators()
keyswitchManipulator.addMatrixManipulator( keyForAnimationPath, "Path", apm )
keyswitchManipulator.selectMatrixManipulator(num)
++keyForAnimationPath
viewer.setCameraManipulator( keyswitchManipulator )
viewer.setThreadingModel(osgViewer.Viewer.SingleThreaded)
# add the state manipulator
viewer.addEventHandler( osgGA.StateSetManipulator(viewer.getCamera().getOrCreateStateSet()) )
# add the stats handler
viewer.addEventHandler(osgViewer.StatsHandler)()
return viewer.run()
def main(argv):
# use an ArgumentParser object to manage the program arguments.
arguments = osg.ArgumentParser(argv)
arguments.getApplicationUsage().addCommandLineOption("-v","Set the terrain vertical scale.")
arguments.getApplicationUsage().addCommandLineOption("-r","Set the terrain sample ratio.")
arguments.getApplicationUsage().addCommandLineOption("--login <url> <username> <password>","Provide authentication information for http file access.")
# construct the viewer.
viewer = osgViewer.Viewer(arguments)
# set the tile loaded callback to load the optional imagery
whiteList = osgTerrain.WhiteListTileLoadedCallback()
setname = str()
while arguments.read("--allow",setname) :
whiteList.allow(setname)
while arguments.read("--allow-all") :
whiteList.setAllowAll(True)
osgTerrain.TerrainTile.setTileLoadedCallback(whiteList)
# obtain the vertical scale
verticalScale = 1.0
while arguments.read("-v",verticalScale) :
# obtain the sample ratio
sampleRatio = 1.0
while arguments.read("-r",sampleRatio) :
# set up any authentication.
str url, username, password
while arguments.read("--login",url, username, password) :
if not osgDB.Registry.instance().getAuthenticationMap() :
osgDB.Registry.instance().setAuthenticationMap(osgDB.AuthenticationMap)()
osgDB.Registry.instance().getAuthenticationMap().addAuthenticationDetails(
url,
osgDB.AuthenticationDetails(username, password)
)
# add all the event handlers to the viewer
# add the state manipulator
viewer.addEventHandler( osgGA.StateSetManipulator(viewer.getCamera().getOrCreateStateSet()) )
# add the thread model handler
viewer.addEventHandler(osgViewer.ThreadingHandler)()
# add the window size toggle handler
viewer.addEventHandler(osgViewer.WindowSizeHandler)()
# add the stats handler
viewer.addEventHandler(osgViewer.StatsHandler)()
# add the help handler
viewer.addEventHandler(osgViewer.HelpHandler(arguments.getApplicationUsage()))
# add the record camera path handler
viewer.addEventHandler(osgViewer.RecordCameraPathHandler)()
# add the LOD Scale handler
viewer.addEventHandler(osgViewer.LODScaleHandler)()
# add all the camera manipulators
keyswitchManipulator = osgGA.KeySwitchMatrixManipulator()
keyswitchManipulator.addMatrixManipulator( ord("1"), "Trackball", osgGA.TrackballManipulator() )
keyswitchManipulator.addMatrixManipulator( ord("2"), "Flight", osgGA.FlightManipulator() )
keyswitchManipulator.addMatrixManipulator( ord("3"), "Drive", osgGA.DriveManipulator() )
num = keyswitchManipulator.getNumMatrixManipulators()
keyswitchManipulator.addMatrixManipulator( ord("4"), "Terrain", osgGA.TerrainManipulator() )
pathfile = str()
keyForAnimationPath = ord("5")
while arguments.read("-p",pathfile) :
apm = osgGA.AnimationPathManipulator(pathfile)
if apm or not apm.valid() :
num = keyswitchManipulator.getNumMatrixManipulators()
keyswitchManipulator.addMatrixManipulator( keyForAnimationPath, "Path", apm )
++keyForAnimationPath
keyswitchManipulator.selectMatrixManipulator(num)
viewer.setCameraManipulator( keyswitchManipulator )
# set up the scene graph
# load the nodes from the commandline arguments.
rootnode = osgDB.readNodeFiles(arguments)
if not rootnode :
osg.notify(osg.NOTICE), "Warning: no valid data loaded, please specify a database on the command line."
return 1
terrain = findTopMostNodeOfType<osgTerrain.Terrain>(rootnode)
if not terrain :
terrain = osgTerrain.Terrain()
csn = findTopMostNodeOfType<osg.CoordinateSystemNode>(rootnode)
if csn :
terrain.set(*csn)
terrain.addChild(rootnode)
rootnode = terrain
csn = terrain
terrain.setSampleRatio(sampleRatio)
terrain.setVerticalScale(verticalScale)
# register our custom handler for adjust Terrain settings
viewer.addEventHandler(TerrainHandler(terrain))
numLayers = 1
mtc = findTopMostNodeOfType<osgFX.MultiTextureControl>(rootnode)
if mtc :
numLayers = mtc.getNumTextureWeights()
# switch on just the first texture layer.
mtc.setTextureWeight(0,1.0)
for(unsigned int i=1 i<numLayers ++i)
mtc.setTextureWeight(i,0.0)
if numLayers<2 :
osg.notify(osg.NOTICE), "Warning: scene must have MultiTextureControl node with at least 2 texture units defined."
return 1
maxElevationTransition = 1e6
elevations = ElevationLayerBlendingCallback.Elevations()
for(unsigned int i=0 i<numLayers ++i)
elevations.push_back(maxElevationTransition)
maxElevationTransition /= 2.0
# we must assign callback as both an update and cull callback, as update callback to do the update of
# the the osgFX.MultiTextureControl node a thread safe way, and as a cull callback to gather the camera
# position information.
elbc = ElevationLayerBlendingCallback(mtc, elevations)
terrain.setUpdateCallback(elbc)
terrain.setCullCallback(elbc)
# add a viewport to the viewer and attach the scene graph.
viewer.setSceneData( rootnode )
# create the windows and run the threads.
viewer.realize()
return viewer.run()
def main(argv):
arguments = osg.ArgumentParser(argv)
# construct the viewer.
viewer = osgViewer.Viewer(arguments)
# set up camera manipulators
keyswitchManipulator = osgGA.KeySwitchMatrixManipulator()
keyswitchManipulator.addMatrixManipulator( ord("1"), "Trackball", osgGA.TrackballManipulator() )
keyswitchManipulator.addMatrixManipulator( ord("2"), "Flight", osgGA.FlightManipulator() )
keyswitchManipulator.addMatrixManipulator( ord("3"), "Drive", osgGA.DriveManipulator() )
keyswitchManipulator.addMatrixManipulator( ord("4"), "Terrain", osgGA.TerrainManipulator() )
keyForAnimationPath = ord("8")
animationSpeed = 1.0
while arguments.read("--speed",animationSpeed) :
pathfile = str()
while arguments.read("-p",pathfile) :
apm = osgGA.AnimationPathManipulator(pathfile)
if apm or not apm.valid() :
apm.setTimeScale(animationSpeed)
apm.setAnimationCompletedCallback(ReportStatsAnimationCompletedCallback())
num = keyswitchManipulator.getNumMatrixManipulators()
keyswitchManipulator.addMatrixManipulator( keyForAnimationPath, "Path", apm )
keyswitchManipulator.selectMatrixManipulator(num)
++keyForAnimationPath
viewer.setCameraManipulator( keyswitchManipulator )
# set up event handlers
viewer.addEventHandler( osgViewer.StatsHandler())
viewer.addEventHandler( osgViewer.WindowSizeHandler() )
viewer.addEventHandler( osgGA.StateSetManipulator(viewer.getCamera().getOrCreateStateSet()) )
viewer.addEventHandler( TexturePoolHandler() )
########################################/
#
# IncrementalCompileOperation settings
#
incrementalCompile = osgUtil.IncrementalCompileOperation()
viewer.setIncrementalCompileOperation(incrementalCompile)
if arguments.read("--force") or arguments.read("-f") :
incrementalCompile.assignForceTextureDownloadGeometry()
if arguments.read("-a") :
incrementalCompile.setMinimumTimeAvailableForGLCompileAndDeletePerFrame(1)
incrementalCompile.setConservativeTimeRatio(1)
incrementalCompile.setMaximumNumOfObjectsToCompilePerFrame(100)
elif arguments.read("-c") :
incrementalCompile.setMinimumTimeAvailableForGLCompileAndDeletePerFrame(0.0001)
incrementalCompile.setConservativeTimeRatio(0.01)
incrementalCompile.setMaximumNumOfObjectsToCompilePerFrame(1)
########################################/
#
# SceneGraph processing setup
#
sceneGraphProcessor = SceneGraphProcessor(arguments)
########################################/
#
# Database settings
#
timeBetweenMerges = 2.0
while arguments.read("--interval",timeBetweenMerges) :
outputPostfix = str()
while arguments.read("-o",outputPostfix) : OSG_NOTICE, "Set ouputPostfix to ", outputPostfix
typedef std.vector< str > FileNames
fileNames = FileNames()
for(int pos=1pos<arguments.argc()++pos)
if not arguments.isOption(pos) :
fileNames.push_back(arguments[pos])
if fileNames.empty() :
OSG_NOTICE, "No files loaded, please specify files on commandline."
return 1
# load the models using a paging thread and use the incremental compile operation to
# manage the compilation of GL objects without breaking frame.
modelIndex = 0
databasePagingThread = osg.OperationThread()
databasePagingOperation = DatabasePagingOperation()
databasePagingThread = osg.OperationThread()
databasePagingThread.startThread()
group = osg.Group()
viewer.setSceneData(group)
viewer.realize()
filename = fileNames[modelIndex++]
outputFilename = str() : osgDB: if (outputPostfix.empty()) else getStrippedName(filename)+outputPostfix
databasePagingOperation = DatabasePagingOperation(
filename,
outputFilename,
sceneGraphProcessor,
incrementalCompile)
databasePagingThread.add(databasePagingOperation)
timeOfLastMerge = viewer.getFrameStamp().getReferenceTime()
while not viewer.done() :
viewer.frame()
currentTime = viewer.getFrameStamp().getReferenceTime()
if not databasePagingOperation and
modelIndex<fileNames.size() and
(currentTime-timeOfLastMerge)>timeBetweenMerges :
filename = fileNames[modelIndex++]
outputFilename = str() : osgDB: if (outputPostfix.empty()) else getStrippedName(filename)+outputPostfix
databasePagingOperation = DatabasePagingOperation(
filename,
outputFilename,
sceneGraphProcessor,
incrementalCompile)
databasePagingThread.add(databasePagingOperation)
if databasePagingOperation and databasePagingOperation._modelReadyToMerge :
OSG_NOTICE, "Merging subgraph"
timeOfLastMerge = currentTime
group.removeChildren(0,group.getNumChildren())
group.addChild(databasePagingOperation._loadedModel)
viewer.home()
# we no longer need the paging operation as it's done it's job.
databasePagingOperation = 0
viewer.home()
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 node tracker.")
arguments.getApplicationUsage().setCommandLineUsage(arguments.getApplicationName())
arguments.getApplicationUsage().addCommandLineOption("-h or --help","Display this information")
# construct the viewer.
viewer = osgViewer.Viewer(arguments)
# add the state manipulator
viewer.addEventHandler( osgGA.StateSetManipulator(viewer.getCamera().getOrCreateStateSet()) )
# add the thread model handler
viewer.addEventHandler(osgViewer.ThreadingHandler)()
# add the window size toggle handler
viewer.addEventHandler(osgViewer.WindowSizeHandler)()
# add the stats handler
viewer.addEventHandler(osgViewer.StatsHandler)()
# add the record camera path handler
viewer.addEventHandler(osgViewer.RecordCameraPathHandler)()
# add the help handler
viewer.addEventHandler(osgViewer.HelpHandler(arguments.getApplicationUsage()))
# set the near far ration computation up.
viewer.getCamera().setComputeNearFarMode(osg.CullSettings.COMPUTE_NEAR_FAR_USING_PRIMITIVES)
viewer.getCamera().setNearFarRatio(0.000003)
speed = 1.0
while arguments.read("-f") or arguments.read("--fixed") : speed = 0.0
rotation = osg.Quat()
vec4 = osg.Vec4()
while arguments.read("--rotate-model",vec4[0],vec4[1],vec4[2],vec4[3]) :
local_rotate = osg.Quat()
local_rotate.makeRotate(osg.DegreesToRadians(vec4[0]),vec4[1],vec4[2],vec4[3])
rotation = rotation * local_rotate
nc = 0
flightpath_filename = str()
while arguments.read("--flight-path",flightpath_filename) :
fin = osgDB.ifstream(flightpath_filename.c_str())
if fin :
path = osg.AnimationPath()
path.read(fin)
nc = osg.AnimationPathCallback(path)
trackerMode = osgGA.NodeTrackerManipulator.NODE_CENTER_AND_ROTATION
mode = str()
while arguments.read("--tracker-mode",mode) :
if mode=="NODE_CENTER_AND_ROTATION" : trackerMode = osgGA.NodeTrackerManipulator.NODE_CENTER_AND_ROTATION
elif mode=="NODE_CENTER_AND_AZIM" : trackerMode = osgGA.NodeTrackerManipulator.NODE_CENTER_AND_AZIM
elif mode=="NODE_CENTER" : trackerMode = osgGA.NodeTrackerManipulator.NODE_CENTER
else:
print "Unrecognized --tracker-mode option ", mode, ", valid options are:"
print " NODE_CENTER_AND_ROTATION"
print " NODE_CENTER_AND_AZIM"
print " NODE_CENTER"
return 1
rotationMode = osgGA.NodeTrackerManipulator.TRACKBALL
while arguments.read("--rotation-mode",mode) :
if mode=="TRACKBALL" : rotationMode = osgGA.NodeTrackerManipulator.TRACKBALL
elif mode=="ELEVATION_AZIM" : rotationMode = osgGA.NodeTrackerManipulator.ELEVATION_AZIM
else:
print "Unrecognized --rotation-mode option ", mode, ", valid options are:"
print " TRACKBALL"
print " ELEVATION_AZIM"
return 1
useOverlay = True
while arguments.read("--no-overlay") or arguments.read("-n") : useOverlay = False
technique = osgSim.OverlayNode.OBJECT_DEPENDENT_WITH_ORTHOGRAPHIC_OVERLAY
while arguments.read("--object") : technique = osgSim.OverlayNode.OBJECT_DEPENDENT_WITH_ORTHOGRAPHIC_OVERLAY
while arguments.read("--ortho") or arguments.read("--orthographic") : technique = osgSim.OverlayNode.VIEW_DEPENDENT_WITH_ORTHOGRAPHIC_OVERLAY
while arguments.read("--persp") or arguments.read("--perspective") : technique = osgSim.OverlayNode.VIEW_DEPENDENT_WITH_PERSPECTIVE_OVERLAY
overlayTextureUnit = 1
while arguments.read("--unit", overlayTextureUnit) :
pathfile = str()
while arguments.read("-p",pathfile) :
addFireEffect = arguments.read("--fire")
# if user request help write it out to cout.
if arguments.read("-h") or arguments.read("--help") :
arguments.getApplicationUsage().write(std.cout)
return 1
tm = osgGA.NodeTrackerManipulator()
overlayFilename = str()
while arguments.read("--overlay", overlayFilename) :
# read the scene from the list of file specified commandline args.
root = osgDB.readNodeFiles(arguments)
if not root : root = createEarth()
if not root : return 0
if not overlayFilename.empty() :
#osg.Object *pObj = osgDB.readObjectFile("alaska_clean.shp")
#osg.Geode shapefile = dynamic_cast<osg.Geode*> (pObj)
#
#ConvertLatLon2EllipsoidCoordinates latlon2em
#shapefile.accept(latlon2em)
shapefile = osgDB.readNodeFile(overlayFilename)
if not shapefile :
osg.notify(osg.NOTICE), "File `", overlayFilename, "` not found"
return 1
csn = dynamic_cast<osg.CoordinateSystemNode*>(root)
if csn :
overlayNode = osgSim.OverlayNode(technique)
overlayNode.getOrCreateStateSet().setTextureAttribute(1, osg.TexEnv(osg.TexEnv.DECAL))
overlayNode.setOverlaySubgraph(shapefile)
overlayNode.setOverlayTextureSizeHint(1024)
overlayNode.setOverlayTextureUnit(overlayTextureUnit)
# insert the OverlayNode between the coordinate system node and its children.
for(unsigned int i=0 i<csn.getNumChildren() ++i)
overlayNode.addChild( csn.getChild(i) )
csn.removeChildren(0, csn.getNumChildren())
csn.addChild(overlayNode)
viewer.setSceneData(csn)
else:
overlayNode = osgSim.OverlayNode(technique)
overlayNode.getOrCreateStateSet().setTextureAttribute(1, osg.TexEnv(osg.TexEnv.DECAL))
overlayNode.setOverlaySubgraph(shapefile)
overlayNode.setOverlayTextureSizeHint(1024)
overlayNode.addChild(root)
viewer.setSceneData(overlayNode)
else:
# add a viewport to the viewer and attach the scene graph.
viewer.setSceneData(root)
csn = dynamic_cast<osg.CoordinateSystemNode*>(root)
if csn :
overlayNode = osgSim.OverlayNode()
if useOverlay :
overlayNode = osgSim.OverlayNode(technique)
# insert the OverlayNode between the coordinate system node and its children.
for(unsigned int i=0 i<csn.getNumChildren() ++i)
overlayNode.addChild( csn.getChild(i) )
csn.removeChildren(0, csn.getNumChildren())
csn.addChild(overlayNode)
# tell the overlay node to continously update its overlay texture
# as we know we'll be tracking a moving target.
overlayNode.setContinuousUpdate(True)
cessna = osgDB.readNodeFile("cessna.osgt")
if cessna :
s = 200000.0 / cessna.getBound().radius()
scaler = osg.MatrixTransform()
scaler.addChild(cessna)
scaler.setMatrix(osg.Matrixd.scale(s,s,s)*osg.Matrixd.rotate(rotation))
scaler.getOrCreateStateSet().setMode(GL_RESCALE_NORMAL,osg.StateAttribute.ON)
if addFireEffect :
center = cessna.getBound().center()
fire = osgParticle.FireEffect(center, 10.0)
scaler.addChild(fire)
if False :
ss = osgSim.SphereSegment(
osg.Vec3(0.0,0.0,0.0), # center
19.9, # radius
osg.DegreesToRadians(135.0),
osg.DegreesToRadians(240.0),
osg.DegreesToRadians(-10.0),
osg.DegreesToRadians(30.0),
60)
scaler.addChild(ss)
mt = osg.MatrixTransform()
mt.addChild(scaler)
if not nc : nc = ModelPositionCallback(speed)
mt.setUpdateCallback(nc)
csn.addChild(mt)
# if we are using an overaly node, use the cessna subgraph as the overlay subgraph
if overlayNode.valid() :
overlayNode.setOverlaySubgraph(mt)
tm = osgGA.NodeTrackerManipulator()
tm.setTrackerMode(trackerMode)
tm.setRotationMode(rotationMode)
tm.setTrackNode(scaler)
else:
print "Failed to read cessna.osgt"
# set up camera manipulators.
keyswitchManipulator = osgGA.KeySwitchMatrixManipulator()
if tm.valid() : keyswitchManipulator.addMatrixManipulator( ord("0"), "NodeTracker", tm )
keyswitchManipulator.addMatrixManipulator( ord("1"), "Trackball", osgGA.TrackballManipulator() )
keyswitchManipulator.addMatrixManipulator( ord("2"), "Flight", osgGA.FlightManipulator() )
keyswitchManipulator.addMatrixManipulator( ord("3"), "Drive", osgGA.DriveManipulator() )
keyswitchManipulator.addMatrixManipulator( ord("4"), "Terrain", osgGA.TerrainManipulator() )
if not pathfile.empty() :
apm = osgGA.AnimationPathManipulator(pathfile)
if apm or not apm.valid() :
num = keyswitchManipulator.getNumMatrixManipulators()
keyswitchManipulator.addMatrixManipulator( ord("5"), "Path", apm )
keyswitchManipulator.selectMatrixManipulator(num)
viewer.setCameraManipulator( keyswitchManipulator )
# viewer.setThreadingModel(osgViewer.Viewer.SingleThreaded)
return viewer.run()
if __name__ == "__main__":
main(sys.argv)
arguments.writeErrorMessages(std.cout)
return 1
if arguments.argc()<=1 :
arguments.getApplicationUsage().write(std.cout,osg.ApplicationUsage.COMMAND_LINE_OPTION)
return 1
viewer = osgViewer.Viewer()
# set up the camera manipulators.
keyswitchManipulator = osgGA.KeySwitchMatrixManipulator()
keyswitchManipulator.addMatrixManipulator( ord("1"), "Trackball", osgGA.TrackballManipulator() )
keyswitchManipulator.addMatrixManipulator( ord("2"), "Flight", osgGA.FlightManipulator() )
keyswitchManipulator.addMatrixManipulator( ord("3"), "Drive", osgGA.DriveManipulator() )
keyswitchManipulator.addMatrixManipulator( ord("4"), "Terrain", osgGA.TerrainManipulator() )
pathfile = str()
keyForAnimationPath = ord("5")
while arguments.read("-p",pathfile) :
apm = osgGA.AnimationPathManipulator(pathfile)
if apm or not apm.valid() :
num = keyswitchManipulator.getNumMatrixManipulators()
keyswitchManipulator.addMatrixManipulator( keyForAnimationPath, "Path", apm )
keyswitchManipulator.selectMatrixManipulator(num)
++keyForAnimationPath
viewer.setCameraManipulator( keyswitchManipulator )
# add the state manipulator
viewer.addEventHandler( osgGA.StateSetManipulator(viewer.getCamera().getOrCreateStateSet()) )