def createSceneGraph(arguments):
node = osgDB.readNodeFiles(arguments)
if not node : return 0
group = osg.Group()
spacing = node.getBound().radius() * 2.0
position = osg.Vec3d(0.0,0.0,0.0)
sa1 = NULL
stateset = group.getOrCreateStateSet()
sa = osg.ShaderAttribute()
sa.setType(osg.StateAttribute.Type(10000))
sa1 = sa
stateset.setAttribute(sa)
vertex_shader = osg.Shader(osg.Shader.VERTEX)
vertex_shader.addCodeInjection(-1,"varying vec4 color\n")
vertex_shader.addCodeInjection(-1,"varying vec4 texcoord\n")
vertex_shader.addCodeInjection(0,"color = gl_Color\n")
vertex_shader.addCodeInjection(0,"texcoord = gl_MultiTexCoord0\n")
vertex_shader.addCodeInjection(0,"gl_Position = ftransform()\n")
sa.addShader(vertex_shader)
fragment_shader = osg.Shader(osg.Shader.FRAGMENT)
fragment_shader.addCodeInjection(-1,"varying vec4 color\n")
fragment_shader.addCodeInjection(-1,"varying vec4 texcoord\n")
fragment_shader.addCodeInjection(-1,"uniform sampler2D baseTexture \n")
fragment_shader.addCodeInjection(0,"gl_FragColor = color * texture2DProj( baseTexture, texcoord )\n")
sa.addShader(fragment_shader)
def main(argv):
viewer = osgViewer.Viewer()
wm = osgWidget.WindowManager(
viewer,
WINDOW_WIDTH,
WINDOW_HEIGHT,
MASK_2D
)
menu = osgWidget.Box("menu", osgWidget.Box.HORIZONTAL)
menu.addWidget(ColorLabelMenu("Choose EaseMotion"))
menu.getBackground().setColor(1.0, 1.0, 1.0, 1.0)
menu.setPosition(15.0, 15.0, 0.0)
wm.addChild(menu)
group = osg.Group()
geode = osg.Geode()
mt = osg.MatrixTransform()
geode.addDrawable(osg.ShapeDrawable(osg.Sphere(osg.Vec3(), 4.0)))
EASE_MOTION_SAMPLER = EaseMotionSampler(osg.Vec3(50.0, 0.0, 0.0))
EASE_MOTION_GEODE = osg.Geode()
mt.addChild(geode)
mt.setUpdateCallback(EASE_MOTION_SAMPLER)
mt.setNodeMask(MASK_3D)
viewer.setCameraManipulator(osgGA.TrackballManipulator())
viewer.getCameraManipulator().setHomePosition(
osg.Vec3d(0.0, 0.0, 200.0),
osg.Vec3d(20.0, 0.0, 0.0),
osg.Vec3d(0.0, 1.0, 0.0)
)
viewer.home()
group.addChild(mt)
group.addChild(EASE_MOTION_GEODE)
return osgWidget.createExample(viewer, wm, group)
def computeViewMatrixOnEarth(camera, scene, latLongHeight, hpr):
csn = findTopMostNodeOfType<osg.CoordinateSystemNode>(scene)
if not csn : return
# Compute eye point in world coordiantes
eye = osg.Vec3d()
csn.getEllipsoidModel().convertLatLongHeightToXYZ(
latLongHeight.x(), latLongHeight.y(), latLongHeight.z(), eye.x(), eye.y(), eye.z() )
# Build matrix for computing target vector
target_matrix = osg.Matrixd.rotate( -hpr.x(), osg.Vec3d(1,0,0),
-latLongHeight.x(), osg.Vec3d(0,1,0),
latLongHeight.y(), osg.Vec3d(0,0,1) )
# Compute tangent vector
tangent = target_matrix.preMult( osg.Vec3d(0,0,1) )
# Compute non-inclined, non-rolled up vector
up = osg.Vec3d( eye )
up.normalize()
# Incline by rotating the target- and up vector around the tangent/up-vector
# cross-product
up_cross_tangent = up ^ tangent
incline_matrix = osg.Matrixd.rotate( hpr.y(), up_cross_tangent )
target = incline_matrix.preMult( tangent )
# Roll by rotating the up vector around the target vector
roll_matrix = incline_matrix * osg.Matrixd.rotate( hpr.z(), target )
up = roll_matrix.preMult( up )
camera.setViewMatrixAsLookAt( eye, eye+target, up )
def traverse(nv):
if _dragger.valid() :
if _active and nv.getVisitorType()==osg.NodeVisitor.CULL_VISITOR :
cv = static_cast<osgUtil.CullVisitor*>(nv)
pixelSize = cv.pixelSize(_dragger.getBound().center(), 0.48)
if pixelSize not =_draggerSize :
pixelScale = _draggerSize/pixelSize if (pixelSize>0.0) else 1.0
scaleFactor = osg.Vec3d(pixelScale, pixelScale, pixelScale)
trans = _dragger.getMatrix().getTrans()
_dragger.setMatrix( osg.Matrix.scale(scaleFactor) * osg.Matrix.translate(trans) )
def main(argv):
# use an ArgumentParser object to manage the program arguments.
arguments = osg.ArgumentParser(argv)
# construct the viewer.
viewer = osgViewer.Viewer()
# add the state manipulator
viewer.addEventHandler( osgGA.StateSetManipulator(viewer.getCamera().getOrCreateStateSet()) )
# add stats
viewer.addEventHandler( osgViewer.StatsHandler() )
needToSetHomePosition = False
# read the scene from the list of file specified commandline args.
scene = osgDB.readNodeFiles(arguments)
# if one hasn't been loaded create an earth and sun test model.
if not scene :
scene = createScene()
needToSetHomePosition = True
# pass the loaded scene graph to the viewer.
viewer.setSceneData(scene)
viewer.setCameraManipulator(osgGA.TrackballManipulator)()
if needToSetHomePosition :
viewer.getCameraManipulator().setHomePosition(osg.Vec3d(0.0,-5.0*r_earth,0.0),osg.Vec3d(0.0,0.0,0.0),osg.Vec3d(0.0,0.0,1.0))
zNear = 1.0, zMid=10.0, zFar=1000.0
if arguments.read("--depth-partition",zNear, zMid, zFar) :
# set up depth partitioning
dps = osgViewer.DepthPartitionSettings()
dps._mode = osgViewer.DepthPartitionSettings.FIXED_RANGE
dps._zNear = zNear
dps._zMid = zMid
dps._zFar = zFar
viewer.setUpDepthPartition(dps)
else:
# set up depth partitioning with default settings
viewer.setUpDepthPartition()
return viewer.run()
def createScene():
# Create the Earth, in blue
earth_sd = osg.ShapeDrawable()
earth_sphere = osg.Sphere()
earth_sphere.setName("EarthSphere")
earth_sphere.setRadius(r_earth)
earth_sd.setShape(earth_sphere)
earth_sd.setColor(osg.Vec4(0, 0, 1.0, 1.0))
earth_geode = osg.Geode()
earth_geode.setName("EarthGeode")
earth_geode.addDrawable(earth_sd)
# Create the Sun, in yellow
sun_sd = osg.ShapeDrawable()
sun_sphere = osg.Sphere()
sun_sphere.setName("SunSphere")
sun_sphere.setRadius(r_sun)
sun_sd.setShape(sun_sphere)
sun_sd.setColor(osg.Vec4(1.0, 0.0, 0.0, 1.0))
sun_geode = osg.Geode()
sun_geode.setName("SunGeode")
sun_geode.addDrawable(sun_sd)
# Move the sun behind the earth
pat = osg.PositionAttitudeTransform()
pat.setPosition(osg.Vec3d(0.0, AU, 0.0))
pat.addChild(sun_geode)
unitCircle = osg.Geometry()
colours = osg.Vec4Array(1)
(*colours)[0] = osg.Vec4d(1.0,1.0,1.0,1.0)
unitCircle.setColorArray(colours, osg.Array.BIND_OVERALL)
n_points = 1024
coords = osg.Vec3Array(n_points)
dx = 2.0*osg.PI/n_points
double s,c
for (unsigned int j=0 j<n_points ++j)
for(unsigned int i=0 i<hat.getNumPoints() i++)
print " point = ", hat.getPoint(i), " hat = ", hat.getHeightAboveTerrain(i)
print "Completed in ", osg.Timer.instance().delta_s(startTick,endTick)
#endif
# now do a second traversal to test performance of cache.
startTick = osg.Timer.instance().tick()
print "Computing ElevationSlice"
es = osgSim.ElevationSlice()
es.setDatabaseCacheReadCallback(los.getDatabaseCacheReadCallback())
es.setStartPoint(bs.center()+osg.Vec3d(bs.radius(),0.0,0.0) )
es.setEndPoint(bs.center()+osg.Vec3d(0.0,0.0, bs.radius()) )
es.computeIntersections(scene)
endTick = osg.Timer.instance().tick()
print "Completed in ", osg.Timer.instance().delta_s(startTick,endTick)
typedef osgSim.ElevationSlice.DistanceHeightList DistanceHeightList
dhl = es.getDistanceHeightIntersections()
print "Number of intersections =", dhl.size()
for(DistanceHeightList.const_iterator dhitr = dhl.begin()
not = dhl.end()
++dhitr)
std.cout.precision(10)
def test_quat(self):
"Adapted from examples/osgunittests/osgunittests.cpp"
q1 = osg.Quat()
q1.makeRotate(osg.DegreesToRadians(30.0), 0.0, 0.0, 1.0)
q2 = osg.Quat()
q2.makeRotate(osg.DegreesToRadians(133.0), 0.0, 1.0, 1.0)
q1_2 = q1 * q2
q2_1 = q2 * q1
m1 = osg.Matrix.rotate(q1)
m2 = osg.Matrix.rotate(q2)
m1_2 = m1 * m2
m2_1 = m2 * m1
qm1_2 = osg.Quat()
qm1_2.set(m1_2)
qm2_1 = osg.Quat()
qm2_1.set(m2_1)
print "q1*q2 = ", q1_2
print "q2*q1 = ", q2_1
print "m1*m2 = ", qm1_2
print "m2*m1 = ", qm2_1
testQuatRotate(osg.Vec3d(1.0, 0.0, 0.0), osg.Vec3d(0.0, 1.0, 0.0))
testQuatRotate(osg.Vec3d(0.0, 1.0, 0.0), osg.Vec3d(1.0, 0.0, 0.0))
testQuatRotate(osg.Vec3d(0.0, 0.0, 1.0), osg.Vec3d(0.0, 1.0, 0.0))
testQuatRotate(osg.Vec3d(1.0, 1.0, 1.0), osg.Vec3d(1.0, 0.0, 0.0))
testQuatRotate(osg.Vec3d(1.0, 0.0, 0.0), osg.Vec3d(1.0, 0.0, 0.0))
testQuatRotate(osg.Vec3d(1.0, 0.0, 0.0), osg.Vec3d(-1.0, 0.0, 0.0))
testQuatRotate(osg.Vec3d(-1.0, 0.0, 0.0), osg.Vec3d(1.0, 0.0, 0.0))
testQuatRotate(osg.Vec3d(0.0, 1.0, 0.0), osg.Vec3d(0.0, -1.0, 0.0))
testQuatRotate(osg.Vec3d(0.0, -1.0, 0.0), osg.Vec3d(0.0, 1.0, 0.0))
testQuatRotate(osg.Vec3d(0.0, 0.0, 1.0), osg.Vec3d(0.0, 0.0, -1.0))
testQuatRotate(osg.Vec3d(0.0, 0.0, -1.0), osg.Vec3d(0.0, 0.0, 1.0))
# Test a range of rotations
testGetQuatFromMatrix(quat_scale)
# This is a specific test case for a matrix containing scale and rotation
matrix = osg.Matrix(0.5, 0.0, 0.0, 0.0, 0.0, 0.5, 0.0, 0.0, 0.0, 0.0,
0.5, 0.0, 1.0, 1.0, 1.0, 1.0)
quat = osg.Quat()
matrix.get(quat)
print "Matrix = ", matrix, "rotation = ", quat, ", expected quat = (0,0,0,1)"
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
from osgpypp import osg
import unittest
from numpy import arange
# osg.Matrix = osg.Matrixd
quat_scale = osg.Vec3d(1, 1, 1)
class TestQuat(unittest.TestCase):
def test_quat(self):
"Adapted from examples/osgunittests/osgunittests.cpp"
q1 = osg.Quat()
q1.makeRotate(osg.DegreesToRadians(30.0), 0.0, 0.0, 1.0)
q2 = osg.Quat()
q2.makeRotate(osg.DegreesToRadians(133.0), 0.0, 1.0, 1.0)
q1_2 = q1 * q2
q2_1 = q2 * q1
m1 = osg.Matrix.rotate(q1)
m2 = osg.Matrix.rotate(q2)
m1_2 = m1 * m2
m2_1 = m2 * m1
qm1_2 = osg.Quat()
qm1_2.set(m1_2)
qm2_1 = osg.Quat()
qm2_1.set(m2_1)
def testGetQuatFromMatrix(scale):
# Options
# acceptable error range
eps = 1e-6
# scale matrix
# To not test with scale, use 1,1,1
# Not sure if 0's or negative values are acceptable
scalemat = osg.Matrixd()
scalemat.makeScale(scale)
# range of rotations
if True:
# wide range
rol1start = 0.0
rol1stop = 360.0
rol1step = 20.0
pit1start = 0.0
pit1stop = 90.0
pit1step = 20.0
yaw1start = 0.0
yaw1stop = 360.0
yaw1step = 20.0
rol2start = 0.0
rol2stop = 360.0
rol2step = 20.0
pit2start = 0.0
pit2stop = 90.0
pit2step = 20.0
yaw2start = 0.0
yaw2stop = 360.0
yaw2step = 20.0
else:
# focussed range
rol1start = 0.0
rol1stop = 0.0
rol1step = 0.1
pit1start = 0.0
pit1stop = 5.0
pit1step = 5.0
yaw1start = 89.0
yaw1stop = 91.0
yaw1step = 0.0
rol2start = 0.0
rol2stop = 0.0
rol2step = 0.0
pit2start = 0.0
pit2stop = 0.0
pit2step = 0.1
yaw2start = 89.0
yaw2stop = 91.0
yaw2step = 0.1
#endif
print "Starting testGetQuatFromMatrix, it can take a while ..."
tstart = osg.Timer.instance().tick()
count = 0
for rol1 in arange(rol1start, rol1stop + 1, rol1step):
# for (double pit1 = pit1start pit1 <= pit1stop pit1 += pit1step)
for pit1 in arange(pit1start, pit1stop + 1, pit1step):
# for (double yaw1 = yaw1start yaw1 <= yaw1stop yaw1 += yaw1step)
for yaw1 in arange(yaw1start, yaw1stop + 1, yaw1step):
# for (double rol2 = rol2start rol2 <= rol2stop rol2 += rol2step)
for rol2 in arange(rol2start, rol2stop + 1, rol2step):
# for (double pit2 = pit2start pit2 <= pit2stop pit2 += pit2step)
for pit2 in arange(pit2start, pit2stop, pit2step):
# for (double yaw2 = yaw2start yaw2 <= yaw2stop yaw2 += yaw2step)
for yaw2 in arange(yaw2start, yaw2stop + 1, yaw2step):
count += 1
# create two quats based on the roll, pitch and yaw values
rot_quat1 = osg.Quat(osg.DegreesToRadians(rol1),
osg.Vec3d(1, 0, 0),
osg.DegreesToRadians(pit1),
osg.Vec3d(0, 1, 0),
osg.DegreesToRadians(yaw1),
osg.Vec3d(0, 0, 1))
rot_quat2 = osg.Quat(osg.DegreesToRadians(rol2),
osg.Vec3d(1, 0, 0),
osg.DegreesToRadians(pit2),
osg.Vec3d(0, 1, 0),
osg.DegreesToRadians(yaw2),
osg.Vec3d(0, 0, 1))
# create an output quat using quaternion math
out_quat1 = rot_quat2 * rot_quat1
# create two matrices based on the input quats
# osg.Matrixd mat1,mat2
mat1 = osg.Matrixd()
mat2 = osg.Matrixd()
mat1.makeRotate(rot_quat1)
mat2.makeRotate(rot_quat2)
# create an output quat by matrix multiplication and getRotate
out_mat = mat2 * mat1
# add matrix scale for even more nastiness
out_mat = out_mat * scalemat
out_quat2 = out_mat.getRotate()
# If the quaternion W is <0, then we should reflect
# to get it into the positive W.
# Unfortunately, when W is very small (close to 0), the sign
# does not really make sense because of precision problems
# and the reflection might not work.
if out_quat1.w() < 0:
out_quat1 = out_quat1 * -1.0
if out_quat2.w() < 0:
out_quat2 = out_quat2 * -1.0
# if the output quat length is not one
# or if the components do not match,
# something is amiss
componentsOK = False
if (((abs(out_quat1.x() - out_quat2.x())) < eps)
and
((abs(out_quat1.y() - out_quat2.y())) < eps)
and
((abs(out_quat1.z() - out_quat2.z())) < eps)
and
((abs(out_quat1.w() - out_quat2.w())) < eps)):
componentsOK = True
# We should also test for q = -q which is valid, so reflect
# one quat.
out_quat2 = out_quat2 * -1.0
if (((abs(out_quat1.x() - out_quat2.x())) < eps)
and
((abs(out_quat1.y() - out_quat2.y())) < eps)
and
((abs(out_quat1.z() - out_quat2.z())) < eps)
and
((abs(out_quat1.w() - out_quat2.w())) < eps)):
componentsOK = True
lengthOK = False
if (abs(1.0 - out_quat2.length()) < eps):
lengthOK = True
if (not lengthOK) or (not componentsOK):
print[
"testGetQuatFromMatrix problem at: \n",
" r1=", rol1, " p1=", pit1, " y1=", yaw1,
" r2=", rol2, " p2=", pit2, " y2=", yaw2
]
print "quats: ", out_quat1, " length: ", out_quat1.length(
), "\n"
print "mats and get: ", out_quat2, " length: ", out_quat2.length(
), "\n\n"
tstop = osg.Timer.instance().tick()
duration = osg.Timer.instance().delta_s(tstart, tstop)
print "Time for testGetQuatFromMatrix with ", count, " iterations: ", duration
DepthPeeling.CullCallback.CullCallback(unsigned int texUnit, unsigned int texWidth, unsigned int texHeight, unsigned int offsetValue) :
_texUnit(texUnit),
_texWidth(texWidth),
_texHeight(texHeight),
_offsetValue(offsetValue)
void DepthPeeling.CullCallback.operator()(osg.Node* node, osg.NodeVisitor* nv)
cullVisitor = static_cast<osgUtil.CullVisitor*>(nv)
renderStage = cullVisitor.getCurrentRenderStage()
viewport = renderStage.getViewport()
m = osg.Matrixd(*cullVisitor.getProjectionMatrix())
m.postMultTranslate(osg.Vec3d(1, 1, 1))
m.postMultScale(osg.Vec3d(0.5, 0.5, 0.5))
# scale the texture coordinates to the viewport
#ifdef USE_TEXTURE_RECTANGLE
m.postMultScale(osg.Vec3d(viewport.width(), viewport.height(), 1))
#else:
#ifndef USE_NON_POWER_OF_TWO_TEXTURE
m.postMultScale(osg.Vec3d(viewport.width()/double(_texWidth), viewport.height()/double(_texHeight), 1))
#endif
#endif
if _texUnit not = 0 and _offsetValue :
# Kind of polygon offset: note this way, we can also offset lines and points.
# Whereas with the polygon offset we could only handle surface primitives.
m.postMultTranslate(osg.Vec3d(0, 0, -ldexp(double(_offsetValue), -24)))
_image = osg.Image*()
#define NUM_TEXTURES 4
# 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))
class #OSGTEXT_EXPORT TextNode : public osg.Group
TextNode()
TextNode( TextNode text, osg.CopyOp copyop=osg.CopyOp.SHALLOW_COPY)
META_Node(osgText, TextNode)
traverse = virtual void(osg.NodeVisitor nv)
def setFont(font):
_font = font
def getFont():
return _font
def getFont():
return _font
def getActiveFont():
return _font : Font: if (_font.valid()) else getDefaultFont()
def getActiveFont():
return _font : Font: if (_font.valid()) else getDefaultFont()
def setStyle(style):
_style = style
def getStyle():
return _style
def getStyle():
return _style
def getActiveStyle():
return _style : Style: if (_style.valid()) else getDefaultStyle()
def getActiveStyle():
return _style : Style: if (_style.valid()) else getDefaultStyle()
def setLayout(layout):
_layout = layout
def getLayout():
return _layout
def getLayout():
return _layout
def getActiveLayout():
return _layout : Layout: if (_layout.valid()) else getDefaultLayout()
setTextTechnique = void(TextTechnique* technique)
def getTextTechnique():
return _technique
def getTextTechnique():
return _technique
setText = void( str str)
def setText(str):
_string = str
def getText():
return _string
def getText():
return _string
def setPosition(position):
_position = position
def getPosition():
return _position
def setRotation(rotation):
_rotation = rotation
def getRotation():
return _rotation
def setCharacterSize(characterSize):
_characterSize = characterSize
def getCharacterSize():
return _characterSize
#/ force a regeneration of the rendering backend required to represent the text.
update = virtual void()
virtual ~TextNode()
_font = Font()
_style = Style()
_layout = Layout()
_technique = TextTechnique()
_string = String()
_position = osg.Vec3d()
_rotation = osg.Quat()
_characterSize = float()
static TextTechnique s_defaultTextTechnique = TextTechnique()
return s_defaultTextTechnique
void TextTechnique.start()
OSG_NOTICE, "TextTechnique.start()"
void TextTechnique.addCharacter( osg.Vec3 position, osg.Vec3 size, Glyph* glyph, Style* style)
OSG_NOTICE, "TextTechnique.addCharacter 2D(", position, ", ", size, ", ", glyph, ", ", style, ")"
void TextTechnique.addCharacter( osg.Vec3 position, osg.Vec3 size, Glyph3D* glyph, Style* style)
OSG_NOTICE, "TextTechnique.addCharacter 3D(", position, ", ", size, ", ", glyph, ", ", style, ")"
transform = osg.PositionAttitudeTransform()
transform.setPosition(position)
transform.setAttitude(osg.Quat(osg.inDegrees(90.0),osg.Vec3d(1.0,0.0,0.0)))
transform.setScale(size)
geode = osg.Geode()
bevel = style.getBevel() if (style) else 0
outline = style.getOutlineRatio()>0.0 if (style) else False
width = style.getThicknessRatio()
creaseAngle = 30.0
smooth = True
if bevel :
thickness = bevel.getBevelThickness()
glyphGeometry = osgText.computeGlyphGeometry(glyph, thickness, width)
textGeometry = osgText.computeTextGeometry(glyphGeometry, *bevel, width)
def main(argv):
# use an ArgumentParser object to manage the program arguments.
arguments = osg.ArgumentParser(argv)
scene = osgDB.readNodeFiles(arguments)
if not scene :
print "No model loaded, please specify a valid model on the command line."
return 0
print "Intersection "
bs = scene.getBound()
useIntersectorGroup = True
useLineOfSight = True
#osg.CoordinateSystemNode* csn = dynamic_cast<osg.CoordinateSystemNode*>(scene)
#osg.EllipsoidModel* em = csn.getEllipsoidModel() if (csn) else 0
if useLineOfSight :
start = bs.center() + osg.Vec3d(0.0,bs.radius(),0.0)
end = bs.center() - osg.Vec3d(0.0, bs.radius(),0.0)
deltaRow = osg.Vec3d( 0.0, 0.0, bs.radius()*0.01)
deltaColumn = osg.Vec3d( bs.radius()*0.01, 0.0, 0.0)
los = osgSim.LineOfSight()
#if 1
numRows = 20
numColumns = 20
hat = osgSim.HeightAboveTerrain()
hat.setDatabaseCacheReadCallback(los.getDatabaseCacheReadCallback())
for(unsigned int r=0 r<numRows ++r)
for(unsigned int c=0 c<numColumns ++c)
s = start + deltaColumn * double(c) + deltaRow * double(r)
e = end + deltaColumn * double(c) + deltaRow * double(r)
los.addLOS(s,e)
hat.addPoint(s)
print "Computing LineOfSight"
startTick = osg.Timer.instance().tick()
los.computeIntersections(scene)
endTick = osg.Timer.instance().tick()
print "Completed in ", osg.Timer.instance().delta_s(startTick,endTick)
for(unsigned int i=0 i<los.getNumLOS() i++)
intersections = los.getIntersections(i)
for(osgSim.LineOfSight.Intersections.const_iterator itr = intersections.begin()
not = intersections.end()
++itr)
print " point ", *itr
switch(ea.getEventType())
case(osgGA.GUIEventAdapter.PUSH):
view = dynamic_cast<osgViewer.View*>(aa)
if view : pick(view,ea)
return False
case(osgGA.GUIEventAdapter.KEYUP):
if ea.getKey() == ord("t") :
user_event = osgGA.GUIEventAdapter()
user_event.setEventType(osgGA.GUIEventAdapter.USER)
user_event.setUserValue("vec2f", osg.Vec2f(1.0,2.0))
user_event.setUserValue("vec3f", osg.Vec3f(1.0,2.0, 3.0))
user_event.setUserValue("vec4f", osg.Vec4f(1.0,2.0, 3.0, 4.0))
user_event.setUserValue("vec2d", osg.Vec2d(1.0,2.0))
user_event.setUserValue("vec3d", osg.Vec3d(1.0,2.0, 3.0))
user_event.setUserValue("vec4d", osg.Vec4d(1.0,2.0, 3.0, 4.0))
user_event.setName("osc_test_1")
_device.sendEvent(*user_event)
default:
return False
void PickHandler.pick(osgViewer.View* view, osgGA.GUIEventAdapter ea)
intersections = osgUtil.LineSegmentIntersector.Intersections()
gdlist = ""
x = ea.getX()
pat = osg.PositionAttitudeTransform()
pat.setPosition(osg.Vec3d(0.0, AU, 0.0))
pat.addChild(sun_geode)
unitCircle = osg.Geometry()
colours = osg.Vec4Array(1)
(*colours)[0] = osg.Vec4d(1.0,1.0,1.0,1.0)
unitCircle.setColorArray(colours, osg.Array.BIND_OVERALL)
n_points = 1024
coords = osg.Vec3Array(n_points)
dx = 2.0*osg.PI/n_points
double s,c
for (unsigned int j=0 j<n_points ++j)
s = sin(dx*j)
c = cos(dx*j)
(*coords)[j].set(osg.Vec3d(c,s,0.0))
unitCircle.setVertexArray(coords)
unitCircle.getOrCreateStateSet().setMode(GL_LIGHTING,osg.StateAttribute.OFF)
unitCircle.addPrimitiveSet(osg.DrawArrays(osg.PrimitiveSet.LINE_LOOP,0,n_points))
axes = osg.Geometry()
colours = osg.Vec4Array(1)
(*colours)[0] = osg.Vec4d(1.0,0.0,0.0,1.0)
axes.setColorArray(colours, osg.Array.BIND_OVERALL)
coords = osg.Vec3Array(6)
(*coords)[0].set(osg.Vec3d(0.0, 0.0, 0.0))
(*coords)[1].set(osg.Vec3d(0.5, 0.0, 0.0))
(*coords)[2].set(osg.Vec3d(0.0, 0.0, 0.0))
(*coords)[3].set(osg.Vec3d(0.0, 0.5, 0.0))
(*coords)[4].set(osg.Vec3d(0.0, 0.0, 0.0))
(*coords)[5].set(osg.Vec3d(0.0, 0.0, 0.5))
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)
#if 1
if node.getName().find("Presentation")==str.npos :
screenWidth = osg.DisplaySettings.instance().getScreenWidth()
screenHeight = osg.DisplaySettings.instance().getScreenHeight()
screenDistance = osg.DisplaySettings.instance().getScreenDistance()
vfov = atan2(screenHeight/2.0,screenDistance)*2.0
hfov = atan2(screenWidth/2.0,screenDistance)*2.0
viewAngle = vfov if (vfov<hfov) else hfov
dist = bs.radius() / sin(viewAngle*0.5)
#endif
_center = bs.center()
_eye = _center - osg.Vec3d(0.0, dist, 0.0)
_up = osg.Vec3d(0.0, 0.0, 1.0)
_rotationCenter = _center
_rotationAxis = osg.Vec3d(0.0, 0.0, 1.0)
_rotationSpeed = 0.0
void CameraProperty.update(osgViewer.View* view)
camera = view.getCamera()
fs = view.getFrameStamp()
matrix = osg.Matrixd()
matrix.makeLookAt(_eye, _center, _up)
if _rotationSpeed not =0.0 :
def main(argv):
arguments = osg.ArgumentParser( argc, argv )
usage = arguments.getApplicationUsage()
usage.setDescription( arguments.getApplicationName() +
" is the example which demonstrates how to render high-resolution images (posters).")
usage.setCommandLineUsage( arguments.getApplicationName() + " [options] scene_file" )
usage.addCommandLineOption( "-h or --help", "Display this information." )
usage.addCommandLineOption( "--color <r> <g> <b>", "The background color." )
usage.addCommandLineOption( "--ext <ext>", "The output tiles' extension (Default: bmp)." )
usage.addCommandLineOption( "--poster <filename>", "The output poster's name (Default: poster.bmp)." )
usage.addCommandLineOption( "--tilesize <w> <h>", "Size of each image tile (Default: 640 480)." )
usage.addCommandLineOption( "--finalsize <w> <h>", "Size of the poster (Default: 6400 4800)." )
usage.addCommandLineOption( "--enable-output-poster", "Output the final poster file (Default)." )
usage.addCommandLineOption( "--disable-output-poster", "Don't output the final poster file." )
#usage.addCommandLineOption( "--enable-output-tiles", "Output all tile files." )
#usage.addCommandLineOption( "--disable-output-tiles", "Don't output all tile files (Default)." )
usage.addCommandLineOption( "--use-fb", "Use Frame Buffer for rendering tiles (Default, recommended).")
usage.addCommandLineOption( "--use-fbo", "Use Frame Buffer Object for rendering tiles.")
usage.addCommandLineOption( "--use-pbuffer","Use Pixel Buffer for rendering tiles.")
usage.addCommandLineOption( "--use-pbuffer-rtt","Use Pixel Buffer RTT for rendering tiles.")
usage.addCommandLineOption( "--inactive", "Inactive capturing mode." )
usage.addCommandLineOption( "--camera-eye <x> <y> <z>", "Set eye position in inactive mode." )
usage.addCommandLineOption( "--camera-latlongheight <lat> <lon> <h>", "Set eye position on earth in inactive mode." )
usage.addCommandLineOption( "--camera-hpr <h> <p> <r>", "Set eye rotation in inactive mode." )
if arguments.read("-h") or arguments.read("--help") :
usage.write( std.cout )
return 1
# Poster arguments
activeMode = True
outputPoster = True
#bool outputTiles = False
tileWidth = 640, tileHeight = 480
posterWidth = 640*2, posterHeight = 480*2
posterName = "poster.bmp", extName = "bmp"
bgColor = osg.Vec4(0.2, 0.2, 0.6, 1.0)
renderImplementation = osg.Camera.FRAME_BUFFER_OBJECT
while arguments.read("--inactive") : activeMode = False
while arguments.read("--color", bgColor.r(), bgColor.g(), bgColor.b()) :
while arguments.read("--tilesize", tileWidth, tileHeight) :
while arguments.read("--finalsize", posterWidth, posterHeight) :
while arguments.read("--poster", posterName) :
while arguments.read("--ext", extName) :
while arguments.read("--enable-output-poster") : outputPoster = True
while arguments.read("--disable-output-poster") : outputPoster = False
#while arguments.read("--enable-output-tiles") : outputTiles = True
#while arguments.read("--disable-output-tiles") : outputTiles = False
while arguments.read("--use-fbo") : renderImplementation = osg.Camera.FRAME_BUFFER_OBJECT
while arguments.read("--use-pbuffer") : renderImplementation = osg.Camera.PIXEL_BUFFER
while arguments.read("--use-pbuffer-rtt") : renderImplementation = osg.Camera.PIXEL_BUFFER_RTT
while arguments.read("--use-fb") : renderImplementation = osg.Camera.FRAME_BUFFER
# Camera settings for inactive screenshot
useLatLongHeight = True
eye = osg.Vec3d()
latLongHeight = osg.Vec3d( 50.0, 10.0, 2000.0 )
hpr = osg.Vec3d( 0.0, 0.0, 0.0 )
if arguments.read("--camera-eye", eye.x(), eye.y(), eye.z()) :
useLatLongHeight = False
activeMode = False
elif arguments.read("--camera-latlongheight", latLongHeight.x(), latLongHeight.y(), latLongHeight.z()) :
activeMode = False
latLongHeight.x() = osg.DegreesToRadians( latLongHeight.x() )
latLongHeight.y() = osg.DegreesToRadians( latLongHeight.y() )
if arguments.read("--camera-hpr", hpr.x(), hpr.y(), hpr.z()) :
activeMode = False
hpr.x() = osg.DegreesToRadians( hpr.x() )
hpr.y() = osg.DegreesToRadians( hpr.y() )
hpr.z() = osg.DegreesToRadians( hpr.z() )
# Construct scene graph
scene = osgDB.readNodeFiles( arguments )
if not scene : scene = osgDB.readNodeFile( "cow.osgt" )
if not scene :
print arguments.getApplicationName(), ": No data loaded"
return 1
# Create camera for rendering tiles offscreen. FrameBuffer is recommended because it requires less memory.
camera = osg.Camera()
camera.setClearColor( bgColor )
camera.setClearMask( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT )
camera.setReferenceFrame( osg.Transform.ABSOLUTE_RF )
camera.setRenderOrder( osg.Camera.PRE_RENDER )
camera.setRenderTargetImplementation( renderImplementation )
camera.setViewport( 0, 0, tileWidth, tileHeight )
camera.addChild( scene )
# Set the printer
printer = PosterPrinter()
printer.setTileSize( tileWidth, tileHeight )
printer.setPosterSize( posterWidth, posterHeight )
printer.setCamera( camera )
posterImage = 0
if outputPoster :
posterImage = osg.Image()
posterImage.allocateImage( posterWidth, posterHeight, 1, GL_RGBA, GL_UNSIGNED_BYTE )
printer.setFinalPoster( posterImage )
printer.setOutputPosterName( posterName )
#if 0
# While recording sub-images of the poster, the scene will always be traversed twice, from its two
# parent node: root and camera. Sometimes this may not be so comfortable.
# To prevent this behaviour, we can use a switch node to enable one parent and disable the other.
# However, the solution also needs to be used with care, as the window will go blank while taking
# snapshots and recover later.
root = osg.Switch()
root.addChild( scene, True )
root.addChild( camera, False )
#else:
root = osg.Group()
root.addChild( scene )
root.addChild( camera )
#endif
viewer = osgViewer.Viewer()
viewer.setSceneData( root )
viewer.getDatabasePager().setDoPreCompile( False )
if renderImplementation==osg.Camera.FRAME_BUFFER :
# FRAME_BUFFER requires the window resolution equal or greater than the to-be-copied size
viewer.setUpViewInWindow( 100, 100, tileWidth, tileHeight )
else:
# We want to see the console output, so just render in a window
viewer.setUpViewInWindow( 100, 100, 800, 600 )
if activeMode :
viewer.addEventHandler( PrintPosterHandler(printer) )
viewer.addEventHandler( osgViewer.StatsHandler )()
viewer.addEventHandler( osgGA.StateSetManipulator(viewer.getCamera().getOrCreateStateSet()) )
viewer.setCameraManipulator( osgGA.TrackballManipulator )()
viewer.run()
else:
camera = viewer.getCamera()
if not useLatLongHeight : computeViewMatrix( camera, eye, hpr )
computeViewMatrixOnEarth = else( camera, scene, latLongHeight, hpr )
renderer = CustomRenderer( camera )
camera.setRenderer( renderer )
viewer.setThreadingModel( osgViewer.Viewer.SingleThreaded )
# Realize and initiate the first PagedLOD request
viewer.realize()
viewer.frame()
printer.init( camera )
while not printer.done() :
viewer.advance()
# Keep updating and culling until full level of detail is reached
renderer.setCullOnly( True )
while viewer.getDatabasePager().getRequestsInProgress() :
viewer.updateTraversal()
viewer.renderingTraversals()
renderer.setCullOnly( False )
printer.frame( viewer.getFrameStamp(), viewer.getSceneData() )
viewer.renderingTraversals()
return 0
# Translated from file 'PosterPrinter.cpp'
#include <osg/ClusterCullingCallback>
#include <osgDB/ReadFile>
#include <osgDB/WriteFile>
#include <string.h>
#include <iostream>
#include <sstream>
#include "PosterPrinter.h"
# PagedLoadingCallback: Callback for loading paged nodes while doing intersecting test
class PagedLoadingCallback (osgUtil.IntersectionVisitor.ReadCallback) :
def readNodeFile(filename):
return osgDB.readNodeFile( filename )
static PagedLoadingCallback g_pagedLoadingCallback = PagedLoadingCallback()
# LodCullingCallback: Callback for culling LODs and selecting the highest level
class LodCullingCallback (osg.NodeCallback) :
virtual void operator()( osg.Node* node, osg.NodeVisitor* nv )
lod = static_cast<osg.LOD*>(node)
if lod and lod.getNumChildren()>0 :
lod.getChild(lod.getNumChildren()-1).accept(*nv)
static LodCullingCallback g_lodCullingCallback = LodCullingCallback()
# PagedCullingCallback: Callback for culling paged nodes and selecting the highest level
class PagedCullingCallback (osg.NodeCallback) :
virtual void operator()( osg.Node* node, osg.NodeVisitor* nv )
pagedLOD = static_cast<osg.PagedLOD*>(node)
if pagedLOD and pagedLOD.getNumChildren()>0 :
numChildren = pagedLOD.getNumChildren()
updateTimeStamp = nv.getVisitorType()==osg.NodeVisitor.CULL_VISITOR
if nv.getFrameStamp() and updateTimeStamp :
timeStamp = nv.getFrameStamp().getReferenceTime() if (nv.getFrameStamp()) else 0.0
frameNumber = nv.getFrameStamp().getFrameNumber() if (nv.getFrameStamp()) else 0
pagedLOD.setFrameNumberOfLastTraversal( frameNumber )
pagedLOD.setTimeStamp( numChildren-1, timeStamp )
pagedLOD.setFrameNumber( numChildren-1, frameNumber )
pagedLOD.getChild(numChildren-1).accept(*nv)
# Request for child
if not pagedLOD.getDisableExternalChildrenPaging() and
nv.getDatabaseRequestHandler() and
numChildren<pagedLOD.getNumRanges() :
if pagedLOD.getDatabasePath().empty() :
nv.getDatabaseRequestHandler().requestNodeFile(
pagedLOD.getFileName(numChildren), nv.getNodePath(),
1.0, nv.getFrameStamp(),
pagedLOD.getDatabaseRequest(numChildren), pagedLOD.getDatabaseOptions() )
else:
nv.getDatabaseRequestHandler().requestNodeFile(
pagedLOD.getDatabasePath()+pagedLOD.getFileName(numChildren), nv.getNodePath(),
1.0, nv.getFrameStamp(),
pagedLOD.getDatabaseRequest(numChildren), pagedLOD.getDatabaseOptions() )
#node.traverse(*nv)
static PagedCullingCallback g_pagedCullingCallback = PagedCullingCallback()
# PosterVisitor: A visitor for adding culling callbacks to newly allocated paged nodes
PosterVisitor.PosterVisitor()
: osg.NodeVisitor(osg.NodeVisitor.TRAVERSE_ALL_CHILDREN),
_appliedCount(0), _needToApplyCount(0),
_addingCallbacks(True)
void PosterVisitor.apply( osg.LOD node )
#if not hasCullCallback(node.getCullCallback(), g_lodCullingCallback) :
#
# if not node.getName().empty() :
#
# itr = _pagedNodeNames.find( node.getName() )
# if itr not =_pagedNodeNames.end() :
#
# insertCullCallback( node, g_lodCullingCallback )
# _appliedCount++
#
#
#
# def if _addingCallbacks .
#
# node.removeCullCallback( g_lodCullingCallback )
# _appliedCount--
#
traverse( node )
void PosterVisitor.apply( osg.PagedLOD node )
if not hasCullCallback(node.getCullCallback(), g_pagedCullingCallback) :
for ( unsigned int i=0 i<node.getNumFileNames() ++i )
if node.getFileName(i).empty() : continue
itr = _pagedNodeNames.find( node.getFileName(i) )
if itr not =_pagedNodeNames.end() :
node.addCullCallback( g_pagedCullingCallback )
_appliedCount++
break
# 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
# Setup specified camera
if camera_specified :
csn = findTopMostNodeOfType<osg.CoordinateSystemNode>(loadedModel)
if not csn : return 1
# Compute eye point in world coordiantes
eye = osg.Vec3d()
csn.getEllipsoidModel().convertLatLongHeightToXYZ(lat, lon, alt, eye.x(), eye.y(), eye.z())
# Build matrix for computing target vector
target_matrix = osg.Matrixd.rotate(-heading, osg.Vec3d(1,0,0),
-lat, osg.Vec3d(0,1,0),
lon, osg.Vec3d(0,0,1))
# Compute tangent vector ...
tangent = target_matrix.preMult(osg.Vec3d(0, 0, 1))
# Compute non-inclined, non-rolled up vector ...
up = osg.Vec3d(eye)
up.normalize()
# Incline by rotating the target- and up vector around the tangent/up-vector