def handle(ea, aa): viewer = dynamic_cast<osgViewer.Viewer*>(aa) if not viewer : return False switch(ea.getEventType()) case(osgGA.GUIEventAdapter.KEYUP): if ea.getKey()==ord("s") : saveSelectedModel(viewer.getSceneData()) elif ea.getKey()==ord("o") : osg.notify(osg.NOTICE), "Saved model to file 'saved_model.osgt'" osgDB.writeNodeFile(*(viewer.getSceneData()), "saved_model.osgt") elif ea.getKey()==ord("p") : _usePolytopeIntersector = not _usePolytopeIntersector if _usePolytopeIntersector : osg.notify(osg.NOTICE), "Using PolytopeIntersector" else: osg.notify(osg.NOTICE), "Using LineSegmentIntersector" elif ea.getKey()==ord("c") : _useWindowCoordinates = not _useWindowCoordinates if _useWindowCoordinates : osg.notify(osg.NOTICE), "Using window coordinates for picking" else: osg.notify(osg.NOTICE), "Using projection coordiates for picking" elif ea.getKey()==osgGA.GUIEventAdapter.KEY_Delete or ea.getKey()==osgGA.GUIEventAdapter.KEY_BackSpace : osg.notify(osg.NOTICE), "Delete" dsnv = DeleteSelectedNodesVisitor() viewer.getSceneData().accept(dsnv) dsnv.pruneSelectedNodes() return False
def apply(plod): # go through all the named children and write them out to disk. for(unsigned int i=0i<plod.getNumChildren()++i) child = plod.getChild(i) filename = plod.getFileName(i) if not filename.empty() : osg.notify(osg.NOTICE), "Writing out ", filename osgDB.writeNodeFile(*child,filename)
def saveSelectedModel(scene): if not scene : return cmtsv = CreateModelToSaveVisitor() scene.accept(cmtsv) if cmtsv._group.getNumChildren()>0 : print "Writing selected compoents to 'selected_model.osgt'" osgDB.writeNodeFile(*cmtsv._group, "selected_model.osgt")
def main(argv): # use an ArgumentParser object to manage the program arguments. viewer = osgViewer.Viewer() # viewer.setThreadingModel(osgViewer.Viewer.SingleThreaded) # read the scene from the list of file specified commandline args. loadedModel = osgDB.readNodeFile("cessna.osg") if loadedModel == None: raise Exception('Could not load model file (is OSG_FILE_PATH set and correct?)') # create a transform to spin the model. loadedModelTransform = osg.MatrixTransform() loadedModelTransform.addChild(loadedModel) print loadedModelTransform.getBound()._center #todo: nc = osg.AnimationPathCallback(loadedModelTransform.getBound()._center,osg.Vec3(0.0,0.0,1.0),osg.inDegrees(45.0)); # loadedModelTransform.setUpdateCallback(nc) rootNode = osg.Group() rootNode.stateSet.dataVariance = osg.Object.DYNAMIC rootNode.addChild(createMirroredScene(loadedModelTransform)) viewer.addEventHandler(osgViewer.HelpHandler()) viewer.addEventHandler(osgViewer.StatsHandler()) viewer.addEventHandler(osgGA.StateSetManipulator(rootNode.stateSet)) viewer.setSceneData(rootNode) print "set scene data" #hint to tell viewer to request stencil buffer when setting up windows # osg.DisplaySettings().setMinimumNumStencilBits(8) osg.DisplaySettings.instance().setMinimumNumStencilBits(8); osgDB.writeNodeFile(rootNode, "test_reflect.osg"); viewer.run() #we need run, because that sets up a trackballmanipulator and so we have the correct "look" into the scene. return 0
def main(argv): arguments = osg.ArgumentParser(argv) node = osg.Group() if arguments.read("--MyUserDataContainer") or arguments.read("--mydc") : node.setUserDataContainer(MyNamespace.MyUserDataContainer)() i = 10 node.setUserValue("Int value",i) testString = str("All seems fine") node.setUserValue("Status",testString) node.setUserValue("Height",float(1.4)) drawable = osg.Geometry() drawable.setName("myDrawable") node.getOrCreateUserDataContainer().addUserObject(drawable) node.setUserValue("fred",12) node.setUserValue("john",1.1) node.setUserValue("david",1.9) node.setUserValue("char",char(65)) node.setUserValue("matrixd",osg.Matrixd.translate(1.0,2.0,3.0)) node.setUserValue("flag-on",True) node.setUserValue("flag-off",False) OSG_NOTICE, "Testing results for values set directly on scene graph" testResults(node) osgDB.writeNodeFile(*node, "results.osgt") from_osgt = osgDB.readNodeFile("results.osgt") if from_osgt.valid() : OSG_NOTICE, "Testing results for values from scene graph read from .osgt file" testResults(from_osgt) osgDB.writeNodeFile(*node, "results.osgb") from_osgb = osgDB.readNodeFile("results.osgb") if from_osgb.valid() : OSG_NOTICE, "Testing results for values from scene graph read from .osgb file" testResults(from_osgb) osgDB.writeNodeFile(*node, "results.osgx") from_osgx = osgDB.readNodeFile("results.osgx") if from_osgx.valid() : OSG_NOTICE, "Testing results for values from scene graph read from .osgx file" testResults(from_osgx)
return 1 if runShaderGen : # convert fixed function pipeline to shaders sgv = osgUtil.ShaderGenVisitor() loadedModel.accept(sgv) if runConvertToVertexAttributes : # find any conventional vertex, colour, normal and tex coords arrays and convert to vertex attributes ctvaa = ConvertToVertexAttibArrays() loadedModel.accept(ctvaa) if not loadedModel : return 1 if not outputFileName.empty() : osgDB.writeNodeFile(*loadedModel, outputFileName) return 0 # add a viewport to the viewer and attach the scene graph. viewer.setSceneData(loadedModel) viewer.setCameraManipulator(osgGA.TrackballManipulator()) # add the stats handler viewer.addEventHandler(osgViewer.StatsHandler)() viewer.realize() if runConvertToVertexAttributes : # switch on the uniforms that track the modelview and projection matrices
sunLight.addChild( aroundSunRotationJupiter ) # #********************************************* #** end Jupiter and Transformations #********************************************* # # # # add space, but don't light it, as its not illuminated by our sun # space = solarSystem.createSpace( "Space", solarSystem._mapSpace ) # space.getOrCreateStateSet().setMode(GL_LIGHTING, osg.StateAttribute.OFF) # root.addChild( space ) # if not writeFileName.empty() : osgDB.writeNodeFile(*root, writeFileName) print "Written solar system to \"", writeFileName, "\"" return 0 # run optimization over the scene graph optimzer = osgUtil.Optimizer() optimzer.optimize( root ) # set the scene to render viewer.setSceneData( root ) # set up tracker manipulators, once for each astral body fnnv = FindNamedNodeVisitor("Moon") root.accept(fnnv)
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()+" creates a hierarchy of files for paging which can be later loaded by viewers.") arguments.getApplicationUsage().setCommandLineUsage(arguments.getApplicationName()+" [options] filename ...") arguments.getApplicationUsage().addCommandLineOption("-h or --help","Display this information") arguments.getApplicationUsage().addCommandLineOption("-o","set the output file (defaults to output.ive)") arguments.getApplicationUsage().addCommandLineOption("--makeAllChildrenPaged","Force all children of LOD to be written out as external PagedLOD children") # if user request help write it out to cout. if arguments.read("-h") or arguments.read("--help") : arguments.getApplicationUsage().write(std.cout) return 1 outputfile = str("output.ive") while arguments.read("-o",outputfile) : makeAllChildrenPaged = False while arguments.read("--makeAllChildrenPaged") : makeAllChildrenPaged = True # 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 # if arguments.argc()<=1 : # # arguments.getApplicationUsage().write(std.cout,osg.ApplicationUsage.COMMAND_LINE_OPTION) # return 1 # model = osgDB.readNodeFiles(arguments) if not model : osg.notify(osg.NOTICE), "No model loaded." return 1 basename = str( osgDB.getNameLessExtension(outputfile) ) ext = ord(".")+ osgDB.getFileExtension(outputfile) converter = ConvertToPageLODVistor(basename,ext, makeAllChildrenPaged) model.accept(converter) converter.convert() nameNodes = NameVistor() model.accept(nameNodes) #CheckVisitor checkNodes #model.accept(checkNodes) if model.valid() : osgDB.writeNodeFile(*model,outputfile) woplsv = WriteOutPagedLODSubgraphsVistor() model.accept(woplsv) return 0 if __name__ == "__main__": main(sys.argv)
ddv = DebugDisplayVisitor( _debug ) _node.accept( ddv ) return True elif ea.getKey()==osgGA.GUIEventAdapter.KEY_F8 : # F8 -- Gether stats and display sv = StatisticsVisitor() _node.accept( sv ) print "osgOQ: Stats: numOQNs ", sv.getNumOQNs(), ", numPased ", sv.getNumPassed() return True elif ea.getKey()==osgGA.GUIEventAdapter.KEY_F9 : # F9 -- Remove all OcclusionQueryNodes roqv = RemoveOcclusionQueryVisitor() _node.accept( roqv ) return True elif ea.getKey()==ord("o") : if osgDB.writeNodeFile( _node, "saved_model.osgt" ) : osg.notify( osg.ALWAYS ), "osgOQ: Wrote scene graph to \"saved_model.osgt\"" else: osg.notify( osg.ALWAYS ), "osgOQ: Wrote failed for \"saved_model.osgt\"" return True return False default: break return False _node = osg.Node() bool _enable, _debug # Create a cube with one side missing. This makes a great simple occluder.
def main(argv): # use an ArgumentParser object to manage the program arguments. arguments = osg.ArgumentParser(argv) # initialize the viewer. viewer = osgViewer.Viewer() # load the nodes from the commandline arguments. rootnode = osgDB.readNodeFiles(arguments) if not rootnode : osg.notify(osg.NOTICE), "Please specify a model filename on the command line." return 1 # run optimization over the scene graph optimzer = osgUtil.Optimizer() optimzer.optimize(rootnode) # ------------- Start of copy specific code ------------------------------------------------------- # do a deep copy, using MyCopyOp to reveal whats going on under the good, # in your own code you'd typically just use the basic osg.CopyOp something like mycopy = dynamic_cast<osg.Node*>(rootnode.clone(osg.CopyOp.DEEP_COPY_ALL)) print "Doing a deep copy of scene graph" # note, we need the dyanmic_cast because MS Visual Studio can't handle covarient # return types, so that clone has return just Object*. bahh hum bug deep_copy = dynamic_cast<osg.Node*>(rootnode.clone(MyCopyOp(osg.CopyOp.DEEP_COPY_ALL))) print "----------------------------------------------------------------" # do a graph preserving deep copy. print "Doing a graph preserving deep copy of scene graph nodes" graph_copy = dynamic_cast<osg.Node*>(rootnode.clone(GraphCopyOp(osg.CopyOp.DEEP_COPY_NODES))) # do a shallow copy. print "Doing a shallow copy of scene graph" shallow_copy = dynamic_cast<osg.Node*>(rootnode.clone(MyCopyOp(osg.CopyOp.SHALLOW_COPY))) # write out the various scene graphs so that they can be browsed, either # in an editor or using a graphics diff tool gdiff/xdiff/xxdiff. print std.endl, "Writing out the original scene graph as 'original.osgt'" osgDB.writeNodeFile(*rootnode,"original.osgt") print std.endl, "Writing out the graph preserving scene graph as 'graph_copy.osgt'" osgDB.writeNodeFile(*graph_copy,"graph_copy.osgt") print "Writing out the deep copied scene graph as 'deep_copy.osgt'" osgDB.writeNodeFile(*deep_copy,"deep_copy.osgt") print "Writing out the shallow copied scene graph as 'shallow_copy.osgt'" osgDB.writeNodeFile(*shallow_copy,"shallow_copy.osgt") # You can use a bit mask to control which parts of the scene graph are shallow copied # vs deep copied. The options are (from include/osg/CopyOp) : # enum Options # SHALLOW_COPY = 0, # DEEP_COPY_OBJECTS = 1, # DEEP_COPY_NODES = 2, # DEEP_COPY_DRAWABLES = 4, # DEEP_COPY_STATESETS = 8, # DEEP_COPY_STATEATTRIBUTES = 16, # DEEP_COPY_TEXTURES = 32, # DEEP_COPY_IMAGES = 64, # DEEP_COPY_ALL = 0xffffffff # # # These options you can use together such as : # osg.Node* mycopy = dynamic_cast<osg.Node*>(rootnode.clone(osg.CopyOp.DEEP_COPY_NODES | DEEP_COPY_DRAWABLES)) # Which shares state but creates copies of all nodes and drawables (which contain the geometry). # # You may also want to subclass from CopyOp to provide finer grained control of what gets shared (shallow copy) vs # cloned (deep copy). # ------------- End of copy specific code ------------------------------------------------------- # set the scene to render viewer.setSceneData(rootnode) # viewer.setThreadingModel(osgViewer.Viewer.SingleThreaded) return viewer.run()
camera.setViewMatrix(osg.Matrix.identity()) camera.setClearMask(GL_DEPTH_BUFFER_BIT) camera.addChild(createHUDText()) camera.getOrCreateStateSet().setMode(GL_LIGHTING,osg.StateAttribute.OFF) group.addChild(camera) if True : group.addChild(create3DText(center,radius)) # set the scene to render viewer.setSceneData(group) filename = str() if arguments.read("-o",filename) : osgDB.writeNodeFile(*viewer.getSceneData(),filename) return 0 viewer.addEventHandler( osgGA.StateSetManipulator(viewer.getCamera().getOrCreateStateSet()) ) viewer.addEventHandler(osgViewer.StatsHandler()) viewer.run() if not operationThreads.empty() : for(Threads.iterator itr = operationThreads.begin() not = operationThreads.end() ++itr) (*itr).cancel() return 0
virtual void operator () (osg.Object* object) osg.notify(osg.NOTICE), "LoadAndCompileOperation ", _filename _modelReadyToMerge = False _loadedModel = osgDB.readNodeFile(_filename) if _loadedModel.valid() : if _sceneGraphProcessor.valid() : _loadedModel = _sceneGraphProcessor.process(_loadedModel) if _loadedModel.valid() : if not _outputFilename.empty() : OSG_NOTICE, "Writing out file ", _outputFilename osgDB.writeNodeFile(*_loadedModel, _outputFilename) if _incrementalCompileOperation.valid() : OSG_NOTICE, "Registering with ICO ", _outputFilename compileSet = osgUtil.IncrementalCompileOperation.CompileSet(_loadedModel) compileSet._compileCompletedCallback = this _incrementalCompileOperation.add(compileSet) else: _modelReadyToMerge = True osg.notify(osg.NOTICE), "done LoadAndCompileOperation ", _filename def compileCompleted(compileSet):
def main(argv): # use an ArgumentParser object to manage the program arguments. arguments = osg.ArgumentParser(argv) if argc<2 : print argv[0], ": requires filename argument." return 1 viewer = osgViewer.Viewer(arguments) outputfile = str("output.osgt") while arguments.read("-o",outputfile) : while arguments.read("-s") : viewer.setThreadingModel(osgViewer.Viewer.SingleThreaded) while arguments.read("-g") : viewer.setThreadingModel(osgViewer.Viewer.CullDrawThreadPerContext) while arguments.read("-d") : viewer.setThreadingModel(osgViewer.Viewer.DrawThreadPerContext) while arguments.read("-c") : viewer.setThreadingModel(osgViewer.Viewer.CullThreadPerCameraDrawThreadPerContext) singleWindowSideBySideCameras(viewer) viewer.setCameraManipulator( osgGA.TrackballManipulator() ) viewer.addEventHandler(osgViewer.StatsHandler)() viewer.addEventHandler(osgViewer.ThreadingHandler)() viewer.addEventHandler(osgViewer.WindowSizeHandler()) viewer.addEventHandler(osgViewer.LODScaleHandler()) viewer.addEventHandler(osgGA.StateSetManipulator()) visit = SwitchDOFVisitor() viewer.addEventHandler(visit) loadedModel = osg.Node() # load the scene. loadedModel = osgDB.readNodeFiles(arguments) if not loadedModel : print argv[0], ": No data loaded." return 1 group = osg.Group() group1 = osg.Group() group1.addChild(loadedModel) group1.setNodeMask(1) # Uncomment these lines if you like to compare the loaded model to the resulting model in a merge/diff tool #osgDB.writeNodeFile(*loadedModel, "dummy1.osgt") osgDB.writeNodeFile(*loadedModel, outputfile) convertedModel = osgDB.readNodeFile(outputfile) #osgDB.writeNodeFile(*convertedModel, "dummy2.osgt") group2 = osg.Group() group2.addChild(convertedModel) group2.setNodeMask(2) # Activate DOF animations and collect switches loadedModel.accept(*visit) convertedModel.accept(*visit) group.addChild(group1) group.addChild(group2) viewer.setSceneData(group) viewer.setThreadingModel(osgViewer.Viewer.DrawThreadPerContext) viewer.realize() viewer.run() return 0 if __name__ == "__main__": main(sys.argv)
scene.addUpdateCallback(bam) geode = osg.Geode() geode.addDrawable(morph) geode.addUpdateCallback(osgAnimation.UpdateMorph("MorphNodeCallback")) scene.addChild(geode) viewer.addEventHandler(osgViewer.StatsHandler()) viewer.addEventHandler(osgViewer.WindowSizeHandler()) viewer.addEventHandler(osgGA.StateSetManipulator(viewer.getCamera().getOrCreateStateSet())) # let's run not viewer.setSceneData( scene ) viewer.realize() bam.playAnimation(animation) while not viewer.done() : viewer.frame() osgDB.writeNodeFile(*scene, "morph_scene.osg") return 0 if __name__ == "__main__": main(sys.argv)
trueroot.addChild(skelroot) trueroot.setDataVariance(osg.Object.DYNAMIC) rootTransform.addChild(trueroot) scene.addChild(rootTransform) geom = createTesselatedBox(4, 4.0) geode = osg.Geode() geode.addDrawable(geom) skelroot.addChild(geode) src = dynamic_cast<osg.Vec3Array*>(geom.getSourceGeometry().getVertexArray()) geom.getOrCreateStateSet().setMode(GL_LIGHTING, False) geom.setDataVariance(osg.Object.DYNAMIC) initVertexMap(root, right0, right1, geom, src) # let's run not viewer.setSceneData( scene ) viewer.realize() while not viewer.done() : viewer.frame() osgDB.writeNodeFile(*scene, "skinning.osg") return 0 if __name__ == "__main__": main(sys.argv)
view = dynamic_cast<osgViewer.View*>(aa) intersections = osgUtil.LineSegmentIntersector.Intersections() if view and view.computeIntersections(ea, intersections) : hit = *(intersections.begin()) if hit.matrix.valid() : addPoint(hit.localIntersectionPoint * (*hit.matrix)) addPoint = else(hit.localIntersectionPoint) return True elif ea.getKey()==ord("e") : endOccluder() return True elif ea.getKey()==ord("O") : if _occluders.valid() : if osgDB.writeNodeFile(*_occluders,"saved_occluders.osgt") : print "saved occluders to 'saved_occluders.osgt'" else: print "no occluders to save" return True return False default: return False void OccluderEventHandler.addPoint( osg.Vec3 pos) print "add point ", pos if not _convexPlanarOccluder.valid() : _convexPlanarOccluder = osg.ConvexPlanarOccluder() occluder = _convexPlanarOccluder.getOccluder()