def build_wrapping_node(self, data):
grp = osg.Group()
camera, texture = self.camera_build()
grp.addChild(camera)
camera.addChild(data)
quad = self.quad_create(texture)
grp.addChild(quad)
grp.getOrCreateStateSet().setMode(GL.GL_LIGHTING, False)
# ALPHA_TEST should be disabled by default by OpenGL but it's not.
# That's why it is required to explicitly disable it.
grp.getOrCreateStateSet().setMode(GL.GL_ALPHA_TEST,
osg.StateAttribute.OFF)
return grp
def create_test_graph():
"""Create a simple test graph, with no geode.
"""
root = osg.Group()
root.setName('root')
child0 = osg.Group()
child0.setName('child0')
root.addChild(child0)
grandchild00 = osg.Group()
grandchild00.setName('grandchild00')
child0.addChild(grandchild00)
grandchild01 = osg.Group()
grandchild01.setName('grandchild01')
child0.addChild(grandchild01)
child1 = osg.Group()
child1.setName('child1')
root.addChild(child1)
grandchild10 = osg.Group()
grandchild10.setName('grandchild10')
child1.addChild(grandchild10)
return root
#create a wirebox and safe it, the wire box
#will be attached to the parental transform node
self.wb = createWireBox(geode)
self._selectedNode.addChild(self.wb)
self.wb.thisown = False
return True
return False
else:
print "No Intersection Found"
return False
#load the model
loadedModel = osgDB.readNodeFile("cow.osg")
root = osg.Group()
#create some dynamic transformation nodes
dynamicTransform1 = osg.PositionAttitudeTransform()
dynamicTransform2 = osg.PositionAttitudeTransform()
dynamicTransform3 = osg.PositionAttitudeTransform()
dynamicTransform4 = osg.PositionAttitudeTransform()
#add the loaded model to the transform nodes
dynamicTransform1.addChild(loadedModel)
dynamicTransform1.setPosition(osg.Vec3d(-10, 0, -10))
dynamicTransform2.addChild(loadedModel)
dynamicTransform2.setPosition(osg.Vec3d(-10, 0, 10))
dynamicTransform3.addChild(loadedModel)
dynamicTransform3.setPosition(osg.Vec3d(10, 0, -10))
dynamicTransform4.addChild(loadedModel)
#create menubar
menubar = self.menuBar()
file = menubar.addMenu('&File')
file.addAction(exit)
#optional toolbar
#toolbar = self.addToolBar('Exit')
#toolbar.addAction(exit)
def setSceneData(self, node):
"""set the scenedata in the osgViewer of the widget"""
self.viewerWidget.viewer.setSceneData(node)
if __name__ == "__main__":
app = QtGui.QApplication(sys.argv)
mainwindow = MainWindow()
#show the mainwindow
mainwindow.show()
# create a root node
node = osg.Group()
# open a file
loadedmodel = osgDB.readNodeFile("cow.osg")
node.addChild(loadedmodel)
mainwindow.setSceneData(node)
#execute the application
sys.exit(app.exec_())
def createPreRenderSubGraph(subgraph, tex_width, tex_height, renderImplementation, \
useImage, useTextureRectangle, useHDR, \
samples, colorSamples):
if not subgraph:
return 0
# create a group to contain the flag and the pre rendering camera.
parent = osg.Group()
#texture to render to and to use for rendering of flag.
texture = 0
if (useTextureRectangle):
textureRect = osg.TextureRectangle()
textureRect.setTextureSize(tex_width, tex_height)
textureRect.setInternalFormat(osg.GL_RGBA)
textureRect.setFilter(osg.Texture2D.MIN_FILTER, osg.Texture2D.LINEAR)
textureRect.setFilter(osg.Texture2D.MAG_FILTER, osg.Texture2D.LINEAR)
texture = textureRect
else:
texture2D = osg.Texture2D()
texture2D.setTextureSize(tex_width, tex_height)
texture2D.setInternalFormat(osg.GL_RGBA)
texture2D.setFilter(osg.Texture2D.MIN_FILTER, osg.Texture2D.LINEAR)
texture2D.setFilter(osg.Texture2D.MAG_FILTER, osg.Texture2D.LINEAR)
texture = texture2D
if useHDR:
texture.setInternalFormat(osg.GL_RGBA16F_ARB)
texture.setSourceFormat(osg.GL_RGBA)
texture.setSourceType(osg.GL_FLOAT)
#first create the geometry of the flag of which to view.
if True:
# create the to visualize.
polyGeom = osg.Geometry()
polyGeom.setName("PolyGeom")
polyGeom.setDataVariance(osg.Object.DYNAMIC)
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 = osg.Vec3(origin[0], origin[1], origin[2])
top = osg.Vec3(origin[0], origin[1], origin[2])
top[2] += 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)
if useTextureRectangle:
ltex_height = tex_height
ltex_width = tex_width
else:
ltex_height = 1.0
ltex_width = 1.0
top_texcoord = osg.Vec2(0.0, ltex_height)
dv_texcoord = osg.Vec2(ltex_width / float((noSteps - 1)), 0.0)
for i in range(noSteps):
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
# pass the created vertex array to the points geometry object.
polyGeom.setVertexArray(vertices)
polyGeom.setTexCoordArray(0, texcoords)
colors = osg.Vec4Array()
colors.push_back(osg.Vec4(1.0, 1.0, 1.0, 1.0))
polyGeom.setColorArray(colors)
polyGeom.setColorBinding(osg.Geometry.BIND_OVERALL)
polyGeom.addPrimitiveSet(
osg.DrawArrays(osg.PrimitiveSet.QUAD_STRIP, 0, vertices.size()))
# new we need to add the texture to the Drawable, we do so by creating a
# StateSet to contain the Texture StateAttribute.
stateset = osg.StateSet()
stateset.setTextureAttributeAndModes(0, texture, osg.StateAttribute.ON)
polyGeom.setStateSet(stateset)
#changes to the geometry
polyGeom.setUpdateCallback(
MyGeometryCallback(origin, xAxis, yAxis, zAxis, 1.0, 1.0 / width,
0.2).__disown__())
geode = osg.Geode()
geode.addDrawable(polyGeom)
parent.addChild(geode)
# then create the camera node to do the render to texture
if True:
camera = osg.Camera()
# set up the background color and clear mask.
camera.setClearColor(osg.Vec4(0.1, 0.1, 0.3, 1.0))
camera.setClearMask(osg.GL_COLOR_BUFFER_BIT | osg.GL_DEPTH_BUFFER_BIT)
bs = subgraph.getBound()
if not bs.valid():
return subgraph
znear = 1.0 * bs.radius()
zfar = 3.0 * bs.radius()
# 2:1 aspect ratio as per flag geometry below.
proj_top = 0.25 * znear
proj_right = 0.5 * znear
znear *= 0.9
zfar *= 1.1
# set up projection.
camera.setProjectionMatrixAsFrustum(-proj_right, proj_right, -proj_top,
proj_top, znear, zfar)
# set view
camera.setReferenceFrame(osg.Transform.ABSOLUTE_RF)
camera.setViewMatrixAsLookAt(osg.Vec3d(bs.center())-osg.Vec3d(0.0,2.0,0.0)*bs.radius(), \
osg.Vec3d(bs.center()),\
osg.Vec3d(0.0,0.0,1.0))
# 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(renderImplementation)
if useImage:
image = osg.Image()
#image.allocateImage(tex_width, tex_height, 1, GL_RGBA, GL_UNSIGNED_BYTE);
image.allocateImage(tex_width, tex_height, 1, osg.GL_RGBA,
osg.GL_FLOAT)
# attach the image so its copied on each frame.
camera.attach(osg.Camera.COLOR_BUFFER, image, samples,
colorSamples)
camera.setPostDrawCallback(MyCameraPostDrawCallback(image))
# Rather than attach the texture directly to illustrate the texture's ability to
# detect an image update and to subload the image onto the texture. You needn't
# do this when using an Image for copying to, as a separate camera.attach(..)
# would suffice as well, but we'll do it the long way round here just for demonstration
# purposes (long way round meaning we'll need to copy image to main memory, then
# copy it back to the graphics card to the texture in one frame).
# The long way round allows us to manually modify the copied image via the callback
# and then let this modified image by reloaded back.
texture.setImage(0, image)
else:
# attach the texture and use it as the color buffer.
camera.attach(osg.Camera.COLOR_BUFFER, texture, 0, 0, False,
samples, colorSamples)
# add subgraph to render
camera.addChild(subgraph)
parent.addChild(camera)
return parent
def main():
# use an ArgumentParser object to manage the program arguments.
#arguments = osg.ArgumentParser()
#construct the viewer.
viewer = osgViewer.Viewer()
#need to use singlethreaded mode
viewer.setThreadingModel(viewer.SingleThreaded)
# add the stats
viewer.addEventHandler(osgViewer.StatsHandler())
# add the record camera path handler
viewer.addEventHandler(osgViewer.RecordCameraPathHandler())
#add the threading handler
viewer.addEventHandler(osgViewer.ThreadingHandler())
#if user request help write it out to cout.
#if (arguments.read("-h") or arguments.read("--help")):
# arguments.getApplicationUsage().write(sys.stdout)
# return 1
tex_width = 1024
tex_height = 512
samples = 0
colorSamples = 0
renderImplementation = osg.Camera.FRAME_BUFFER_OBJECT
useImage = False
useTextureRectangle = False
useHDR = False
# if not loaded assume no arguments passed in, try use default mode instead.
loadedModel = osgDB.readNodeFile("cessna.osg")
# create a transform to spin the model.
loadedModelTransform = osg.MatrixTransform()
loadedModelTransform.addChild(loadedModel)
nc = osg.AnimationPathCallback(
osg.Vec3d(loadedModelTransform.getBound().center()),
osg.Vec3d(0.0, 0.0, 1.0), osg.inDegrees(45.0))
loadedModelTransform.setUpdateCallback(nc)
rootNode = osg.Group()
rootNode.addChild(createPreRenderSubGraph(loadedModelTransform,\
tex_width,tex_height, \
renderImplementation, \
useImage, useTextureRectangle, \
useHDR, samples, colorSamples))
osgDB.writeNodeFile(rootNode, "test.ive")
# add model to the viewer.
viewer.setSceneData(rootNode)
viewer.run()
import ctypes
import osgDB, osgViewer, osg
group = osg.Group()
image = osgDB.readImageFile(
"/home/trigrou/Pictures/backgrounds/games/Another_World_by_Orioto.jpg")
loadedModel = osg.Group()
corner = osg.Vec3(0, 0, 0)
width = osg.Vec3(1, 0, 0)
height = osg.Vec3(0, 1, 0)
geom = osg.createTexturedQuadGeometry(corner, width, height, 0.0, 0.0, 1.0,
1.0)
geom.getOrCreateStateSet().setTextureAttributeAndModes(0, osg.Texture2D(image))
geom.getOrCreateStateSet().setTextureAttributeAndModes(
1,
osg.Texture2D(
osgDB.readImageFile(
"/home/trigrou/Pictures/backgrounds/games/Big_Blue_by_Orioto.jpg"))
)
vertProg = """
void main()
{
gl_Position = ftransform();
gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;
}
"""
fragProg = """
uniform float test;
uniform int index;
uniform sampler2D tex0;
def main():
#arguments = osg.ArgumentParses(len(sys.argv),sys.argv)
viewer = osgViewer.Viewer() #arguments)
viewer.setCameraManipulator(osgGA.TrackballManipulator())
skelroot = osgAnimation.Skeleton()
skelroot.setDefaultUpdateCallback()
root = osgAnimation.Bone()
root.setBindMatrixInBoneSpace(osg.Matrixd_identity())
root.setBindMatrixInBoneSpace(osg.Matrixd_translate(-1, 0, 0))
root.setName("root")
root.setDefaultUpdateCallback()
right0 = osgAnimation.Bone()
right0.setBindMatrixInBoneSpace(osg.Matrixd_translate(1, 0, 0))
right0.setName("right0")
right0.setDefaultUpdateCallback("right0")
right1 = osgAnimation.Bone()
right1.setBindMatrixInBoneSpace(osg.Matrixd_translate(1, 0, 0))
right1.setName("right1")
right1.setDefaultUpdateCallback("right1")
root.addChild(right0)
right0.addChild(right1)
skelroot.addChild(root)
scene = osg.Group()
manager = osgAnimation.BasicAnimationManager()
scene.setUpdateCallback(manager)
anim = osgAnimation.Animation()
keys0 = osgAnimation.QuatKeyframeContainer()
keys1 = osgAnimation.QuatKeyframeContainer()
pKeys0 = int(keys0.this)
pKeys1 = int(keys1.this)
rotate = osg.Quat()
rotate.makeRotate(PI_2, osg.Vec3(0, 0, 1))
keys0.push_back(osgAnimation.QuatKeyframe(0, osg.Quat(0, 0, 0, 1)))
keys0.push_back(osgAnimation.QuatKeyframe(3, rotate))
keys0.push_back(osgAnimation.QuatKeyframe(6, rotate))
keys1.push_back(osgAnimation.QuatKeyframe(0, osg.Quat(0, 0, 0, 1)))
keys1.push_back(osgAnimation.QuatKeyframe(3, osg.Quat(0, 0, 0, 1)))
keys1.push_back(osgAnimation.QuatKeyframe(6, rotate))
sampler0 = osgAnimation.QuatSphericalLinearSampler()
sampler0.setKeyframeContainer(keys0)
channel0 = osgAnimation.QuatSphericalLinearChannel(sampler0)
channel0.setName("quaternion")
channel0.setTargetName("right0")
anim.addChannel(channel0)
sampler1 = osgAnimation.QuatSphericalLinearSampler()
sampler1.setKeyframeContainer(keys1)
channel1 = osgAnimation.QuatSphericalLinearChannel(sampler1)
channel1.setName("quaternion")
channel1.setTargetName("right1")
anim.addChannel(channel1)
manager.registerAnimation(anim)
manager.buildTargetReference()
# let's start !
manager.playAnimation(anim)
# we will use local data from the skeleton
rootTransform = osg.MatrixTransform()
rootTransform.setMatrix(osg.Matrixd_rotate(PI_2, osg.Vec3(1, 0, 0)))
right0.addChild(createAxis())
right0.setDataVariance(osg.Object.DYNAMIC)
right1.addChild(createAxis())
right1.setDataVariance(osg.Object.DYNAMIC)
trueroot = osg.MatrixTransform()
trueroot.setMatrix(osg.Matrixd(root.getMatrixInBoneSpace()))
trueroot.addChild(createAxis())
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 = geom.getVertexArray().asVec3Array()
geom.getOrCreateStateSet().setMode(osg.GL_LIGHTING, False)
geom.setDataVariance(osg.Object.DYNAMIC)
initVertexMap(root, right0, right1, geom, src)
#let's run !
viewer.setSceneData(scene)
viewer.realize()
while not viewer.done():
viewer.frame()
osg.setNotifyLevel(osg.INFO)
# create a viewer
viewer = osgViewer.Viewer()
# needed for Python
osgDB.setLibraryFilePathList(sys.path)
# create a viewer
viewer = osgViewer.Viewer()
# configure
viewer.setThreadingModel(osgViewer.Viewer.SingleThreaded)
# scene
scene = osg.Group()
# open a file
cow = osgDB.readNodeFile('cow.osg')
# add to the scene
viewer.setSceneData(scene)
# create a tracker - in HITLabNZ we use this one
tracker = osgVRPN.Tracker("DTrack@HITLVSTRACKER")
# create a ref ptr for the tracker
tracker_ref = osgVRPN.TrackerRef()
# add the tracker
tracker_ref = tracker
