def Display():
global angle
gl.glMatrixMode(gl.GL_MODELVIEW)
#Borramos la escena
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
#Dibuja taza
gl.glPushMatrix()
gl.glColor3f(1.0, 1.0, 1.0)
gl.glTranslatef(0.0, 0.0, -1.0)
gl.glRotatef(angle, 0.0, 1.0, 0.0)
glut.glutSolidTeapot(0.3)
gl.glPopMatrix()
#Dibuja Cubo
gl.glPushMatrix()
gl.glColor3f(0.0, 1.0, 0.0)
gl.glTranslatef(0.0, 0.0, -4.0)
gl.glRotatef(angle, 0.0, 1.0, 0.0)
#gl.glRotatef(angle,0.0,1.0,0.0)
gl.glTranslatef(1.0, 0.0, 0.0)
glut.glutSolidCube(0.1)
gl.glPopMatrix()
glut.glutSwapBuffers()
gl.glFlush()
def on_display( ):
global shader
gl.glClearColor(1,1,1,1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnable(gl.GL_BLEND)
radius = 255.0
theta, dtheta = 0, 5.5/180.0*math.pi
thickness = 1.0
support = .75
for i in range(500):
xc, yc = 256, 256+32
r = 10.1-i*0.02
thickness = 1.0 #0.1 + (1.0-i/500.0)*4
x0 = xc + np.cos(theta)*radius*.925
y0 = yc + np.sin(theta)*radius*.925
x1 = xc + np.cos(theta)*radius*1.00
y1 = yc + np.sin(theta)*radius*1.00
line( (x0,y0), (x1,y1), thickness, support)
radius -= 0.45
theta += dtheta
for i in range(0,49):
thickness = (i+1)/10.0
x = 20+i*10 + .315
y = 16+.315
line( (x,y+6), (x,y-6), thickness, support )
glut.glutSwapBuffers()
def display():
global projection, view
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glDisable( gl.GL_BLEND )
gl.glEnable( gl.GL_DEPTH_TEST )
gl.glEnable( gl.GL_POLYGON_OFFSET_FILL )
cubes.uniforms['rotate'][:,1] += 0.05
cubes.uniforms['rotate'][:,2] += 0.05
cubes.upload_uniforms()
cubes.draw(gl.GL_TRIANGLES,
{'u_projection' : projection,
'u_view' : view,
'u_color' : (1.0,1.0,1.0,1.0) } )
gl.glDisable( gl.GL_POLYGON_OFFSET_FILL )
gl.glEnable( gl.GL_BLEND );
gl.glDepthMask( gl.GL_FALSE );
outlines.uniforms['rotate'][:,1] += 0.05
outlines.uniforms['rotate'][:,2] += 0.05
outlines.upload_uniforms()
outlines.draw(gl.GL_LINES,
{'u_projection' : projection,
'u_view' : view,
'u_color' : (0.0,0.0,0.0,0.5) } )
gl.glDepthMask( gl.GL_TRUE )
glut.glutSwapBuffers()
def figure():
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
GL.glLoadIdentity()
GL.glPushMatrix()
GL.glTranslatef(dX, dY, dZ)
GL.glRotatef(a, 0.0, 1.0, 0.0)
GL.glRotatef(b, 0.0, 0.0, 1.0)
GL.glBindTexture(GL.GL_TEXTURE_2D, textura[0])
GL.glBegin(GL.GL_QUADS)
GL.glTexCoord2f(0.0, 0.0)
GL.glVertex3f(-1.0, -1.0, 1.0)
GL.glTexCoord2f(1 / 3, 0.0)
GL.glVertex3f(1.0, -1.0, 1.0)
GL.glTexCoord2f(1 / 3, 1 / 2)
GL.glVertex3f(1.0, 1.0, 1.0)
GL.glTexCoord2f(0.0, 1 / 2)
GL.glVertex3f(-1.0, 1.0, 1.0)
GL.glTexCoord2f(2 / 3, 1 / 2)
GL.glVertex3f(-1.0, -1.0, -1.0)
GL.glTexCoord2f(1.0, 1 / 2)
GL.glVertex3f(-1.0, 1.0, -1.0)
GL.glTexCoord2f(1.0, 1.0)
GL.glVertex3f(1.0, 1.0, -1.0)
GL.glTexCoord2f(2 / 3, 1.0)
GL.glVertex3f(1.0, -1.0, -1.0)
GL.glTexCoord2f(1 / 3, 1 / 2)
GL.glVertex3f(-1.0, 1.0, -1.0)
GL.glTexCoord2f(2 / 3, 1 / 2)
GL.glVertex3f(-1.0, 1.0, 1.0)
GL.glTexCoord2f(2 / 3, 1)
GL.glVertex3f(1.0, 1.0, 1.0)
GL.glTexCoord2f(1 / 3, 1)
GL.glVertex3f(1.0, 1.0, -1.0)
GL.glTexCoord2f(1 / 3, 0.0)
GL.glVertex3f(-1.0, -1.0, -1.0)
GL.glTexCoord2f(2 / 3, 0.0)
GL.glVertex3f(1.0, -1.0, -1.0)
GL.glTexCoord2f(2 / 3, 1 / 2)
GL.glVertex3f(1.0, -1.0, 1.0)
GL.glTexCoord2f(1 / 3, 1 / 2)
GL.glVertex3f(-1.0, -1.0, 1.0)
GL.glTexCoord2f(0.0, 1 / 2)
GL.glVertex3f(1.0, -1.0, -1.0)
GL.glTexCoord2f(1 / 3, 1 / 2)
GL.glVertex3f(1.0, 1.0, -1.0)
GL.glTexCoord2f(1 / 3, 1.0)
GL.glVertex3f(1.0, 1.0, 1.0)
GL.glTexCoord2f(0.0, 1.0)
GL.glVertex3f(1.0, -1.0, 1.0)
GL.glTexCoord2f(2 / 3, 0.0)
GL.glVertex3f(-1.0, -1.0, -1.0)
GL.glTexCoord2f(1.0, 0.0)
GL.glVertex3f(-1.0, -1.0, 1.0)
GL.glTexCoord2f(1.0, 1 / 2)
GL.glVertex3f(-1.0, 1.0, 1.0)
GL.glTexCoord2f(2 / 3, 1 / 2)
GL.glVertex3f(-1.0, 1.0, -1.0)
GL.glEnd()
GL.glPopMatrix()
GLUT.glutSwapBuffers()
def draw_func():
#Clear the current buffer
GL.glFlush()
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
# Render stuff
f(self)
# Load the identity matrix
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glLoadIdentity()
#Transform the view in the appropriate way
if self._dim == 3:
GL.glTranslatef(0.,0.,-2)
GL.glTranslatef(self._translate[0],
self._translate[1],
self._translate[2])
GL.glRotatef(self._rotate[0], 1, 0, 0)
GL.glRotatef(self._rotate[1], 0, 1, 0)
else:
GL.glTranslatef(0.,0.,0.)
GL.glTranslatef(self._translate[0], self._translate[1],0.0)
GL.glRotatef(self._rotate[0], 0, 0, 1)
GL.glRotatef(self._rotate[1], 0, 0, 1)
# Scale
GL.glScale(self._scale,self._scale,self._scale)
#More niceness
GL.glShadeModel(GL.GL_SMOOTH)
# Swap out the new rendering.
GLUT.glutSwapBuffers()
def display(self):
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glLoadIdentity()
# do zoom
glu.gluLookAt(0.0, 0.0, self.zoom, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0)
# do rotation
for x_rot, y_rot in reversed(self.rotations):
gl.glRotatef(math.sqrt(x_rot**2 + y_rot**2), y_rot, x_rot, 0)
#gl.glRotate(x_rot, 0, 1, 0)
#gl.glRotate(y_rot, 1, 0, 0)
"""
one, two, three, four = (1, 1, 0), (1, -1, 0), (-1, -1, 0), (-1, 1, 0)
draw_element(chemistry.elements[0], one)
draw_single_bond(one, two)
draw_element(chemistry.elements[0], two)
draw_double_bond(two, three)
draw_element(chemistry.elements[0], three)
draw_triple_bond(three, four)
draw_element(chemistry.elements[0], four)
draw_quadruple_bond(four, one)
"""
#self.draw_atoms(self.molecule)
gl.glCallList(self.displist)
#gl.glFlush()
glut.glutSwapBuffers()
def display():
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
program.draw(gl.GL_TRIANGLES, indices)
glut.glutSwapBuffers()
# Take screenshot in every display()
screenshot()
def display(self):
with self.mainfbo:
self.clear()
self.render()
gl.glMemoryBarrier(gl.GL_FRAMEBUFFER_BARRIER_BIT)
if self.emulate:
gl.glClearColor(0, 0, 0, 0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glViewport(0, 0, int(self.screenWidth / 2), self.screenHeight)
self.tree.render(0)
gl.glViewport(int(self.screenWidth / 2), 0,
int(self.screenWidth / 2), self.screenHeight)
self.texquad.render()
else:
gl.glClearColor(0, 0, 0, 0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
if self.preview:
self.texquad.render()
else:
self.signalgenerator.render()
glut.glutSwapBuffers()
glut.glutPostRedisplay()
def render(drawings_list: List[Drawing]) -> None:
"""
Draw all sprites
:param drawings_list: List of sprites to draw
:return:
"""
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
extended_drawings_list = []
drawings_queue = Queue()
for drawing in drawings_list:
extended_drawings_list.append(drawing)
for child in drawing.get_child_sprites():
drawings_queue.put(child)
while drawings_queue.qsize() > 0:
drawing = drawings_queue.get()
extended_drawings_list.append(drawing)
for child in drawing.get_child_sprites():
drawings_queue.put(child)
sorted_drawings_list = sorted(extended_drawings_list,
key=lambda x: x.position[2])
for drawing in sorted_drawings_list:
drawing.render()
gl.glFlush()
glut.glutSwapBuffers()
def render(self):
"""The display callback function."""
self.frame_count += 1
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
self.do_render()
GLUT.glutSwapBuffers()
def display():
global args, mainfbo, texquad, signalgenerator
with mainfbo:
clear()
t = reltime()
effect.render(t)
if args.emulate:
gl.glClearColor(0, 0, 0, 0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glViewport(0, 0, int(screenWidth / 2), screenHeight)
tree.render(reltime())
gl.glViewport(int(screenWidth / 2), 0, int(screenWidth / 2),
screenHeight)
texquad.render()
else:
gl.glClearColor(0, 0, 0, 0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
if args.preview:
texquad.render()
else:
signalgenerator.render()
glut.glutSwapBuffers()
glut.glutPostRedisplay()
def Display (): global angle gl.glMatrixMode(gl.GL_MODELVIEW) #Borramos la escena gl.glClear (gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) #Dibuja taza gl.glPushMatrix() gl.glColor3f (1.0, 1.0, 1.0) gl.glTranslatef(0.0,0.0,-1.0) gl.glRotatef(angle,0.0,1.0,0.0) glut.glutSolidTeapot(0.3) gl.glPopMatrix() #Dibuja Cubo gl.glPushMatrix() gl.glColor3f (0.0, 1.0, 0.0) gl.glTranslatef(0.0,0.0,-4.0) gl.glRotatef(angle,0.0,1.0,0.0) #gl.glRotatef(angle,0.0,1.0,0.0) gl.glTranslatef(1.0,0.0,0.0) glut.glutSolidCube(0.1) gl.glPopMatrix() glut.glutSwapBuffers() gl.glFlush()
def on_display( ):
gl.glClearColor(1,1,1,1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnable(gl.GL_BLEND)
global t, t0, frames
t = glut.glutGet( glut.GLUT_ELAPSED_TIME )
frames = frames + 1
if t-t0 > 2500:
print "FPS : %.2f (%d frames in %.2f second)" % (frames*1000.0/(t-t0), frames, (t-t0)/1000.0)
t0, frames = t,0
shader.bind()
shader.uniformi( 'texture', 0)
shader.uniformf( 'size', w,h)
shader.uniformf( 'major_grid_width', major_grid_width )
shader.uniformf( 'minor_grid_width', minor_grid_width )
shader.uniformf( 'major_grid_color', *major_grid_color )
shader.uniformf( 'minor_grid_color', *minor_grid_color )
shader.uniformf( 'major_tick_size', *major_tick_size )
shader.uniformf( 'minor_tick_size', *minor_tick_size )
shader.uniformf( 'major_tick_width', major_tick_width )
shader.uniformf( 'minor_tick_width', minor_tick_width )
shader.uniformf( 'major_tick_color', *major_tick_color )
shader.uniformf( 'minor_tick_color', *minor_tick_color )
axis.draw( gl.GL_TRIANGLES )
shader.unbind()
glut.glutSwapBuffers()
def display(): gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glClearColor(1,0,1,0) gl.glBegin(gl.GL_QUADS) gl.glColor3f(1,0,0); gl.glVertex2f( 0.9,-0.9) gl.glColor3f(1,1,0); gl.glVertex2f(-0.9,-0.9) gl.glColor3f(1,1,1); gl.glVertex2f(-0.9, 0.9) gl.glColor3f(1,0,0); gl.glVertex2f( 0.9, 0.9) gl.glEnd() gl.glBegin(gl.GL_TRIANGLES) gl.glColor3f(1,0,0,1) gl.glVertex2f(-0.5,-0.5) gl.glColor3f(1,0,0,1) gl.glVertex2f(0.5,-0.5) gl.glColor3f(1,0,1,1) gl.glVertex2f(0.0,0.5) gl.glEnd() glut.glutSwapBuffers()
def display():
CAMERA.render()
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
nonlocal scale
scale_location = gl.glGetUniformLocation(program, "gScale")
assert scale_location != 0xffffffff
world_location = gl.glGetUniformLocation(program, "gWorld")
assert world_location != 0xffffffff
scale += 0.01
pipeline = Pipeline(
rotation=[0.0, 30 * scale, 0.0],
# scaling=[math.sin(scale)] * 3,
translation=[0, 0, 6],
projection=ProjParams(WINDOW_WIDTH, WINDOW_HEIGHT, 1.0, 100.0,
60.0))
pipeline.set_camera(CAMERA)
gl.glUniformMatrix4fv(world_location, 1, gl.GL_TRUE,
pipeline.get_wvp())
gl.glDrawElements(gl.GL_TRIANGLES, 18, gl.GL_UNSIGNED_INT,
ctypes.c_void_p(0))
glut.glutSwapBuffers()
def DrawGLScene():
global xrot, yrot, zrot, scale, xdist, ydist, zdist, light
# Clear The Screen And The Depth Buffer
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
# Reset The View
GL.glLoadIdentity()
# Move Into The Screen
GL.glTranslatef(xdist, ydist, zdist)
# Rotate The Cube
GL.glRotatef(xrot, 1.0, 0.0, 0.0)
GL.glRotatef(yrot, 0.0, 1.0, 0.0)
GL.glRotatef(zrot, 0.0, 0.0, 1.0)
GL.glScalef(scale, scale, scale)
if light:
GL.glEnable(GL.GL_LIGHTING)
else:
GL.glDisable(GL.GL_LIGHTING)
if _DrawCurrentSceneFunc:
_DrawCurrentSceneFunc()
# Since this is double buffered, swap the buffers to display what just got
# drawn.
GLUT.glutSwapBuffers()
def save(display_func, filename="screenshot.png"):
"""
"""
try:
import OpenGL.GL.EXT.framebuffer_object as fbo
except ImportError:
print 'You do not have the framebuffer extension on your video card'
print 'Cannot save figure'
return
x, y, w, h = gl.glGetIntegerv(gl.GL_VIEWPORT)
# Setup framebuffer
framebuffer = fbo.glGenFramebuffersEXT(1)
fbo.glBindFramebufferEXT(fbo.GL_FRAMEBUFFER_EXT, framebuffer)
# Setup depthbuffer
depthbuffer = fbo.glGenRenderbuffersEXT(1)
fbo.glBindRenderbufferEXT(fbo.GL_RENDERBUFFER_EXT, depthbuffer)
fbo.glRenderbufferStorageEXT(fbo.GL_RENDERBUFFER_EXT,
gl.GL_DEPTH_COMPONENT, w, h)
# Create texture to render to
data = np.zeros((w, h, 4), dtype=np.ubyte)
texture = gl.glGenTextures(1)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_LINEAR)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER,
gl.GL_LINEAR)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, w, h, 0, gl.GL_RGBA,
gl.GL_UNSIGNED_BYTE, data)
fbo.glFramebufferTexture2DEXT(gl.GL_FRAMEBUFFER_EXT,
gl.GL_COLOR_ATTACHMENT0_EXT,
gl.GL_TEXTURE_2D, texture, 0)
fbo.glFramebufferRenderbufferEXT(gl.GL_FRAMEBUFFER_EXT,
gl.GL_DEPTH_ATTACHMENT_EXT,
gl.GL_RENDERBUFFER_EXT, depthbuffer)
status = fbo.glCheckFramebufferStatusEXT(fbo.GL_FRAMEBUFFER_EXT)
if status != fbo.GL_FRAMEBUFFER_COMPLETE_EXT:
raise (RuntimeError, 'Error in framebuffer activation')
display_func()
glut.glutSwapBuffers()
data = gl.glReadPixels(x, y, w, h, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE)
from PIL import Image
image = Image.fromstring('RGBA', (w, h), data)
image = image.transpose(Image.FLIP_TOP_BOTTOM)
image.save(filename)
# Cleanup
fbo.glBindRenderbufferEXT(fbo.GL_RENDERBUFFER_EXT, 0)
fbo.glBindFramebufferEXT(fbo.GL_FRAMEBUFFER_EXT, 0)
gl.glDeleteTextures(texture)
fbo.glDeleteFramebuffersEXT([
framebuffer,
])
def display(): #zadane tocke grupiraju se u grupe po 4 i tumace kao vrhovi cetverokuta koje treba nacrtati gl.glBegin(gl.GL_QUADS) gl.glColor3f(1,0,0); gl.glVertex2f( 1.0,-1.0) gl.glColor3f(1,1,0); gl.glVertex2f(-1.0,-1.0) gl.glColor3f(1,1,1); gl.glVertex2f(-1.0, 1.0) gl.glColor3f(1,0,1); gl.glVertex2f( 1.0, 1.0) gl.glEnd() gl.glBegin(gl.GL_QUADS) gl.glColor3f(1,0,0); gl.glVertex2f( -0.85,0.85) gl.glColor3f(1,1,1); gl.glVertex2f(0.85,0.85) gl.glColor3f(0,1,1); gl.glVertex2f(0.85, -0.85) gl.glColor3f(0,1,0); gl.glVertex2f( -0.85, -0.85) gl.glEnd() gl.glBegin(gl.GL_QUADS) gl.glColor3f(0,1,1); gl.glVertex2f( 0.5,-0.5) gl.glColor3f(1,0,1); gl.glVertex2f(-0.5,-0.5) gl.glColor3f(1,1,1); gl.glVertex2f(-0.5, 0.5) gl.glColor3f(1,0,0); gl.glVertex2f( 0.5, 0.5) gl.glEnd() glut.glutSwapBuffers()
def render_routine():
global render_time_list
# gl.glFinish()
# t_initial = time.time()
#prepare rendering model
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
glu.gluOrtho2D(*screen_limits)
# translate to position of left board and render
gl.glTranslatef(xTranslateLeft, yTranslate, 0.0)
CB_left.render()
# translate to position of right board and render
gl.glTranslatef(-xTranslateLeft + xTranslateRight, 0.0, 0.0)
CB_right.render()
#show the scene
gl.glFinish()
glut.glutSwapBuffers()
gl.glFinish()
t_final = time.time()
render_time_list.append(t_final)#t_final - t_initial)
def display(self):
now = time.time()
timedelt = now-self.timestamp
self.timestamp = now
self.current_fps = 1.0/timedelt
hid_js.read_js(self.camera)
view = self.camera.matrix()
# updating shared variables in shader data block. Also see
# timer()
self.shader_data_block.map()
self.shader_data_block.set('u_view', view)
self.shader_data_block.set("camera_position",
np.array(self.camera.loc,
dtype=np.float32))
self.light_count += 1
if self.light_count == 2:
self.light_count = 0
self.lights = self.get_lights()
self.shader_data_block.set("light_diffuse",
np.array(self.lights, dtype=np.float32))
self.shader_data_block.unmap()
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
for drawable in self.drawables:
drawable.draw()
glut.glutSwapBuffers()
def __display(self):
self.setSky(self.__Daytime)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
if self.__enableCamera == True:
self.__do_movement()
view = self.__camera.get_view_matrix()
glUniformMatrix4fv(self.view_loc, 1, GL_FALSE, view)
for element in self.__ElementsList:
if isinstance(element, DayNightTimeBase):
element.setDaytime(self.__Daytime)
glUniform1i(self.switcher_loc, 0)
if isinstance(element, DaytimeBase):
if self.__Daytime == True:
element.draw()
elif isinstance(element, NighttimeBase):
if self.__Daytime == False:
element.draw()
else:
element.draw()
glut.glutSwapBuffers()
def draw(): """skeleton function""" gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) #clear screen gl.glLoadIdentity() #reset postition glut.glutSwapBuffers() #allows doouble buffering
def display():
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
program.draw(gl.GL_TRIANGLES, indices)
glut.glutSwapBuffers()
# Take screenshot in every display()
screenshot()
def drawGLScene():
gl.glLoadIdentity()
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
cube.drawCube()
glut.glutSwapBuffers()
def tick(self, idle=None):
now = time.time()
if self.clock is not None:
self.elapsed = now - self.clock
self.clock = now
if (idle and self.state and self.state != self.last_save_state
and self.last_update_time
and self.clock > self.last_update_time + UPDATE_DELAY_SECONDS):
self.save_state()
if self.elapsed is not None and self.anim_t is not None:
last_t = self.anim_t
self.anim_t -= self.elapsed / self.anim_duration
self.anim_t = max(0, self.anim_t)
anim_te = pow(self.anim_t, self.anim_ease)
last_te = pow(last_t, self.anim_ease)
self.anim_d = (last_te - anim_te) / last_te
if self.anim_t == 0:
self.anim_t = None
self.update_state()
self.anim_camera()
self.anim_explode()
self.clear()
self.render_3d_lines()
self.render_2d_hud()
GLUT.glutSwapBuffers()
def on_display():
global shader
gl.glClearColor(1, 1, 1, 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnable(gl.GL_BLEND)
radius = 255.0
theta, dtheta = 0, 5.5 / 180.0 * math.pi
thickness = 1.0
support = .75
for i in range(500):
xc, yc = 256, 256 + 32
r = 10.1 - i * 0.02
thickness = 1.0 #0.1 + (1.0-i/500.0)*4
x0 = xc + np.cos(theta) * radius * .925
y0 = yc + np.sin(theta) * radius * .925
x1 = xc + np.cos(theta) * radius * 1.00
y1 = yc + np.sin(theta) * radius * 1.00
line((x0, y0), (x1, y1), thickness, support)
radius -= 0.45
theta += dtheta
for i in range(0, 49):
thickness = (i + 1) / 10.0
x = 20 + i * 10 + .315
y = 16 + .315
line((x, y + 6), (x, y - 6), thickness, support)
glut.glutSwapBuffers()
def display(): update_from_http_control() gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) camera() gl.glTranslate(cam_x, cam_y, cam_z) sphere() glut.glutSwapBuffers()
def display(self, camera_tr_vec, camera_rot_mat, camera_fov_y, tracked_cam_track_pos_float):
"""
Draw everything with specified render camera position, projection parameters and
tracked camera position
:param camera_tr_vec: vec3 position of render camera in global space
:param camera_rot_mat: mat3 rotation matrix of render camera in global space
:param camera_fov_y: render camera field of view. To be used for building a projection
matrix. Use glutGet to calculate current aspect ratio
:param tracked_cam_track_pos_float: a frame in which tracked camera
model and frustrum should be drawn (see tracked_cam_track_pos for basic task)
:return: returns nothing
"""
# a frame in which a tracked camera model and frustrum should be drawn
# without interpolation
tracked_cam_track_pos = int(tracked_cam_track_pos_float)
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
model = np.diag([1, -1, -1, 1]).astype(np.float32)
view = self._view_matrix(camera_tr_vec, camera_rot_mat)
projection = self._projection_matrix_from_fovy(camera_fov_y)
mvp = projection.dot(view.dot(model))
# Cloud of points
self._render_object(mvp, self._cloud_points_buffer, self._cloud_colors_buffer,
self._vertex_program, self._n_cloud_points)
# Camera track
# print(self._camera_track_positions[:tracked_cam_track_pos + 1])
self._render_object(mvp, self._bufferize(self._camera_track_positions[:tracked_cam_track_pos + 1]),
self._white, self._fragment_program, tracked_cam_track_pos + 1,
uniform_color=True, drawing_object=GL.GL_LINE_STRIP)
# Frustum
frustum_corners = self._frustum_corners(camera_fov_y,
self._camera_track_positions[tracked_cam_track_pos],
self._camera_track_rotations[tracked_cam_track_pos])
self._render_object(mvp, self._bufferize(frustum_corners),
self._yellow, self._fragment_program, 4,
uniform_color=True, drawing_object=GL.GL_LINE_LOOP)
self._render_object(mvp, self._bufferize(np.array(
[[self._camera_track_positions[tracked_cam_track_pos], p] for p in frustum_corners]
)),
self._yellow, self._fragment_program, 8,
uniform_color=True, drawing_object=GL.GL_LINES)
camera_pos = self._camera_track_positions[tracked_cam_track_pos]
camera_rot = self._camera_track_rotations[tracked_cam_track_pos]
rot_matrix = np.diag([-1., -1., -1.])
camera_vertices = np.array([rot_matrix.dot(camera_rot.dot(v)) + camera_pos
for v in self._camera_vertices], dtype=np.float32)
self._render_object(mvp, self._bufferize(camera_vertices),
self._blue, self._fragment_program, self._n_camera_vertices,
uniform_color=True, drawing_object=GL.GL_TRIANGLES)
GLUT.glutSwapBuffers()
def draw():
global alpha, left_button, right_button
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
figure()
alpha = alpha + delta_alpha
GLUT.glutSwapBuffers()
def on_display():
global cube, theta, phi, frame, time, timebase
frame += 1
time = glut.glutGet( glut.GLUT_ELAPSED_TIME )
if (time - timebase > 1000):
print frame*1000.0/(time-timebase)
timebase = time;
frame = 0;
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glPushMatrix()
gl.glRotatef(theta, 0,0,1)
gl.glRotatef(phi, 0,1,0)
gl.glDisable( gl.GL_BLEND )
gl.glEnable( gl.GL_LIGHTING )
gl.glEnable( gl.GL_DEPTH_TEST )
gl.glEnable( gl.GL_POLYGON_OFFSET_FILL )
gl.glPolygonMode( gl.GL_FRONT_AND_BACK, gl.GL_FILL )
cube.draw( gl.GL_QUADS, 'pnc' )
gl.glDisable( gl.GL_POLYGON_OFFSET_FILL )
gl.glEnable( gl.GL_BLEND )
gl.glDisable( gl.GL_LIGHTING )
gl.glPolygonMode( gl.GL_FRONT_AND_BACK, gl.GL_LINE )
gl.glDepthMask( gl.GL_FALSE )
gl.glColor( 0.0, 0.0, 0.0, 0.5 )
cube.draw( gl.GL_QUADS, 'p' )
gl.glDepthMask( gl.GL_TRUE )
gl.glPopMatrix()
glut.glutSwapBuffers()
def figure():
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
GL.glLoadIdentity()
GL.glPushMatrix()
GL.glRotatef(alpha, 0.0, 1.0, 0.0)
GL.glRotatef(beta, 0.0, 0.0, 1.0)
GL.glBindTexture(GL.GL_TEXTURE_2D, texture[0])
for i in range(n):
GL.glBegin(GL.GL_QUAD_STRIP)
for j in range(m):
x, y, z, s, t = f(i,j)
GL.glTexCoord2f(s, t)
GL.glVertex3f(x,y,z)
x, y, z, s, t = f(i+1, j)
GL.glTexCoord2f(s, t)
GL.glVertex3f(x,y,z)
GL.glEnd()
GL.glPopMatrix()
GLUT.glutSwapBuffers()
def display():
global phi, theta
gl.glDepthMask(gl.GL_TRUE)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
# Filled cube
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_POLYGON_OFFSET_FILL)
gl.glUniform4f(gpu["uniform"]["u_color"], 1, 1, 1, 1)
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, gpu["buffer"]["filled"])
gl.glDrawElements(gl.GL_TRIANGLES, len(f_indices), gl.GL_UNSIGNED_INT, None)
# Outlined cube
gl.glDisable(gl.GL_POLYGON_OFFSET_FILL)
gl.glEnable(gl.GL_BLEND)
gl.glDepthMask(gl.GL_FALSE)
gl.glUniform4f(gpu["uniform"]["u_color"], 0, 0, 0, 0.5)
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, gpu["buffer"]["outline"])
gl.glDrawElements(gl.GL_LINES, len(o_indices), gl.GL_UNSIGNED_INT, None)
gl.glDepthMask(gl.GL_TRUE)
# Rotate cube
theta += 0.5 # degrees
phi += 0.5 # degrees
model = np.eye(4, dtype=np.float32)
rotate(model, theta, 0, 0, 1)
rotate(model, phi, 0, 1, 0)
gl.glUniformMatrix4fv(gpu["uniform"]["u_model"], 1, False, model)
glut.glutSwapBuffers()
def render_routine():
global render_time_list
global render_left
global render_right
gl.glFinish()
ti = time.time()
#prepare rendering model
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
glu.gluOrtho2D(*screen_limits)
# translate to position of left board and render
gl.glTranslatef(xTranslateLeft, yTranslate, 0.0)
if render_left:
CB_left.render()
render_left = False
# translate to position of right board and render
gl.glTranslatef(-xTranslateLeft + xTranslateRight, 0.0, 0.0)
if render_right:
CB_right.render()
render_right = False
#show the scene
gl.glFinish()
glut.glutSwapBuffers()
# get time for later mean frame time calculation
gl.glFinish()
tf = time.time()
render_time_list.append(tf - ti)
def draw(self):
"""The OpenGL draw routine."""
# sys.stderr.write("Start GLUTContext.draw\n")
GL.glClearColor(self.background_color[0], self.background_color[1],
self.background_color[2], self.background_color[3])
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
GL.glEnable(GL.GL_DEPTH_TEST)
# sys.stderr.write("About to draw collections\n")
for collection in self.object_collections:
collection.draw()
err = GL.glGetError()
if err != GL.GL_NO_ERROR:
sys.stderr.write("Error {} drawing: {}\n".format(
err, gluErrorString(err)))
sys.exit(-1)
GLUT.glutSwapBuffers()
# sys.stderr.write("Done drawing collections.\n")
Rater.get().set()
# sys.stderr.write("End GLUTContext.draw\n")
self.framecount += 1
def display(self):
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glLoadIdentity()
# do zoom
glu.gluLookAt(0.0, 0.0, self.zoom, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0)
# do rotation
for x_rot, y_rot in reversed(self.rotations):
gl.glRotatef(math.sqrt(x_rot**2 + y_rot**2), y_rot, x_rot, 0)
#gl.glRotate(x_rot, 0, 1, 0)
#gl.glRotate(y_rot, 1, 0, 0)
"""
one, two, three, four = (1, 1, 0), (1, -1, 0), (-1, -1, 0), (-1, 1, 0)
draw_element(chemistry.elements[0], one)
draw_single_bond(one, two)
draw_element(chemistry.elements[0], two)
draw_double_bond(two, three)
draw_element(chemistry.elements[0], three)
draw_triple_bond(three, four)
draw_element(chemistry.elements[0], four)
draw_quadruple_bond(four, one)
"""
#self.draw_atoms(self.molecule)
gl.glCallList(self.displist)
#gl.glFlush()
glut.glutSwapBuffers()
def display():
global projection, view
global theta, phi
theta += .43
phi += .37
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
model = np.eye(4, dtype=np.float32)
rotate(model, theta, 0,0,1)
rotate(model, phi, 0,1,0)
shader.bind()
shader.uniformf('u_color', 1.0, 1.0, 1.0, 1.0 )
shader.uniform_matrixf('u_view', view)
shader.uniform_matrixf('u_projection', projection)
shader.uniform_matrixf('u_model', model)
gl.glDisable( gl.GL_BLEND )
gl.glEnable( gl.GL_DEPTH_TEST )
gl.glEnable( gl.GL_POLYGON_OFFSET_FILL )
obj.draw( gl.GL_TRIANGLES )
gl.glDisable( gl.GL_POLYGON_OFFSET_FILL )
gl.glEnable( gl.GL_BLEND );
gl.glDepthMask( gl.GL_FALSE );
shader.uniformf('u_color', 0.0, 0.0, 0.0, 0.25 )
outline.draw( gl.GL_LINES )
gl.glDepthMask( gl.GL_TRUE )
gl.glUseProgram( 0 )
glut.glutSwapBuffers()
def draw(self):
self.execute()
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
#handle mouse transformations
gl.glTranslatef(self.initrans[0], self.initrans[1], self.initrans[2])
gl.glRotatef(self.rotate[0], 1, 0, 0)
gl.glRotatef(self.rotate[1], 0, 1, 0) #we switched around the axis so make this rotate_z
gl.glTranslatef(self.translate[0], self.translate[1], self.translate[2])
gl.glEnable(gl.GL_POINT_SMOOTH)
gl.glPointSize(5)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
self.arrvbo.bind()
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glEnableClientState(gl.GL_COLOR_ARRAY)
gl.glVertexPointer(4, gl.GL_FLOAT, 0, self.arrvbo)
self.colvbo.bind()
gl.glColorPointer(4, gl.GL_FLOAT, 0, self.colvbo)
gl.glDrawArrays(gl.GL_POINTS, 0, self.size**3)
gl.glDisableClientState(gl.GL_VERTEX_ARRAY)
gl.glDisableClientState(gl.GL_COLOR_ARRAY)
self.arrvbo.unbind()
self.colvbo.unbind()
glut.glutSwapBuffers()
if self.makeMovie:
gl.glReadPixels(0,0,800,600,gl.GL_RGB, gl.GL_UNSIGNED_BYTE, array=self.curimage)
fname = '_tmp%05d.png'%self.curindex
scipy.misc.imsave(fname, self.curimage)
self.curindex += 1
def __glDraw(self):
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glEnableClientState(gl.GL_COLOR_ARRAY)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
width = glut.glutGet(glut.GLUT_WINDOW_WIDTH)
height = glut.glutGet(glut.GLUT_WINDOW_HEIGHT)
if width == 0:
return
wh = width * 1.0 / height
ctime = float(time.time()) - float(self.initTime)
gl.glUniformMatrix2fv(self.timeloc, 1, False, [ctime, 0.0, 0.0, ctime])
for varIndex, varValue in self.fractalSettings.vars.items():
cValue = [varValue, 0.0, 0.0, varValue]
gl.glUniformMatrix2fv(self.varloc[varIndex], 1, False, cValue)
st = self.fractalSettings
vertexAttrib = [st.center[0], st.center[1], st.scale, wh]
gl.glVertexAttrib4f(1, *vertexAttrib)
gl.glBegin(gl.GL_TRIANGLE_FAN)
gl.glVertex2f(-1, -1)
gl.glVertex2f(-1, 1)
gl.glVertex2f(1, 1)
gl.glVertex2f(1, -1)
gl.glEnd()
gl.glDisableClientState(gl.GL_VERTEX_ARRAY)
gl.glDisableClientState(gl.GL_COLOR_ARRAY)
glut.glutSwapBuffers()
def render(self):
"""
Render the scene using the sphere display list
"""
if self.do_exit:
print('renderer exiting ...')
# glut event loop needs hard exit ...
sys.exit(0)
if self.bodies is None:
time.sleep(1 / self.fps)
return
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glLoadIdentity()
x_size = GLUT.glutGet(GLUT.GLUT_WINDOW_WIDTH)
y_size = GLUT.glutGet(GLUT.GLUT_WINDOW_HEIGHT)
GLU.gluPerspective(60, float(x_size) / float(y_size), 0.05, 10)
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glLoadIdentity()
GL.glTranslatef(-_CAMERA_POSITION[0], -_CAMERA_POSITION[1],
-_CAMERA_POSITION[2])
self.mouse_interactor.apply_transformation()
for body_index in range(self.bodies.shape[0]):
body = self.bodies[body_index, :]
GL.glPushMatrix()
GL.glTranslatef(body[0], body[1], body[2])
GL.glScalef(body[3], body[3], body[3])
GL.glCallList(self.sphere)
GL.glPopMatrix()
GLUT.glutSwapBuffers()
def onDrawGL():
global g_yaw, g_pitch, g_translation_offset
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
# test
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glLoadIdentity()
#g_yaw+=0.05
#g_pitch+=0.05
GL.glTranslatef(0.0, 0.0, -g_translation_offset)
GL.glRotatef(g_yaw, 0, 1, 0)
#GL.glRotatef(g_pitch, 1, 0, 0)
#GL.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_POINT)
#GL.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_LINE)
for i, renderable in enumerate(g_renderables):
if g_active_renderable >= 0 and g_active_renderable != i:
continue
if renderable["type"] == "trimesh":
draw_tri_mesh(renderable["vertices"], renderable["normals"], renderable["indices"])
elif renderable["type"] == "points":
draw_points(renderable["positions"])
elif renderable["type"] == "lines":
draw_lines(renderable["positions"])
GL.glFlush()
GLUT.glutSwapBuffers()
def display():
simulation_start = timeit.default_timer()
simulation.step()
# simulation_end = timeit.default_timer()
# render_start = timeit.default_timer()
for k, p in enumerate(simulation.particles):
particle_position[k, 0] = p.position.x
particle_position[k, 1] = p.position.y
loc = gl.glGetUniformLocation(program, "particle_pos")
gl.glUniform2fv(loc, particle_count, particle_position)
loc = gl.glGetUniformLocation(program, "resolution")
gl.glUniform2f(loc, float(screen_x), float(screen_y))
loc = gl.glGetUniformLocation(program, "particle_bouding_radius")
gl.glUniform1f(loc, float(simulation.box_radius))
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glDrawArrays(gl.GL_TRIANGLE_STRIP, 0, 4)
glut.glutSwapBuffers()
render_end = timeit.default_timer()
fps_counter.append(1.0 / (render_end - simulation_start))
def render():
# clear screen
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
# reset camera
gl.glLoadIdentity()
# perform camera movement if necessary
if deltaMove:
computePos(deltaMove)
# set up camera
glu.gluLookAt(cam_pos_x, cam_pos_y, cam_pos_z, cam_pos_x + look_at_x,
cam_pos_y + look_at_y, cam_pos_z + look_at_z, 0.0, 1.0, 0.0)
# draw all bodies
for body in bodies:
body.draw()
# draw all springs
for s in springs:
s.draw()
blanket.draw()
# redraw
glut.glutSwapBuffers()
glut.glutPostRedisplay()
def display():
global projection, view
global theta, phi
theta += .43
phi += .37
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
model = np.eye(4, dtype=np.float32)
rotate(model, theta, 0, 0, 1)
rotate(model, phi, 0, 1, 0)
shader.bind()
shader.uniformf('u_color', 1.0, 1.0, 1.0, 1.0)
shader.uniform_matrixf('u_view', view)
shader.uniform_matrixf('u_projection', projection)
shader.uniform_matrixf('u_model', model)
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_POLYGON_OFFSET_FILL)
obj.draw(gl.GL_TRIANGLES)
gl.glDisable(gl.GL_POLYGON_OFFSET_FILL)
gl.glEnable(gl.GL_BLEND)
gl.glDepthMask(gl.GL_FALSE)
shader.uniformf('u_color', 0.0, 0.0, 0.0, 0.25)
outline.draw(gl.GL_LINES)
gl.glDepthMask(gl.GL_TRUE)
gl.glUseProgram(0)
glut.glutSwapBuffers()
def display(self):
""" Render the scene. """
start = time.time()
GL.glClear(GL.GL_COLOR_BUFFER_BIT |
GL.GL_DEPTH_BUFFER_BIT)
GL.glPushMatrix()
cam_x = self.zoom * math.sin(self.cam_lat) * math.cos(self.cam_long)
cam_y = self.zoom * math.sin(self.cam_lat) * math.sin(self.cam_long)
cam_z = self.zoom * math.cos(self.cam_lat)
GLU.gluLookAt(cam_x, cam_y, cam_z, 0, 0, 0, 0, 0, 2)
self.display_box()
self.display_points()
self.display_segments()
self.display_circles()
self.display_polygons()
self.display_regions()
self.display_sphere()
GL.glPopMatrix()
GLUT.glutSwapBuffers()
render_time = time.time() - start
GLUT.glutSetWindowTitle("%.3f" % render_time)
def display():
global phi, theta
gl.glDepthMask(gl.GL_TRUE)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
# Filled cube
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_POLYGON_OFFSET_FILL)
gl.glUniform4f(gpu["uniform"]["u_color"], 1, 1, 1, 1)
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, gpu["buffer"]["filled"])
gl.glDrawElements(gl.GL_TRIANGLES, len(f_indices), gl.GL_UNSIGNED_INT,
None)
# Outlined cube
gl.glDisable(gl.GL_POLYGON_OFFSET_FILL)
gl.glEnable(gl.GL_BLEND)
gl.glDepthMask(gl.GL_FALSE)
gl.glUniform4f(gpu["uniform"]["u_color"], 0, 0, 0, .5)
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, gpu["buffer"]["outline"])
gl.glDrawElements(gl.GL_LINES, len(o_indices), gl.GL_UNSIGNED_INT, None)
gl.glDepthMask(gl.GL_TRUE)
# Rotate cube
theta += 0.5 # degrees
phi += 0.5 # degrees
model = np.eye(4, dtype=np.float32)
rotate(model, theta, 0, 0, 1)
rotate(model, phi, 0, 1, 0)
gl.glUniformMatrix4fv(gpu["uniform"]["u_model"], 1, False, model)
glut.glutSwapBuffers()
def display( self ):
GL.glClearColor( 1.0, 1.0, 1.0, 1.0 )
GL.glClear( GL.GL_COLOR_BUFFER_BIT )
GL.glMatrixMode( GL.GL_PROJECTION )
GL.glLoadIdentity()
GL.glOrtho( 0, self.width, 0, self.height, -1, 1 )
GL.glLineWidth(3)
GL.glBegin( GL.GL_LINE_STRIP )
GL.glColor3f( 0.9, 0.3, 0.2 )
plen = max(int(1 / float(self.width) * len(self.points)), 1)
for x in xrange(self.width):
pstart = int(x / self.width * len(self.points))
prange = self.points[pstart:pstart + plen]
# The log10(sqrt(prange) + 1.) part is totally ripped from Clementine. I don't
# have any clue what it does, but it does make the thing look a whole lot nicer.
# You do lose some detail because of it, though.
# If you feel like explaining what the FHT::logSpectrum method defined in
# <http://code.google.com/p/clementine-player/source/browse/src/core/fht.cpp>
# actually does, drop me a mail at <*****@*****.**> - I'd appreciate it!
GL.glVertex2i( x, int(max(log10(sqrt(prange) + 1.)) * self.height) )
GL.glEnd()
GLUT.glutSwapBuffers()
self.framecount += 1
def display(self):
self.fps_frame += 1
self.fps_time = glut.glutGet(glut.GLUT_ELAPSED_TIME)
if self.fps_time - self.fps_timebase > 1000:
print('FPS:%4.2f' % (self.fps_frame * 1000.0 /
(self.fps_time - self.fps_timebase)))
self.fps_timebase = self.fps_time
self.fps_frame = 0
gl.glClear(self.clear_bit)
x, y, w, h = self.viewport
gl.glMatrixMode(gl.GL_PROJECTION)
gl.glLoadIdentity()
if self.isperspect:
fovy, aspect, zNear, zFar = self.glu_perspect
#print fovy
glu.gluPerspective(fovy, w / float(h), zNear, zFar)
else:
left, right, bottom, top, near, far = self.gl_orthog
gl.glOrtho(left, right, bottom, top, near, far)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
eyex, eyey, eyez, centx, centy, centz, upx, upy, upz = self.glu_lookat
glu.gluLookAt(eyex, eyey, eyez, centx, centy, centz, upx, upy, upz)
self.mouse.applyTransformation()
#Add objects
self.plot.display()
gl.glFlush()
glut.glutSwapBuffers()
def display(self): gl.glClearColor(0.3, 0.5, 0.8, 1.0) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glEnable(gl.GL_DEPTH_TEST) self.wm.camera.set_gl_camera() self.draw_func() glut.glutSwapBuffers()
def on_display( ):
global shader
gl.glClearColor(1,1,1,1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glActiveTexture(gl.GL_TEXTURE0)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnable(gl.GL_BLEND)
gl.glColor(0,0,0,1)
shader.bind()
radius = 255.0
theta, dtheta = 0, 5.5/180.0*math.pi
support = 0.75
thickness = 1.0
for i in range(500):
x = 256+radius*math.cos(theta);
y = 32+256+radius*math.sin(theta);
r = 10.1-i*0.02
circle( (x,y,r), thickness=thickness, support=support )
radius -= 0.45
theta += dtheta
for i in range(0,39):
r = 4
thickness = (i+1)/10.0
x = 20+i*12.5 - r
y = 16
circle( (x,y,r), thickness=thickness, support=support )
glut.glutSwapBuffers( )
def display(self):
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glLoadIdentity()
glu.gluLookAt(self.location[0], self.location[1], self.location[2],
self.focus[0],self.focus[1], self.focus[2] ,
self.up[0], self.up[1], self.up[2])
self.draw_points(self.N)
glut.glutSwapBuffers()
def on_display( ):
gl.glClearColor(1,1,1,1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnable(gl.GL_BLEND)
grid.draw()
collection.draw()
glut.glutSwapBuffers()
def render(self):
GL.glClear(GL.GL_COLOR_BUFFER_BIT)
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glLoadIdentity()
self.world.render()
GLUT.glutSwapBuffers()
def save(display_func, filename="screenshot.png"):
""" """
try:
import OpenGL.GL.EXT.framebuffer_object as fbo
except ImportError:
print 'You do not have the framebuffer extension on your video card'
print 'Cannot save figure'
return
x,y,w,h = gl.glGetIntegerv(gl.GL_VIEWPORT)
# Setup framebuffer
framebuffer = fbo.glGenFramebuffersEXT(1)
fbo.glBindFramebufferEXT( fbo.GL_FRAMEBUFFER_EXT, framebuffer)
# Setup depthbuffer
depthbuffer = fbo.glGenRenderbuffersEXT( 1 )
fbo.glBindRenderbufferEXT( fbo.GL_RENDERBUFFER_EXT, depthbuffer )
fbo.glRenderbufferStorageEXT( fbo.GL_RENDERBUFFER_EXT, gl.GL_DEPTH_COMPONENT, w, h)
# Create texture to render to
data = np.zeros((w,h,4), dtype=np.ubyte)
texture = gl.glGenTextures(1)
gl.glBindTexture( gl.GL_TEXTURE_2D, texture)
gl.glTexParameteri( gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR)
gl.glTexParameteri( gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR)
gl.glTexImage2D( gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, w, h, 0,
gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, data)
fbo.glFramebufferTexture2DEXT( gl.GL_FRAMEBUFFER_EXT, gl.GL_COLOR_ATTACHMENT0_EXT,
gl.GL_TEXTURE_2D, texture, 0)
fbo.glFramebufferRenderbufferEXT( gl.GL_FRAMEBUFFER_EXT, gl.GL_DEPTH_ATTACHMENT_EXT,
gl.GL_RENDERBUFFER_EXT, depthbuffer)
status = fbo.glCheckFramebufferStatusEXT( fbo.GL_FRAMEBUFFER_EXT )
if status != fbo.GL_FRAMEBUFFER_COMPLETE_EXT:
raise(RuntimeError, 'Error in framebuffer activation')
display_func()
glut.glutSwapBuffers()
data = gl.glReadPixels (x,y,w,h, gl.GL_RGB, gl.GL_UNSIGNED_BYTE)
from PIL import Image
#from PIL.ImageCms import profileToProfile
#ADOBE_RGB_PROFILE = "AdobeRGB1998.icc"
#SRGB_PROFILE = "./sRGB.icc"
#RGB_PROFILE = "./RGB.icc"
image = Image.fromstring('RGB', (w,h), data)
#profileToProfile(image, RGB_PROFILE, ADOBE_RGB_PROFILE, inPlace=1)
image = image.transpose(Image.FLIP_TOP_BOTTOM)
image.save (filename)
# Cleanup
fbo.glBindRenderbufferEXT( fbo.GL_RENDERBUFFER_EXT, 0 )
fbo.glBindFramebufferEXT( fbo.GL_FRAMEBUFFER_EXT, 0 )
gl.glDeleteTextures( texture )
fbo.glDeleteFramebuffersEXT( [framebuffer,] )
def redraw(self):
'''
The redraw() method invalidates the window area. Once the main loop
becomes idle (after the current batch of events has been processed,
roughly), the window will dispatch a ``draw`` event and swaps the
buffers if double buffered.
'''
self.dispatch_event('on_draw') # first redraw then swap buffers
glut.glutSwapBuffers()
def DrawGLScene(): GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) #drawRotatingObjects() #setOrthoMode() drawBitsLUT() #setPerspectiveMode() GLUT.glutSwapBuffers()
def display():
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
#GL.glDepthFunc(gl.GL_LEQUAL)
#gl.glDepthMask(gl.GL_TRUE)
#gl.glDrawArrays(gl.GL_TRIANGLE_STRIP, 0, 5)
#gl.glDrawElements(gl.GL_TRIANGLES, len(Indices), gl.GL_UNSIGNED_INT, None)
gl.glDrawElements(gl.GL_TRIANGLES, len(Indices), gl.GL_UNSIGNED_INT, ctypes.c_void_p(0))
glut.glutSwapBuffers()
def display():
gl.glClear(gl.GL_COLOR_BUFFER_BIT|gl.GL_DEPTH_BUFFER_BIT)
gl.glPushMatrix()
color = [1.0,0.5,0.5,1.]
gl.glMaterialfv(gl.GL_FRONT,gl.GL_DIFFUSE,color)
# glut.glutSolidSphere(2,20,20)
glut.glutSolidTeapot(0.5)
gl.glPopMatrix()
glut.glutSwapBuffers()
return
