def compile(self, mode=None):
"""Build the cached display list for this background object
Note: we store 2 display lists in the cache, but only return
one from the compile method. The second list is the final
rendering list, while the first is just the low-level rendering
code.
"""
colorSet = self.colorSet()
if len(colorSet):
vertices, colors = self.buildSphere(colorSet)
glMultMatrixf(mode.matrix)
first = displaylist.DisplayList()
first.start()
try:
glVertexPointerf(vertices)
glColorPointerf(colors)
glEnableClientState(GL_VERTEX_ARRAY)
glEnableClientState(GL_COLOR_ARRAY)
glDrawArrays(GL_TRIANGLE_STRIP, 0, len(vertices))
finally:
first.end()
second = displaylist.DisplayList()
second.start()
try:
glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE)
glDisable(
GL_DEPTH_TEST
) # we don't want to do anything with the depth buffer...
glDisable(GL_LIGHTING)
glEnable(GL_COLOR_MATERIAL)
glDisable(GL_CULL_FACE)
for index in range(int(SEGMENTS)):
first()
glRotated(360.0 / SEGMENTS, 0, 1, 0)
glDisableClientState(GL_VERTEX_ARRAY)
glDisableClientState(GL_COLOR_ARRAY)
# now, completely wipe out the depth buffer, so this appears as a "background"... no idea how expensive this is
glClear(GL_DEPTH_BUFFER_BIT)
glEnable(GL_DEPTH_TEST)
glEnable(GL_LIGHTING)
glColor(0.0, 0.0, 0.0)
glDisable(GL_COLOR_MATERIAL)
glEnable(GL_CULL_FACE)
glFrontFace(GL_CCW)
holder = mode.cache.holder(self, (first, second))
for field in protofunctions.getFields(self):
# change to any field requires a recompile
if field.name != 'bound':
holder.depend(self, field)
return second
finally:
second.end()
holder = mode.cache.holder(self, (None, ()))
return None
def compile(self, mode=None):
"""Compile material information into readily-rendered format"""
holder = mode.cache.holder(self, None)
for field in protofunctions.getFields(self):
# change to any field requires a recompile
holder.depend(self, field)
# def dl():
dl = displaylist.DisplayList()
dl.start()
try:
alpha = 1.0 - self.transparency
renderingData = zeros((4, 4), 'f')
renderingData[:, 3] = alpha
diffuseColor = self.diffuseColor.astype('f')
renderingData[0, :3] = diffuseColor
renderingData[1, :3] = self.emissiveColor.astype('f')
renderingData[2, :3] = self.specularColor.astype('f')
renderingData[3, :3] = (diffuseColor *
self.ambientIntensity).astype('f')
map(glMaterialfv, self.faces, self.datamap, renderingData)
glMaterialf(self.faces[0], GL_SHININESS, self.shininess * 128)
finally:
dl.end()
holder.data = dl
return holder.data
def compile(self, mode=None):
"""Compile the geometry as a display-list"""
dl = displaylist.DisplayList()
dl.start()
try:
self.do()
holder = mode.cache.holder(self, dl)
return dl
finally:
dl.end()
def compile(self, mode=None):
"""Compile the VPCurve into a display-list
"""
# This code is not OpenGL 3.1 compatible
if self.pos.any():
dl = displaylist.DisplayList()
#XXX should do sanity checks here...
dl.start()
try:
pos = self.pos
color = self.color
colorLen = len(color)
killThickness = 0
if self.radius:
glLineWidth(self.radius * 2)
killThickness = 1
try:
glEnable(GL_COLOR_MATERIAL)
try:
glBegin(GL_LINE_STRIP)
try:
lastColor = None
for index in range(len(pos)):
point = pos[index]
if index < colorLen:
col = tuple(color[index])
if col != lastColor:
glColor3dv(col)
lastColor = col
glVertex3dv(point)
finally:
glEnd()
finally:
glDisable(GL_COLOR_MATERIAL)
finally:
if killThickness:
glLineWidth(1)
finally:
dl.end()
holder = mode.cache.holder(self, dl)
for field in protofunctions.getFields(self):
# change to any field requires a recompile
holder.depend(self, field)
return dl
return None
def compile(self, mode):
"""Compile this geometry node to display-list
Initial code is taken from the PyOpenGL-Demo gears.py
which was in the Public Domain and converted multiple
times since then.
"""
dl = displaylist.DisplayList()
dl.start()
try:
self.gear(
self.inner_radius,
self.outer_radius,
self.width,
self.teeth,
self.tooth_depth,
)
holder = mode.cache.holder(self, dl)
for name in ('inner_radius', 'outer_radius', 'width', 'teeth',
'tooth_depth'):
holder.depend(self, name)
return dl
finally:
dl.end()
def compile(self, mode=None):
"""Compile the IndexedLineSet into a display-list
"""
if self.coord and len(self.coord.point) and len(self.coordIndex):
dl = displaylist.DisplayList()
holder = mode.cache.holder(self, dl)
for field in protofunctions.getFields(self):
# change to any field requires a recompile
holder.depend(self, field)
for (n, attr) in [
(self.coord, 'point'),
(self.color, 'color'),
]:
if n:
holder.depend(n, protofunctions.getField(n, attr))
points = self.coord.point
indices = expandIndices(self.coordIndex)
#XXX should do sanity checks here...
if self.color and len(self.color.color):
colors = self.color.color
if self.colorPerVertex:
if len(self.colorIndex):
colorIndices = expandIndices(self.colorIndex)
else:
colorIndices = indices
else:
if len(self.colorIndex):
# each item represents a single polyline colour
colorIndices = self.colorIndex
else:
# each item in color used in turn by each polyline
colorIndices = range(len(indices))
# compile the color-friendly ILS
dl.start()
try:
glEnable(GL_COLOR_MATERIAL)
for index in range(len(indices)):
polyline = indices[index]
color = colorIndices[index]
try:
color = int(color)
except (TypeError, ValueError), err:
glBegin(GL_LINE_STRIP)
try:
for i, c in map(None, polyline, color):
if c is not None:
# numpy treats None as retrieve all??? why?
currentColor = colors[c]
if currentColor is not None:
glColor3d(*currentColor)
glVertex3f(*points[i])
finally:
glEnd()
else:
glColor3d(*colors[color])
glBegin(GL_LINE_STRIP)
try:
for i in polyline:
glVertex3f(*points[i])
finally:
glEnd()
glDisable(GL_COLOR_MATERIAL)
finally:
dl.end()
def compile(
self,
visible=1,
lit=1,
textured=1,
transparent=0,
mode=None,
):
"""Compile to an opaque textured display-list"""
dl = displaylist.DisplayList()
dl.start()
try:
if (not self.target.normal) or (
self.target.normal and not len(self.target.normal.vector)):
# need to generate per-face or per-vertex-use vectors,
# require tessellation!
vertices = self.tessellate()
if not vertices:
return None
if self.target.normalPerVertex:
normalArray = build_normalPerVertex(
vertices, self.target.creaseAngle)
normalStep = 1
else:
normalArray = triangleutilities.normalPerFace(vertexArray)
normalArray = repeat(normalArray, [3] * len(normalArray),
0)
normalStep = 3
glBegin(GL_TRIANGLES)
if self.target.DEBUG_DRAW_NORMALS:
normalValues = []
try:
normalIndex = -1
for vIndex in xrange(len(vertices)):
vertex = vertices[vIndex]
if vIndex % normalStep == 0:
normalIndex += 1
glNormal3dv(normalArray[normalIndex])
if vertex.color is not None:
glColor3dv(vertex.color)
if vertex.textureCoordinate is not None:
glTexCoord2dv(vertex.textureCoordinate)
glVertex3dv(vertex.point)
if self.target.DEBUG_DRAW_NORMALS:
normalValues.append(
(vertex.point,
vertex.point + normalArray[normalIndex]))
finally:
glEnd()
if self.target.DEBUG_DRAW_NORMALS:
glBegin(GL_LINES)
try:
for (v, n) in normalValues:
glColor3f(1, 0, 0)
glVertex3dv(v)
glColor3f(0, 1, 0)
glVertex3dv(n)
finally:
glEnd()
else:
# already has normals, can render without tessellation
for polygon in self.polygons():
if len(polygon) == 3:
glBegin(GL_TRIANGLES)
elif len(polygon) == 4:
glBegin(GL_QUADS)
elif len(polygon) < 3:
continue
else:
glBegin(GL_POLYGON)
try:
for vertex in polygon:
if vertex.normal is not None:
glNormal3dv(vertex.normal)
if vertex.color is not None:
glColor3dv(vertex.color)
if vertex.textureCoordinate is not None:
glTexCoord2dv(vertex.textureCoordinate)
glVertex3dv(vertex.point)
finally:
glEnd()
return DisplayListRenderer(dl)
finally:
dl.end()
