def createMask():
vertices = osg.Vec3Array()
vertices.push_back(osg.Vec3(-0.5, -0.5, 0.0))
vertices.push_back(osg.Vec3(0.5, -0.5, 0.0))
vertices.push_back(osg.Vec3(0.5, 0.5, 0.0))
vertices.push_back(osg.Vec3(-0.5, 0.5, 0.0))
geom = osg.Geometry()
geom.setVertexArray(vertices)
geom.addPrimitiveSet(osg.DrawArrays(GL_QUADS, 0, 4))
geode = osg.Geode()
geode.addDrawable(geom)
stencil = osg.Stencil()
stencil.setFunction(osg.Stencil.ALWAYS, 1, ~0u)
stencil.setOperation(osg.Stencil.KEEP, osg.Stencil.KEEP, osg.Stencil.REPLACE)
ss = geode.getOrCreateStateSet()
ss.setAttributeAndModes(stencil,
osg.StateAttribute.ON | osg.StateAttribute.OVERRIDE)
ss.setAttribute(osg.ColorMask(False, False, False, False),
osg.StateAttribute.ON | osg.StateAttribute.OVERRIDE)
return geode
def createSquare(textureCoordMax):
# set up the Geometry.
geom = osg.Geometry()
coords = osg.Vec3Array(4)
(*coords)[0].set(-1.0,0.0,1.0)
(*coords)[1].set(-1.0,0.0,-1.0)
(*coords)[2].set(1.0,0.0,-1.0)
(*coords)[3].set(1.0,0.0,1.0)
geom.setVertexArray(coords)
norms = osg.Vec3Array(1)
(*norms)[0].set(0.0,-1.0,0.0)
geom.setNormalArray(norms, osg.Array.BIND_OVERALL)
tcoords = osg.Vec2Array(4)
(*tcoords)[0].set(0.0,textureCoordMax)
(*tcoords)[1].set(0.0,0.0)
(*tcoords)[2].set(textureCoordMax,0.0)
(*tcoords)[3].set(textureCoordMax,textureCoordMax)
geom.setTexCoordArray(0,tcoords)
geom.addPrimitiveSet(osg.DrawArrays(osg.PrimitiveSet.QUADS,0,4))
return geom
def createTextureQuad(texture):
vertices = osg.Vec3Array()
vertices.push_back(osg.Vec3(-0.8, 0.0, -0.8))
vertices.push_back(osg.Vec3(0.8, 0.0, -0.8))
vertices.push_back(osg.Vec3(0.8, 0.0, 0.8))
vertices.push_back(osg.Vec3(-0.8, 0.0, 0.8))
texcoord = osg.Vec2Array()
texcoord.push_back(osg.Vec2(0.0, 0.0))
texcoord.push_back(osg.Vec2(1.0, 0.0))
texcoord.push_back(osg.Vec2(1.0, 1.0))
texcoord.push_back(osg.Vec2(0.0, 1.0))
geom = osg.Geometry()
geom.setVertexArray(vertices)
geom.setTexCoordArray(0, texcoord)
geom.addPrimitiveSet(osg.DrawArrays(GL_QUADS, 0, 4))
geode = osg.Geode()
geode.addDrawable(geom)
geode.getOrCreateStateSet().setTextureAttributeAndModes(0, texture, osg.StateAttribute.ON)
return geode
def createGeometry():
geode = osg.Geode()
# create Geometry
geom = osg.Geometry(osg.Geometry())
# add vertices using MyArray class
numVertices = sizeof(myVertices)/sizeof(myVertices[0])
geom.setVertexArray(MyArray(numVertices,const_cast<osg.Vec3*>(myVertices[0])))
# add normals
numNormals = sizeof(myNormals)/sizeof(myNormals[0])
geom.setNormalArray(osg.Vec3Array(numNormals,const_cast<osg.Vec3*>(myNormals[0])), osg.Array.BIND_PER_VERTEX)
# add colors
numColors = sizeof(myColors)/sizeof(myColors[0])
normal_array = osg.Vec4Array(numColors,const_cast<osg.Vec4*>(myColors[0]))
geom.setColorArray(normal_array, osg.Array.BIND_PER_VERTEX)
# add PrimitiveSet
geom.addPrimitiveSet(osg.DrawArrays(osg.PrimitiveSet.QUADS, 0, numVertices))
# Changing these flags will tickle different cases in
# Geometry.drawImplementation. They should all work fine
# with the shared array.
geom.setUseVertexBufferObjects(False)
geom.setUseDisplayList(False)
geode.addDrawable( geom )
return geode
def createTexturedQuadGeometry(corner, widthVec, heightVec, l, b, r, t):
g = osg.Geometry()
# Create vertex array
vertices = osg.Vec3Array()
vertices.append(corner + widthVec)
vertices.append(corner)
vertices.append(corner + heightVec)
vertices.append(corner + widthVec + heightVec)
g.setVertexArray(vertices)
# Create texcoord array
texcoords = osg.Vec2Array()
texcoords.append(osg.Vec2f(l, t))
texcoords.append(osg.Vec2f(l, b))
texcoords.append(osg.Vec2f(r, b))
texcoords.append(osg.Vec2f(r, t))
g.setTexCoordArray(0, texcoords)
# Create color array (single value, white)
colors = osg.Vec4Array()
colors.append(osg.Vec4f(1, 1, 1, 1))
g.setColorArray(colors)
g.colorBinding = osg.Geometry.BIND_OVERALL
# Create normal array (single value for all vertices)
normals = osg.Vec3Array()
normals.append(osg.Vec3f(0, -1, 0))
g.setNormalArray(normals)
g.normalBinding = osg.Geometry.BIND_OVERALL
# Add primitive set
g.addPrimitiveSet(osg.DrawArrays(osg.PrimitiveSet.QUADS, 0, 4))
return g
def createMirrorSurface(xMin, xMax, yMin, yMax, z):
# set up the drawstate.
# set up the Geometry.
geom = osg.Geometry()
coords = osg.Vec3Array(4)
(*coords)[0].set(xMin,yMax,z)
(*coords)[1].set(xMin,yMin,z)
(*coords)[2].set(xMax,yMin,z)
(*coords)[3].set(xMax,yMax,z)
geom.setVertexArray(coords)
norms = osg.Vec3Array(1)
(*norms)[0].set(0.0,0.0,1.0)
geom.setNormalArray(norms, osg.Array.BIND_OVERALL)
tcoords = osg.Vec2Array(4)
(*tcoords)[0].set(0.0,1.0)
(*tcoords)[1].set(0.0,0.0)
(*tcoords)[2].set(1.0,0.0)
(*tcoords)[3].set(1.0,1.0)
geom.setTexCoordArray(0,tcoords)
colours = osg.Vec4Array(1)
(*colours)[0].set(1.0,1.0,1.0,1.0)
geom.setColorArray(colours, osg.Array.BIND_OVERALL)
geom.addPrimitiveSet(osg.DrawArrays(osg.PrimitiveSet.QUADS,0,4))
return geom
class SomePoints (osg.Geometry) :
SomePoints()
cAry = osg.Vec4Array()
setColorArray( cAry, osg.Array.BIND_OVERALL )
cAry.push_back( osg.Vec4(1,1,1,1) )
vAry = osg.Vec3Array()
setVertexArray( vAry )
vAry.push_back( osg.Vec3(0,0,0) )
vAry.push_back( osg.Vec3(0,1,0) )
vAry.push_back( osg.Vec3(1,0,0) )
vAry.push_back( osg.Vec3(1,1,0) )
vAry.push_back( osg.Vec3(0,0,1) )
vAry.push_back( osg.Vec3(0,1,1) )
vAry.push_back( osg.Vec3(1,0,1) )
vAry.push_back( osg.Vec3(1,1,1) )
addPrimitiveSet( osg.DrawArrays( GL_POINTS, 0, vAry.size() ) )
sset = getOrCreateStateSet()
sset.setMode( GL_LIGHTING, osg.StateAttribute.OFF )
# if things go wrong, fall back to big points
p = osg.Point()
p.setSize(6)
sset.setAttribute( p )
#ifdef ENABLE_GLSL
sset.setAttribute( createShader() )
# a generic cyclic animation value
u_anim1 = osg.Uniform*( osg.Uniform( "u_anim1", 0.0 ) )
u_anim1.setUpdateCallback( SineAnimation( 4, 0.5, 0.5 ) )
sset.addUniform( u_anim1 )
def createAxis():
geode = osg.Geode(osg.Geode())
geometry = osg.Geometry(osg.Geometry())
vertices = osg.Vec3Array(osg.Vec3Array())
vertices.push_back (osg.Vec3 ( 0.0, 0.0, 0.0))
vertices.push_back (osg.Vec3 ( 10.0, 0.0, 0.0))
vertices.push_back (osg.Vec3 ( 0.0, 0.0, 0.0))
vertices.push_back (osg.Vec3 ( 0.0, 10.0, 0.0))
vertices.push_back (osg.Vec3 ( 0.0, 0.0, 0.0))
vertices.push_back (osg.Vec3 ( 0.0, 0.0, 10.0))
geometry.setVertexArray (vertices)
colors = osg.Vec4Array(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, osg.Array.BIND_PER_VERTEX)
geometry.addPrimitiveSet(osg.DrawArrays(osg.PrimitiveSet.LINES,0,6))
geode.addDrawable( geometry )
geode.getOrCreateStateSet().setMode(GL_LIGHTING, False)
return geode
def createMirrorSurface(xMin,xMax,yMin,yMax,z):
#// set up the drawstate.
#// set up the Geometry.
geom = osg.Geometry();
coords = osg.Vec3Array();
coords.append(osg.Vec3f(xMin,yMax,z))
coords.append(osg.Vec3f(xMin,yMin,z))
coords.append(osg.Vec3f(xMax,yMin,z))
coords.append(osg.Vec3f(xMax,yMax,z))
geom.setVertexArray(coords);
norms = osg.Vec3Array();
norms.append(osg.Vec3f(0.0,0.0,1.0))
geom.setNormalArray(norms);
geom.normalBinding = osg.Geometry.BIND_OVERALL
tcoords = osg.Vec2Array()
tcoords.append(osg.Vec2f(0.0,1.0))
tcoords.append(osg.Vec2f(0.0,0.0))
tcoords.append(osg.Vec2f(1.0,0.0))
tcoords.append(osg.Vec2f(1.0,1.0))
geom.setTexCoordArray(0,tcoords);
colours = osg.Vec4Array();
colours.append(osg.Vec4f(1.0,1.0,1.0,1.0))
geom.setColorArray(colours);
geom.colorBinding = osg.Geometry.BIND_OVERALL;
geom.addPrimitiveSet(osg.DrawArrays(osg.PrimitiveSet.QUADS,0,4));
return geom;
def createGeometry():
vertices = osg.Vec3Array()
vertices.push_back(osg.Vec3(-1.0, -1.0, 0.0))
vertices.push_back(osg.Vec3(1.0, -1.0, 0.0))
vertices.push_back(osg.Vec3(1.0, 1.0, 0.0))
vertices.push_back(osg.Vec3(-1.0, 1.0, 0.0))
geom = osg.Geometry()
geom.setVertexArray(vertices)
geom.addPrimitiveSet(osg.DrawArrays(GL_QUADS, 0, 4))
geode = osg.Geode()
geode.addDrawable(geom)
stencil = osg.Stencil()
stencil.setFunction(osg.Stencil.NOTEQUAL, 1, ~0u)
stencil.setOperation(osg.Stencil.KEEP, osg.Stencil.KEEP, osg.Stencil.KEEP)
ss = geode.getOrCreateStateSet()
ss.setAttributeAndModes(stencil,
osg.StateAttribute.ON | osg.StateAttribute.OVERRIDE)
return geode
def createSquare(corner, width, height, image):
# set up the Geometry.
geom = osg.Geometry()
coords = osg.Vec3Array(4)
(*coords)[0] = corner
(*coords)[1] = corner+width
(*coords)[2] = corner+width+height
(*coords)[3] = corner+height
geom.setVertexArray(coords)
norms = osg.Vec3Array(1)
(*norms)[0] = width^height
(*norms)[0].normalize()
geom.setNormalArray(norms, osg.Array.BIND_OVERALL)
tcoords = osg.Vec2Array(4)
(*tcoords)[0].set(0.0,0.0)
(*tcoords)[1].set(1.0,0.0)
(*tcoords)[2].set(1.0,1.0)
(*tcoords)[3].set(0.0,1.0)
geom.setTexCoordArray(0,tcoords)
colours = osg.Vec4Array(1)
(*colours)[0].set(1.0,1.0,1.0,1.0)
geom.setColorArray(colours, osg.Array.BIND_OVERALL)
geom.addPrimitiveSet(osg.DrawArrays(osg.PrimitiveSet.QUADS,0,4))
if image :
stateset = osg.StateSet()
texture = osg.Texture2D()
texture.setImage(image)
stateset.setTextureAttributeAndModes(0,texture,osg.StateAttribute.ON)
stateset.setMode(GL_LIGHTING, osg.StateAttribute.OFF)
stateset.setMode(GL_BLEND, osg.StateAttribute.ON)
stateset.setRenderingHint(osg.StateSet.TRANSPARENT_BIN)
geom.setStateSet(stateset)
return geom
def createDAIGeometry(geom, nInstances):
halfDimX = float( .5 )
halfDimZ = float( .5 )
v = osg.Vec3Array()
v.resize( 4 )
geom.setVertexArray( v )
# Geometry for a single quad.
(*v)[ 0 ] = osg.Vec3( -halfDimX, 0., -halfDimZ )
(*v)[ 1 ] = osg.Vec3( halfDimX, 0., -halfDimZ )
(*v)[ 2 ] = osg.Vec3( halfDimX, 0., halfDimZ )
(*v)[ 3 ] = osg.Vec3( -halfDimX, 0., halfDimZ )
# Use the DrawArraysInstanced PrimitiveSet and tell it to draw 1024 instances.
geom.addPrimitiveSet( osg.DrawArrays( GL_QUADS, 0, 4, nInstances ) )
def createEaseMotionGeometry(motion):
geom = osg.Geometry()
cols = osg.Vec4Array()
v = osg.Vec3Array()
for(float i = 0.0 i < M_DURATION i += M_DURATION / 256.0) v.push_back(
osg.Vec3(i * 30.0, motion.getValueAt(i) * 30.0, 0.0)
)
cols.push_back(osg.Vec4(1.0, 1.0, 1.0, 1.0))
geom.setUseDisplayList(False)
geom.setVertexArray(v)
geom.setColorArray(cols, osg.Array.BIND_OVERALL)
geom.addPrimitiveSet(osg.DrawArrays(osg.PrimitiveSet.LINE_STRIP, 0, v.size()))
return geom
def createAxis(corner, xdir, ydir, zdir):
# set up the Geometry.
geom = osg.Geometry()
coords = osg.Vec3Array(6)
(*coords)[0] = corner
(*coords)[1] = corner+xdir
(*coords)[2] = corner
(*coords)[3] = corner+ydir
(*coords)[4] = corner
(*coords)[5] = corner+zdir
geom.setVertexArray(coords)
x_color = osg.Vec4(0.0,1.0,1.0,1.0)
y_color = osg.Vec4(0.0,1.0,1.0,1.0)
z_color = osg.Vec4(1.0,0.0,0.0,1.0)
color = osg.Vec4Array(6)
(*color)[0] = x_color
(*color)[1] = x_color
(*color)[2] = y_color
(*color)[3] = y_color
(*color)[4] = z_color
(*color)[5] = z_color
geom.setColorArray(color, osg.Array.BIND_PER_VERTEX)
geom.addPrimitiveSet(osg.DrawArrays(osg.PrimitiveSet.LINES,0,6))
stateset = osg.StateSet()
linewidth = osg.LineWidth()
linewidth.setWidth(4.0)
stateset.setAttributeAndModes(linewidth,osg.StateAttribute.ON)
stateset.setMode(GL_LIGHTING,osg.StateAttribute.OFF)
geom.setStateSet(stateset)
return geom
def createAxis(s, e, numReps, autoRotateMode, axisAlignment, str):
group = osg.Group()
dv = e-s
dv /= float(numReps-1)
pos = s
useAuto = True
if useAuto :
vertices = osg.Vec3Array()
for(int i=0i<numReps++i)
at = osg.AutoTransform()
at.setPosition(pos)
at.setAutoRotateMode(autoRotateMode)
at.addChild(createLabel(osg.Vec3(0.0,0.0,0.0),dv.length()*0.2,str, axisAlignment))
vertices.push_back(pos)
pos += dv
group.addChild(at)
colors = osg.Vec4Array()
colors.push_back(osg.Vec4(1.0,1.0,1.0,1.0))
geom = osg.Geometry()
geom.setVertexArray(vertices)
geom.setColorArray(colors, osg.Array.BIND_OVERALL)
geom.addPrimitiveSet(osg.DrawArrays(GL_LINE_STRIP,0,vertices.size()))
geode = osg.Geode()
geode.addDrawable(geom)
group.addChild(geode)
# set the colors as before, plus using the above
colors = osg.Vec4Array()
colors.push_back(osg.Vec4(1.0,1.0,0.0,1.0))
linesGeom.setColorArray(colors, osg.Array.BIND_OVERALL)
# set the normal in the same way color.
normals = osg.Vec3Array()
normals.push_back(osg.Vec3(0.0,-1.0,0.0))
linesGeom.setNormalArray(normals, osg.Array.BIND_OVERALL)
# This time we simply use primitive, and hardwire the number of coords to use
# since we know up front,
linesGeom.addPrimitiveSet(osg.DrawArrays(osg.PrimitiveSet.LINE_LOOP,0,numCoords))
# add the points geometry to the geode.
geode.addDrawable(linesGeom)
# now we'll stop creating separate normal and color arrays
# since we are using the same values all the time, we'll just
# share the same ColorArray and NormalArrays..
# set the colors as before, use a ref_ptr rather than just
# standard C pointer, as that in the case of it not being
# assigned it will still be cleaned up automatically.
def createScene():
# create the Geode (Geometry Node) to contain all our osg.Geometry objects.
geode = osg.Geode()
# following are separate blocks for creating POINTS, LINES, LINE_STRIP, LINE_LOOP, POLYGON, QUADS,
# QUAD_STRIP, TRIANGLES, TRIANGLE_STRIP and TRIANGLE_FAN primitives. An image of these primitives
# is provided in the distribution: OpenSceneGraph-Data/Images/primitives.gif.
# create POINTS
# create Geometry object to store all the vertices and points primitive.
pointsGeom = osg.Geometry()
# create a Vec3Array and add to it all my coordinates.
# Like all the *Array variants (see include/osg/Array) , Vec3Array is derived from both osg.Array
# and std.vector<>. osg.Array's are reference counted and hence sharable,
# which std.vector<> provides all the convenience, flexibility and robustness
# of the most popular of all STL containers.
vertices = osg.Vec3Array()
vertices.push_back(osg.Vec3(-1.02168, -2.15188e-09, 0.885735))
vertices.push_back(osg.Vec3(-0.976368, -2.15188e-09, 0.832179))
vertices.push_back(osg.Vec3(-0.873376, 9.18133e-09, 0.832179))
vertices.push_back(osg.Vec3(-0.836299, -2.15188e-09, 0.885735))
vertices.push_back(osg.Vec3(-0.790982, 9.18133e-09, 0.959889))
# pass the created vertex array to the points geometry object.
pointsGeom.setVertexArray(vertices)
# create the color of the geometry, one single for the whole geometry.
# for consistency of design even one single color must added as an element
# in a color array.
colors = osg.Vec4Array()
# add a white color, colors take the form r,g,b,a with 0.0 off, 1.0 full on.
colors.push_back(osg.Vec4(1.0,1.0,0.0,1.0))
# pass the color array to points geometry, note the binding to tell the geometry
# that only use one color for the whole object.
pointsGeom.setColorArray(colors, osg.Array.BIND_OVERALL)
# set the normal in the same way color.
normals = osg.Vec3Array()
normals.push_back(osg.Vec3(0.0,-1.0,0.0))
pointsGeom.setNormalArray(normals, osg.Array.BIND_OVERALL)
# create and add a DrawArray Primitive (see include/osg/Primitive). The first
# parameter passed to the DrawArrays constructor is the Primitive.Mode which
# in this case is POINTS (which has the same value GL_POINTS), the second
# parameter is the index position into the vertex array of the first point
# to draw, and the third parameter is the number of points to draw.
pointsGeom.addPrimitiveSet(osg.DrawArrays(osg.PrimitiveSet.POINTS,0,vertices.size()))
# add the points geometry to the geode.
geode.addDrawable(pointsGeom)
# create LINES
# create Geometry object to store all the vertices and lines primitive.
linesGeom = osg.Geometry()
# this time we'll preallocate the vertex array to the size we
# need and then simple set them as array elements, 8 points
# makes 4 line segments.
vertices = osg.Vec3Array(8)
(*vertices)[0].set(-1.13704, -2.15188e-09, 0.40373)
(*vertices)[1].set(-0.856897, -2.15188e-09, 0.531441)
(*vertices)[2].set(-0.889855, -2.15188e-09, 0.444927)
(*vertices)[3].set(-0.568518, -2.15188e-09, 0.40373)
(*vertices)[4].set(-1.00933, -2.15188e-09, 0.370773)
(*vertices)[5].set(-0.716827, -2.15188e-09, 0.292498)
(*vertices)[6].set(-1.07936, 9.18133e-09, 0.317217)
(*vertices)[7].set(-0.700348, 9.18133e-09, 0.362533)
# pass the created vertex array to the points geometry object.
linesGeom.setVertexArray(vertices)
# set the colors as before, plus using the above
colors = osg.Vec4Array()
colors.push_back(osg.Vec4(1.0,1.0,0.0,1.0))
linesGeom.setColorArray(colors, osg.Array.BIND_OVERALL)
# set the normal in the same way color.
normals = osg.Vec3Array()
normals.push_back(osg.Vec3(0.0,-1.0,0.0))
linesGeom.setNormalArray(normals, osg.Array.BIND_OVERALL)
# This time we simply use primitive, and hardwire the number of coords to use
# since we know up front,
linesGeom.addPrimitiveSet(osg.DrawArrays(osg.PrimitiveSet.LINES,0,8))
# add the points geometry to the geode.
geode.addDrawable(linesGeom)
# create LINE_STRIP
# create Geometry object to store all the vertices and lines primitive.
linesGeom = osg.Geometry()
# this time we'll preallocate the vertex array to the size
# and then use an iterator to fill in the values, a bit perverse
# but does demonstrate that we have just a standard std.vector underneath.
vertices = osg.Vec3Array(5)
vitr = vertices.begin()
(vitr++).set(-0.0741545, -2.15188e-09, 0.416089)
(vitr++).set(0.234823, -2.15188e-09, 0.259541)
(vitr++).set(0.164788, -2.15188e-09, 0.366653)
(vitr++).set(-0.0288379, -2.15188e-09, 0.333695)
(vitr++).set(-0.0453167, -2.15188e-09, 0.280139)
# pass the created vertex array to the points geometry object.
linesGeom.setVertexArray(vertices)
# set the colors as before, plus using the above
colors = osg.Vec4Array()
colors.push_back(osg.Vec4(1.0,1.0,0.0,1.0))
linesGeom.setColorArray(colors, osg.Array.BIND_OVERALL)
# set the normal in the same way color.
normals = osg.Vec3Array()
normals.push_back(osg.Vec3(0.0,-1.0,0.0))
linesGeom.setNormalArray(normals, osg.Array.BIND_OVERALL)
# This time we simply use primitive, and hardwire the number of coords to use
# since we know up front,
linesGeom.addPrimitiveSet(osg.DrawArrays(osg.PrimitiveSet.LINE_STRIP,0,5))
# add the points geometry to the geode.
geode.addDrawable(linesGeom)
# create LINE_LOOP
# create Geometry object to store all the vertices and lines primitive.
linesGeom = osg.Geometry()
# this time we'll a C arrays to initialize the vertices.
osg.Vec3 myCoords[] =
osg.Vec3(0.741546, -2.15188e-09, 0.453167),
osg.Vec3(0.840418, -2.15188e-09, 0.304858),
osg.Vec3(1.12468, -2.15188e-09, 0.300738),
osg.Vec3(1.03816, 9.18133e-09, 0.453167),
osg.Vec3(0.968129, -2.15188e-09, 0.337815),
osg.Vec3(0.869256, -2.15188e-09, 0.531441)
min = -1.0
max = 1.0
j = 0
i = 0
for(i=0i<noStars++i,j+=2)
(*vertices)[j].set(random(min,max),random(min,max),random(min,max))
(*vertices)[j+1] = (*vertices)[j]+osg.Vec3(0.0,0.0,0.001)
# set up colours
colours = osg.Vec4Array(1)
geometry.setColorArray(colours, osg.Array.BIND_OVERALL)
(*colours)[0].set(1.0,1.0,1.0,1.0)
# set up the primitive set to draw lines
geometry.addPrimitiveSet(osg.DrawArrays(GL_LINES,0,noStars*2))
# set up the points for the stars.
points = osg.DrawElementsUShort(GL_POINTS,noStars)
geometry.addPrimitiveSet(points)
for(i=0i<noStars++i)
(*points)[i] = i*2
geometry.setUseDisplayList(False)
geometry.setDrawCallback(DrawCallback)()
geode = osg.Geode()
geode.addDrawable(geometry)
geode.getOrCreateStateSet().setMode(GL_LIGHTING,osg.StateAttribute.OFF)
group = osg.Group()
(*normals)[6] = osg.Vec3( 0.0, 1.0, 0.0)
(*normals)[7] = osg.Vec3( 0.0, 1.0, 0.0)
(*normals)[8] = osg.Vec3(-1.0, -0.0, 0.0)
(*normals)[9] = osg.Vec3(-1.0, -0.0, 0.0)
(*normals)[10] = osg.Vec3( 0.0, -0.928477, 0.371391)
(*normals)[11] = osg.Vec3( 0.0, 0.928477, 0.371391)
(*normals)[12] = osg.Vec3( 0.707107, 0.0, 0.707107)
(*normals)[13] = osg.Vec3( 0.707107, 0.0, 0.707107)
(*normals)[14] = osg.Vec3(-0.707107, 0.0, 0.707107)
(*normals)[15] = osg.Vec3(-0.707107, 0.0, 0.707107)
# coordIndices
coordIndices = osg.UByteArray(48,indices)
# share the primitive set.
primitives = osg.DrawArrays(osg.PrimitiveSet.TRIANGLES,0,48)
for (int q = 0 q < HOUSES_SIZE q++)
xPos = ((static_cast<double> (rand()) /
static_cast<double> (RAND_MAX))
* 2.0 * XDim) - XDim
yPos = ((static_cast<double> (rand()) /
static_cast<double> (RAND_MAX))
* 2 * ZDim) - ZDim
scale = 10.0
offset = osg.Vec3(xPos,yPos,0.0)
# coords
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, osg.Array.BIND_OVERALL)
polyGeom.addPrimitiveSet(osg.DrawArrays(osg.PrimitiveSet.QUAD_STRIP,0,vertices.size()))
# 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)
polyGeom.setUpdateCallback(MyGeometryCallback(origin,xAxis,yAxis,zAxis,1.0,1.0/width,0.2))
geode = osg.Geode()
geode.addDrawable(polyGeom)
parent.addChild(geode)
stateset.setMode(GL_DEPTH_TEST,osg.StateAttribute.OFF)
name = "subOption"
name += " "
name += str(opts[i])
geode.setName(name)
vertices = osg.Vec3Array(4) # 1 quad
colors = osg.Vec4Array()
colors = osg.Vec4Array()
colors.push_back(osg.Vec4(0.8-0.1*i,0.1*i,0.2*i, 1.0))
quad.setColorArray(colors, osg.Array.BIND_OVERALL)
(*vertices)[0]=position
(*vertices)[1]=position+dx
(*vertices)[2]=position+dx+dy
(*vertices)[3]=position+dy
quad.setVertexArray(vertices)
quad.addPrimitiveSet(osg.DrawArrays(osg.PrimitiveSet.QUADS,0,4))
geode.addDrawable(quad)
hudCamera.addChild(geode)
position += delta
# this displays what has been selected
geode = osg.Geode()
stateset = geode.getOrCreateStateSet()
stateset.setMode(GL_LIGHTING,osg.StateAttribute.OFF)
stateset.setMode(GL_DEPTH_TEST,osg.StateAttribute.OFF)
geode.setName("The text label")
geode.addDrawable( updateText )
hudCamera.addChild(geode)
depth = bb.zMin()-0.1
vertices.push_back(osg.Vec3(bb.xMin(),bb.yMax(),depth))
vertices.push_back(osg.Vec3(bb.xMin(),bb.yMin(),depth))
vertices.push_back(osg.Vec3(bb.xMax(),bb.yMin(),depth))
vertices.push_back(osg.Vec3(bb.xMax(),bb.yMax(),depth))
geom.setVertexArray(vertices)
normals = osg.Vec3Array()
normals.push_back(osg.Vec3(0.0,0.0,1.0))
geom.setNormalArray(normals, osg.Array.BIND_OVERALL)
colors = osg.Vec4Array()
colors.push_back(osg.Vec4(1.0,1.0,0.8,0.2))
geom.setColorArray(colors, osg.Array.BIND_OVERALL)
geom.addPrimitiveSet(osg.DrawArrays(GL_QUADS,0,4))
stateset = geom.getOrCreateStateSet()
stateset.setMode(GL_BLEND,osg.StateAttribute.ON)
#stateset.setAttribute(osg.PolygonOffset(1.0,1.0),osg.StateAttribute.ON)
stateset.setRenderingHint(osg.StateSet.TRANSPARENT_BIN)
geode.addDrawable(geom)
camera.addChild(geode)
return camera
class SnapImage (osg.Camera.DrawCallback) :
SnapImage( str filename):
_filename(filename),
vertices.push_back(nose)
geom.setVertexArray(vertices)
normals = osg.Vec3Array()
normals.push_back(normal)
geom.setNormalArray(normals, osg.Array.BIND_OVERALL)
colors = osg.Vec4Array()
colors.push_back(color)
geom.setColorArray(colors, osg.Array.BIND_OVERALL)
geom.addPrimitiveSet(osg.DrawArrays(GL_POLYGON,0,vertices.getNumElements()))
tessellator = osgUtil.Tessellator()
tessellator.retessellatePolygons(*geom)
return geom
osg. Node* createTextBelow( osg.BoundingBox bb, str label, str)
geode = osg.Geode()
font = str("fonts/arial.ttf")
text = osgText.Text()
text.setFont(font)
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)
animationPath.insert(3.0,osg.AnimationPath.ControlPoint(bb.corner(3)))
animationPath.insert(4.0,osg.AnimationPath.ControlPoint(bb.corner(4)))
animationPath.insert(5.0,osg.AnimationPath.ControlPoint(bb.corner(5)))
animationPath.insert(6.0,osg.AnimationPath.ControlPoint(bb.corner(6)))
animationPath.insert(7.0,osg.AnimationPath.ControlPoint(bb.corner(7)))
animationPath.insert(8.0,osg.AnimationPath.ControlPoint(bb.corner(0)))
animationPath.setLoopMode(osg.AnimationPath.SWING)
mt.setUpdateCallback(osg.AnimationPathCallback(animationPath))
# create marker for point light.
marker = osg.Geometry()
vertices = osg.Vec3Array()
vertices.push_back(osg.Vec3(0.0,0.0,0.0))
marker.setVertexArray(vertices)
marker.addPrimitiveSet(osg.DrawArrays(GL_POINTS,0,1))
stateset = osg.StateSet()
point = osg.Point()
point.setSize(4.0)
stateset.setAttribute(point)
marker.setStateSet(stateset)
markerGeode = osg.Geode()
markerGeode.addDrawable(marker)
mt.addChild(lightS2)
mt.addChild(markerGeode)
lightGroup.addChild(mt)
c[0] = color
t[0].set(0.0,0.0)
t[1].set(1.0,0.0)
t[2].set(1.0,1.0)
t[3].set(0.0,1.0)
geom = osg.Geometry()
geom.setVertexArray( v )
geom.setTexCoordArray( 0, t )
geom.setColorArray( c, osg.Array.BIND_OVERALL )
geom.addPrimitiveSet( osg.DrawArrays(osg.PrimitiveSet.QUADS,0,4) )
return geom
osg.Geometry* ForestTechniqueManager.createOrthogonalQuads( osg.Vec3 pos, float w, float h, osg.Vec4ub color )
# set up the coords
v = *(osg.Vec3Array(8))
t = *(osg.Vec2Array(8))
c = *(osg.Vec4ubArray(1))
rotation = random(0.0,osg.PI/2.0)
sw = sinf(rotation)*w*0.5
cw = cosf(rotation)*w*0.5
v[0].set(pos.x()-sw,pos.y()-cw,pos.z()+0.0)
v[1].set(pos.x()+sw,pos.y()+cw,pos.z()+0.0)
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))
quad_geom.setVertexArray(quad_coords)
quad_geom.setTexCoordArray(0, quad_tcoords)
quad_geom.addPrimitiveSet(quad_da)
quad_geom.setColorArray(quad_colors, osg.Array.BIND_OVERALL)
stateset = quad_geom.getOrCreateStateSet()
stateset.setMode(GL_LIGHTING,osg.StateAttribute.OFF)
stateset.addUniform(osg.Uniform("width", (int)tex_width))
# Attach shader, glFragData is used to create data for multiple render targets
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))
axes.setVertexArray(coords)
axes.getOrCreateStateSet().setMode(GL_LIGHTING,osg.StateAttribute.OFF)
axes.addPrimitiveSet(osg.DrawArrays(osg.PrimitiveSet.LINES,0,6))
c = osg.Vec4Array()
geom.setColorArray( c )
geom.setColorBinding( deprecated_osg.Geometry.BIND_OVERALL )
c.push_back( osg.Vec4( 0., 1., 1., 1. ) )
n = osg.Vec3Array()
geom.setNormalArray( n )
geom.setNormalBinding( deprecated_osg.Geometry.BIND_PER_PRIMITIVE )
n.push_back( osg.Vec3( -1., 0., 0. ) )
n.push_back( osg.Vec3( 1., 0., 0. ) )
n.push_back( osg.Vec3( 0., 0., -1. ) )
n.push_back( osg.Vec3( 0., 0., 1. ) )
n.push_back( osg.Vec3( 0., 1., 0. ) )
geom.addPrimitiveSet( osg.DrawArrays( GL_QUADS, 0, 20 ) )
box.addDrawable( geom )
return box
# Make a Geometry that renders slow intentionally.
# To make sure it renders slow, we do the following:
# * Disable display lists
# * Force glBegin/glEnd slow path
# * Lots of vertices and color data per vertex
# * No vertex sharing
# * Draw the triangles as wireframe
def createRandomTriangles(num):
tris = osg.Geode()
alpha = color.w() * 0.5
black = osg.Vec3(0, 0, 0)
clr.push_back(osg.Vec4(black, 0))
clr.push_back(osg.Vec4(black, 0))
clr.push_back(osg.Vec4(black, alpha))
clr.push_back(osg.Vec4(black, alpha))
clr.push_back(osg.Vec4(black, alpha))
clr.push_back(osg.Vec4(black, alpha))
clr.push_back(osg.Vec4(black, 0))
clr.push_back(osg.Vec4(black, 0))
geo.setColorArray(clr, osg.Array.BIND_PER_VERTEX)
geo.addPrimitiveSet(osg.DrawArrays(GL_QUADS, 0, 12 if (shadow) else 4))
return geo.release()
# Translated from file 'Frame.h'
# -*-c++-*-
#*
#* OpenSceneGraph example, osgfxbrowser.
#*
#* Permission is hereby granted, free of charge, to any person obtaining a copy
#* of this software and associated documentation files (the "Software"), to deal
#* in the Software without restriction, including without limitation the rights
#* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
#* copies of the Software, and to permit persons to whom the Software is
