def pick(self, x, y, viewer):
if viewer.getSceneData():
if self.usePolytopeIntersector():
picker = osgUtil.PolytopeIntersector(osgUtil.Intersector.WINDOW, x - 2.0, y - 2.0, x + 2.0, y + 2.0)
else:
picker = osgUtil.LineSegmentIntersector(osgUtil.Intersector.WINDOW, x, y)
intersectionVisitor = osgUtil.IntersectionVisitor(picker)
viewer.getCamera().accept(intersectionVisitor)
if picker.containsIntersections():
intersections = picker.getIntersections()
# The PolytopeIntersector mis-calculates the eye distance for geometry nested under a transform, which is true for all UnitShapes. (See the thread at http://www.mail-archive.com/[email protected]/msg29195.html for some discussion.)
# Calculate the correct distance and re-sort.
# This will probably still work correctly after that bug is fixed but will be inefficient.
visibleHits = []
eye, center, up = (osg.Vec3(), osg.Vec3(), osg.Vec3())
viewer.getCamera().getViewMatrixAsLookAt(eye, center, up)
eye = (eye.x(), eye.y(), eye.z())
for i in range(0, len(intersections)):
intersection = intersections[i]
for j in range(0, len(intersection.nodePath)):
node = intersection.nodePath[j]
geode = osg.NodeToGeode(node)
if geode != None:
visibleID = int(geode.getName())
visible = self._display.visibleWithId(visibleID)
if geode.getOrCreateStateSet().getAttribute(osg.StateAttribute.DEPTH):
# If a geode has this attribute set then (currently) it is being rendered in front of all other nodes. Simulate this here by placing the geode right at the eye.
# If depths other than the default or osg.Depth.ALWAYS are used in the future then this check will need to be modified.
eyeDistance = 0.0
else:
intersectionPoint = intersection.localIntersectionPoint
if isinstance(visible.shape(), UnitShape):
position = visible.worldPosition()
size = visible.worldSize()
intersectionPoint = (position[0] + size[0] * intersectionPoint.x(), position[1] + size[1] * intersectionPoint.y(), position[2] + size[2] * intersectionPoint.z())
eyeDistance = (intersectionPoint[0] - eye[0]) ** 2 + (intersectionPoint[1] - eye[1]) ** 2 + (intersectionPoint[2] - eye[2]) ** 2
visibleHits += [(eyeDistance, visible)]
visibleHits.sort()
# Loop through all of the hits to find the "deepest" one in the sense of the visible hierarchy. For example, a neuron in a region will be picked instead of the region even though the region hit is closer.
if self._display.useGhosts():
# Make a first pass only picking non-ghosted items.
# TODO: this could be done with node masks...
deepestVisible = None
for distance_, visible in visibleHits:
if (visible in self._display.highlightedVisibles or visible in self._display.animatedVisibles) and (deepestVisible is None or deepestVisible in visible.ancestors()):
deepestVisible = visible
if deepestVisible is not None:
self._display.selectVisibles([deepestVisible], self._display.selectionShouldExtend, self._display.findShortestPath, fromclick=True)
return True
deepestVisible = None
for distance_, visible in visibleHits:
if deepestVisible is None or deepestVisible in visible.ancestors():
deepestVisible = visible
self._display.selectVisibles([deepestVisible], self._display.selectionShouldExtend, self._display.findShortestPath, fromclick=True)
else:
self._display.selectVisibles([])
return True
def createTesselatedBox(nsplit, size):
geometry = osgAnimation.RigGeometry()
vertices = osg.Vec3Array()
colors = osg.Vec3Array()
geometry.setVertexArray(vertices)
geometry.setColorArray(colors)
geometry.setColorBinding(osg.Geometry.BIND_PER_VERTEX)
step = size / nsplit
s = 0.5 / 4.0
for i in range(nsplit):
x = -1 + i * step
vertices.push_back(osg.Vec3(x, s, s))
vertices.push_back(osg.Vec3(x, -s, s))
vertices.push_back(osg.Vec3(x, -s, -s))
vertices.push_back(osg.Vec3(x, s, -s))
c = osg.Vec3(0, 0, 0)
c[i % 3] = 1
colors.push_back(c)
colors.push_back(c)
colors.push_back(c)
colors.push_back(c)
faces = osg.DrawElementsUInt(osg.PrimitiveSet.TRIANGLES, 0)
for i in range(nsplit - 1):
base = i * 4
faces.push_back(base)
faces.push_back(base + 1)
faces.push_back(base + 4)
faces.push_back(base + 1)
faces.push_back(base + 5)
faces.push_back(base + 4)
faces.push_back(base + 3)
faces.push_back(base)
faces.push_back(base + 4)
faces.push_back(base + 7)
faces.push_back(base + 3)
faces.push_back(base + 4)
faces.push_back(base + 5)
faces.push_back(base + 1)
faces.push_back(base + 2)
faces.push_back(base + 2)
faces.push_back(base + 6)
faces.push_back(base + 5)
faces.push_back(base + 2)
faces.push_back(base + 3)
faces.push_back(base + 7)
faces.push_back(base + 6)
faces.push_back(base + 2)
faces.push_back(base + 7)
geometry.addPrimitiveSet(faces)
geometry.setUseDisplayList(False)
return geometry
def quad_create(self, texture):
stateset = osg.StateSet()
stateset.setTextureAttributeAndModes(0, texture)
corner = osg.Vec3(-self.aspect_ratio, -1.0, 0)
width = osg.Vec3(2 * self.aspect_ratio, 0, 0)
height = osg.Vec3(0, 2 * 1.0, 0)
geom = osg.createTexturedQuadGeometry(corner, width, height, 0.0, 0.0,
1.0, 1.0)
geom.setStateSet(stateset)
geode = osg.Geode()
geode.addDrawable(geom)
return geode
def startDragPanOrPick(self, eventAdaptor, viewer):
eventWasHandled = False
if viewer.getSceneData():
# TODO: This is a major hack. The intersection code below always picks the composite dragger, even if it isn't being rendered. So we remove the inactive dragger while picking.
# TODO: Figure out how to make the intersection code honor the LOD and get rid of the DraggerCullCallback class.
if self._display.draggerLOD is not None:
if self._display.activeDragger == self._display.simpleDragger:
self._display.draggerLOD.removeChild(
self._display.compositeDragger)
if self._display.activeDragger == self._display.compositeDragger:
self._display.draggerLOD.removeChild(
self._display.simpleDragger)
x, y = eventAdaptor.getX(), eventAdaptor.getY()
if self.usePolytopeIntersector():
picker = osgUtil.PolytopeIntersector(
osgUtil.Intersector.WINDOW, x - 2.0, y - 2.0, x + 2.0,
y + 2.0)
else:
picker = osgUtil.LineSegmentIntersector(
osgUtil.Intersector.WINDOW, x, y)
intersectionVisitor = osgUtil.IntersectionVisitor(picker)
intersectionVisitor.setTraversalMode(
osg.NodeVisitor.TRAVERSE_ACTIVE_CHILDREN)
viewer.getCamera().accept(intersectionVisitor)
if picker.containsIntersections():
# Add all intersections from the first dragger hit onward to the pointer info. This allows dragging of nested regions.
self.pointerInfo.setCamera(viewer.getCamera())
self.pointerInfo.setMousePosition(eventAdaptor.getX(),
eventAdaptor.getY())
intersections = picker.getIntersections()
for i in range(0, len(intersections)):
intersection = intersections[i]
for j in range(0, len(intersection.nodePath)):
node = intersection.nodePath[j]
if self.dragger is None:
self.dragger = osgManipulator.NodeToDragger(node)
if self.dragger is not None:
localPoint = intersection.localIntersectionPoint # have to do stupid conversion from Vec3d to Vec3
if self.usePolytopeIntersector():
self.pointerInfo.addIntersection(
intersection.nodePath,
osg.Vec3(localPoint.x(), localPoint.y(),
localPoint.z()))
else:
self.pointerInfo.addIntersection(
intersection.nodePath,
osg.Vec3d(localPoint.x(), localPoint.y(),
localPoint.z()))
if self.dragger is not None:
self.dragger.handle(self.pointerInfo, eventAdaptor, viewer)
eventWasHandled = True
if self._display.draggerLOD is not None:
if self._display.activeDragger == self._display.simpleDragger:
self._display.draggerLOD.addChild(
self._display.compositeDragger)
if self._display.activeDragger == self._display.compositeDragger:
self._display.draggerLOD.addChild(
self._display.simpleDragger)
return eventWasHandled
def __init__(self,
axis=osg.Vec3(0.0, 0.0, 1.0),
startangle=0.0,
speed=0.001):
self._angle = startangle
self._axis = axis
self._quat = osg.Quat()
self._speed = speed
osg.NodeCallback.__init__(self)
def createAxis():
geode = osg.Geode()
geometry = osg.Geometry()
vertices = osg.Vec3Array()
vertices.push_back(osg.Vec3(0.0, 0.0, 0.0))
vertices.push_back(osg.Vec3(1.0, 0.0, 0.0))
vertices.push_back(osg.Vec3(0.0, 0.0, 0.0))
vertices.push_back(osg.Vec3(0.0, 1.0, 0.0))
vertices.push_back(osg.Vec3(0.0, 0.0, 0.0))
vertices.push_back(osg.Vec3(0.0, 0.0, 1.0))
geometry.setVertexArray(vertices)
colors = osg.Vec4Array()
colors.push_back(osg.Vec4(1.0, 0.0, 0.0, 1.0))
colors.push_back(osg.Vec4(1.0, 0.0, 0.0, 1.0))
colors.push_back(osg.Vec4(0.0, 1.0, 0.0, 1.0))
colors.push_back(osg.Vec4(0.0, 1.0, 0.0, 1.0))
colors.push_back(osg.Vec4(0.0, 0.0, 1.0, 1.0))
colors.push_back(osg.Vec4(0.0, 0.0, 1.0, 1.0))
geometry.setColorArray(colors)
geometry.setColorBinding(osg.Geometry.BIND_PER_VERTEX)
geometry.addPrimitiveSet(osg.DrawArrays(osg.PrimitiveSet.LINES, 0, 6))
geode.addDrawable(geometry)
return geode
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
import ctypes import osgDB, osgViewer, osg, osgGA, osgAnimation floatKeys = osgAnimation.FloatKeyframeContainer() key0 = osgAnimation.FloatKeyframe(0.0, 1.0) floatKeys.push_back(key0) vec3Keys = osgAnimation.Vec3KeyframeContainer() key0 = osgAnimation.Vec3Keyframe(0.0, osg.Vec3(1, 2, 3)) vec3Keys.push_back(key0) vec4Keys = osgAnimation.Vec4KeyframeContainer() key0 = osgAnimation.Vec4Keyframe(0.0, osg.Vec4(1, 2, 3, 4)) vec4Keys.push_back(key0)
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()
import osg import osgDB import osgGA import osgViewer # create a root node node = osg.Group() # Line Geometry lineGeode = osg.Geode() lineGeometry = osg.Geometry() lineGeode.addDrawable(lineGeometry) lineStateSet = lineGeode.getOrCreateStateSet() lineVertices = osg.Vec3Array() lineVertices.push_back(osg.Vec3(-10, 10, 0)) lineVertices.push_back(osg.Vec3(-10, -10, 0)) lineGeometry.setVertexArray(lineVertices) lineBase = osg.DrawElementsUInt(osg.PrimitiveSet.LINES, 0) lineBase.push_back(0) lineBase.push_back(1) lineGeometry.addPrimitiveSet(lineBase) node.addChild(lineGeode) # Pyramid geometry, following tutorial pyramidGeode = osg.Geode() pyramidGeometry = osg.Geometry() pyramidGeode.addDrawable(pyramidGeometry) pyramidStateSet = pyramidGeode.getOrCreateStateSet()
