def on_draw(self):
"""
Render the screen.
"""
start = time.time()
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glDisable(GL.GL_BLEND)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.vertex_vbo_id)
GL.glEnableClientState(GL.GL_VERTEX_ARRAY)
GL.glVertexPointer(2, GL.GL_FLOAT, 0, 0)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.color_vbo_id)
GL.glEnableClientState(GL.GL_COLOR_ARRAY)
GL.glColorPointer(3, GL.GL_FLOAT, 0, 0)
offset = 0
for shape in self.shape_list:
render_rect_filled(shape, offset)
offset += 4
elapsed = time.time() - start
print(elapsed)
def on_draw(self):
"""
Render the screen.
"""
start = time.time()
float_size = ctypes.sizeof(ctypes.c_float)
record_len = 10 * float_size
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glEnableClientState(GL.GL_VERTEX_ARRAY)
GL.glColor4ub(255, 0, 0, 255)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.rect_vbo.vbo_id)
GL.glVertexPointer(2, GL.GL_FLOAT, record_len, 0)
for i in range(len(self.shape_list)):
shape = self.shape_list[i]
GL.glLoadIdentity()
GL.glTranslatef(shape.x, shape.y, 0)
GL.glDrawArrays(GL.GL_QUADS, i * 8, 8)
# GL.glDrawArrays(GL.GL_QUADS,
# 0,
# self.rect_vbo.size)
elapsed = time.time() - start
print(elapsed)
def vykresli():
#Vykresleni hraciho pole
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
nakresli_obdelnik(0, 0, SIRKA, VYSKA, mode = gl.GL_LINE_STRIP)
#vykresleni pulici cary
nakresli_caru(SIRKA//2, 0, SIRKA//2, VYSKA)
#micek
nakresli_obdelnik(*micek, mode = gl.GL_QUADS)
#palky
nakresli_obdelnik(*palka1, mode = gl.GL_QUADS)
nakresli_obdelnik(*palka2, mode = gl.GL_QUADS)
#nazev hry
label = pyglet.text.Label("Hra PONG",
font_size = NADPIS_y,
x = window.width, y = window.height - NADPIS_y,
anchor_x = 'right')
label.draw()
#vykresleni micku
#vykresleni palek
#nastaveni pocatecniho skore, zobrazeni skor
vypis_skore()
def run(self):
while not self.has_exit:
dt = pyglet.clock.tick()
self.dispatch_events()
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glLoadIdentity()
self.shader.use()
self.shader["real"] = self.real
self.shader["w"] = self.w
self.shader["imag"] = self.imag
self.shader["h"] = self.h
gl.glBegin(gl.GL_QUADS)
gl.glVertex3f(0.0, 0.0, 0.0)
gl.glVertex3f(0.0, self.height, 0.0)
gl.glVertex3f(self.width, self.height, 0.0)
gl.glVertex3f(self.width, 0.0, 0.0)
gl.glEnd()
self.shader.stop()
if self.show_fps:
self.fps.draw()
if self.auto_zoom_in:
self.zoom_in(dt)
if self.auto_zoom_out:
self.zoom_out(dt)
self.key_move(dt=dt)
self.flip()
def on_draw(self):
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glColor3ub(255,255,255)
self.heading.draw()
for row in self.items:
for item in row:
item.draw()
def draw(self):
gl.glClear(gl.GL_DEPTH_BUFFER_BIT)
if self.game.game_over:
if self.game.game_lost:
gl.glBegin(gl.GL_QUADS)
gl.glColor3f(1, 1, 1)
gl.glVertex3f(0, 0, -0.9)
gl.glVertex3f(0, defs.WINDOW_HEIGHT, -0.9)
gl.glVertex3f(defs.WINDOW_WIDTH, defs.WINDOW_HEIGHT, -0.9)
gl.glVertex3f(defs.WINDOW_WIDTH, 0, -0.9)
gl.glEnd()
self.you_died.draw()
self.you_died2.draw()
if not self.died:
for name in self.VALUES:
getattr(self, name + '_label').color = (0, 0, 0, 255)
self.died = True
else:
gl.glBegin(gl.GL_QUADS)
gl.glColor3f(0, 0, 0)
gl.glVertex3f(0, 0, -0.9)
gl.glVertex3f(0, defs.WINDOW_HEIGHT, -0.9)
gl.glVertex3f(defs.WINDOW_WIDTH, defs.WINDOW_HEIGHT, -0.9)
gl.glVertex3f(defs.WINDOW_WIDTH, 0, -0.9)
gl.glEnd()
self.you_win.draw()
for name in self.VALUES:
getattr(self, name + '_label').draw()
def on_draw(self):
gl.glClearColor(0.5, 0.69, 1.0, 1.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
self.cam.apply()
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_LIGHTING)
gl.glEnable(gl.GL_CULL_FACE)
render_light((2, 10, -2))
gl.glMaterialfv(gl.GL_FRONT, gl.GL_AMBIENT_AND_DIFFUSE, to_gl_float([0.7, 0.7, 0.7, 1.0]))
check_draw_distance(self.cam.current_chunk)
if len(meshing_list) > 0:
chunks[meshing_list.pop(0)].mesh()
for chunk in active_chunks:
chunks[chunk].vbo.draw()
self.cam.ui_mode()
self.cam.ui.draw()
self.cam.perspective()
self.cam.apply()
def on_draw():
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
# draw_obj(bear, bear_tex)
draw_obj(ball, ball_tex)
def on_draw(self, gl=pyglet.gl): """Clear the current OpenGL context, reset the model/view matrix and invoke the `draw()` methods of the renderers in order """ gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glLoadIdentity() BaseWorld.draw_renderers(self)
def on_draw(self):
self.parent.set_caption(str(pyglet.clock.get_fps()))
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glColor4ub(*[255,255,255,255])
self.room.bg.blit(0,0)
self.room.render()
gl.glColor4ub(255,255,255,255)
self.player.draw()
self.room.lightbatch.draw()
self.player.draw_eye()
self.player.draw_integrity()
if self.pause:
gl.glColor4ub(50,50,50,150)
left = self.message['text'].x-self.message['text'].width/2 -5
down = self.message['text'].y-self.message['text'].height/2 -5
right = self.message['text'].x+self.message['text'].width/2 + 5
up = self.message['text'].y+self.message['text'].height/2 + 5
gl.glRecti(left,down,right,up)
gl.glLineWidth(2)
gl.glColor4ub(200,200,200,200)
gl.glBegin(gl.GL_LINE_LOOP)
gl.glVertex2i(left,down)
gl.glVertex2i(left,up)
gl.glVertex2i(right,up)
gl.glVertex2i(right,down)
gl.glEnd()
gl.glLineWidth(1)
gl.glColor4ub(255,255,255,255)
self.message['text'].draw()
self.message['helper'].draw()
self.message['sprite'].draw()
def flush_labels(self):
gl.glClear(gl.GL_DEPTH_BUFFER_BIT)
gl.glPushMatrix()
gl.glTranslatef(-self.game.camera_x * defs.WINDOW_SCALE[0],
-self.game.camera_y * defs.WINDOW_SCALE[1], 0)
for label, x, y, scale in self.labels:
if scale:
gl.glPushMatrix()
label.anchor_x = 'center'
label.anchor_y = 'center'
gl.glTranslatef(x * defs.WINDOW_SCALE[0],
y * defs.WINDOW_SCALE[1], 0)
gl.glScalef(*scale)
label.x = label.y = 0
label.draw()
gl.glPopMatrix()
else:
label.x = x * defs.WINDOW_SCALE[0]
label.y = y * defs.WINDOW_SCALE[1]
label.draw()
self.labels = []
gl.glColor3f(1, 1, 1)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glPopMatrix()
# self.fps_label.draw()
self.game.score.draw()
def run(self, dt):
## UPDATE ##
# timestep ala http://gafferongames.com/game-physics/fix-your-timestep/
if dt > .25: # avoid spiral of death (updating taking longer than framerate)
dt = .25
self.accumulatedFrameTime += dt
while self.accumulatedFrameTime >= self.updateRate:
self.accumulatedFrameTime -= self.updateRate
self.levelTime = time.time() - self.levelStartTime
for entity in self.groups['updating']:
entity.update(self.updateRate) # update all entities
self._processRemoving()
self._processAdding()
for level in self.groups['level']:
level.update(self.updateRate) # this will do the physics
## DRAW ##
gl.glClearColor(0,0,0, 0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glLoadIdentity()
self.camera.track() # does camera work (such as what it focuses on)
for name in self.drawLayerNames:
shift = Vec2d() if name.startswith('UI') else None
with self.camera.shiftView(shift):
for entity in self.drawLayers[name]: # TODO: not iterate over batched things
entity.draw()
self.drawLayersBatch[name].draw()
self.fps_display.draw()
def on_draw(self):
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
self.grid.draw()
self.score_bar.draw()
self.time_bar.draw()
if self.show_scores:
self.grid.draw_scores()
def OnDraw(self, *args, **kwargs):
"""Draw the window."""
self.pygletcontext.set_current()
glClearColor(*self.color_background)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
self.draw_objects()
self.canvas.SwapBuffers()
def clear_window(self, color):
'''
Clear window color and depth buffers, using the given color
'''
r, g, b, _ = color
gl.glClearColor(r, g, b, 1.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
def on_draw():
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
for block in blocks:
draw_block(block)
def render(self):
try:
if self._kill:
pyg_stop()
return
if self.state:
if self._create_draw:
self.create_drawable_objects()
if self._to_update:
self._update_sprites()
if self._rebuild_panel:
self.panel.from_list(
sorted([(score.points, k[0], score.str_nocolor()) for k, score in self.scores.items()],
reverse=True))
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
self._background.draw()
for d in self._sprites.values():
d.draw()
self.hud.draw()
self.panel.draw()
return True
else:
for d in self.get_welcome():
d.draw()
return True
except Exception, e:
time.sleep(0.0001)
print(e, traceback.print_exc())
raise e
def drawing():
gl.glClear(gl.GL_COLOR_BUFFER_BIT) # smaz obsah okna (vybarvi na cerno)
gl.glColor3f(0, 1, 0) # nastav barvu kresleni na zelenu
### Plots the snake body
for i in range(0,len(snake_position)-1):
draw_rectangle(PIECE*snake_position[i][0],PIECE*snake_position[i][1],PIECE*(snake_position[i][0]+1),PIECE*(snake_position[i][1]+1))
### Snake head in blue
gl.glColor3f(0, 0, 1)
draw_rectangle(PIECE*snake_position[-1][0],PIECE*snake_position[-1][1],PIECE*(snake_position[-1][0]+1),PIECE*(snake_position[-1][1]+1))
### Food
draw_rectangle(PIECE*food_position[0],PIECE*food_position[1],PIECE*(food_position[0]+1),PIECE*(food_position[1]+1))
### Score
draw_text(str(N-20),PIECE*SCORE_POSITION[0],PIECE*SCORE_POSITION[1],'left', PIECE*FONT_SIZE)
### Walls
gl.glColor3f(0, 1, 0) # nastav barvu kresleni na zelenu
draw_rectangle(0, 0, PIECE*WALL_THICKNESS, PIECE*HEIGHT)
draw_rectangle(0, 0, PIECE*WIDTH, PIECE*WALL_THICKNESS)
draw_rectangle(PIECE*WIDTH-PIECE*WALL_THICKNESS,0,PIECE*WIDTH,PIECE*HEIGHT)
draw_rectangle(0,PIECE*HEIGHT-PIECE*WALL_THICKNESS,PIECE*WIDTH,PIECE*HEIGHT)
if QUIT_SIGNAL==1:
draw_text('GAME OVER',PIECE*WIDTH//2-PIECE*FONT_SIZE*4,PIECE*HEIGHT//2-PIECE*FONT_SIZE//2,'left', PIECE*FONT_SIZE)
def copy_texture_to_screen():
# select the target to draw into
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
gl.glViewport(0, 0, window.width, window.height)
# clear the destination
gl.glClearColor(0.4, 0.4, 0.4, 1.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
# select the program for drawing
gl.glUseProgram(copy_program)
# send the vertex data
data = (TEXTURE_VERTEX * 8)(((-0.9, -0.9), (0.0, 0.0)),
((0.5, -0.9), (1.0, 0.0)),
((0.5, 0.5), (1.0, 1.0)),
((-0.9, 0.5), (0.0, 1.0)),
((0.6, 0.6), (0.0, 1.0)),
((1.0, 0.6), (1.0, 1.0)),
((1.0, 1.0), (1.0, 0.0)),
((0.6, 1.0), (0.0, 0.0)),
)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, copy_vertexbuffer)
gl.glBufferData(gl.GL_ARRAY_BUFFER, ctypes.sizeof(data), data, gl.GL_DYNAMIC_DRAW)
# draw
gl.glBindVertexArray(copy_vao)
gl.glDrawArrays(gl.GL_QUADS, 0, 8)
gl.glBindVertexArray(0)
def render_to_texture():
# select the target to draw into
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, framebuffer)
draw_buffers = (gl.GLenum * 1)(gl.GL_COLOR_ATTACHMENT0)
gl.glDrawBuffers(1, draw_buffers)
gl.glViewport(0, 0, FB_WIDTH, FB_HEIGHT)
# clear the destination
gl.glClearColor(0.5, 0.6, 0.7, 1.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
# prepare the rendering
gl.glUseProgram(render_program)
# send the vertex data
data = (COLOR_VERTEX * 3)(((-0.6, -0.5), (1.0, 0.0, 0.0, 1.0)),
((0.6, -0.5), (0.0, 1.0, 0.0, 1.0)),
((0.0, 0.5), (0.0, 0.0, 1.0, 1.0)))
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, render_vertexbuffer)
gl.glBufferData(gl.GL_ARRAY_BUFFER, ctypes.sizeof(data), data, gl.GL_DYNAMIC_DRAW)
# draw using the vertex array for vertex information
gl.glBindVertexArray(render_vao)
gl.glDrawArrays(gl.GL_TRIANGLES, 0, 3)
gl.glBindVertexArray(0)
def start():
gl.glClearColor(0.0, 0.0, 0.0, 1.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
global width, height, scale, pacman
pacman = Pacman()
scale = 20
w = board_width * scale
h = board_height * scale + 100
window.set_size(w, h)
x, y = window.get_location()
window.set_location(x, y - 150)
width = w // scale
height = h // scale
enemies['red'] = Enemy('red')
enemies['pink'] = Enemy('pink')
enemies['cyan'] = Enemy('cyan')
enemies['orange'] = Enemy('orange')
parse_board()
draw_board()
draw_dots()
draw_ui()
draw_score()
draw_lives()
set_speeds(0.075)
pyglet.clock.schedule_once(toggle_mode, 7)
pyglet.clock.schedule_interval(game_loop, 1 / 60)
pyglet.app.run()
def on_draw(self):
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
if self.app.show_fps:
self.fps_display.draw()
self.app.on_draw()
def on_draw():
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
#flip_origin_top_left()
#plot_test_box()
sprite.scale = min(window.width / sprite.image.width,
window.height / sprite.image.height)
sprite.draw()
plot_box_label_yml(my_yml_dict, sprite.scale_x, sprite.scale_y)
def OnDraw(self, *args, **kwargs):
"Draw the window."
# clear the context
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
# draw objects
self.draw_objects()
# update screen
self.SwapBuffers()
def start_render():
"""
Get set up to render. Required to be called before drawing anything to the
screen.
"""
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
def update_drawing(self):
# self.draw_rect(0,0,self.width,self.height,(0,0,0))
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
self.clear()
self.main_batch.draw()
print('drwa')
self.main_batch = pyglet.graphics.Batch()
self.save_drawing()
def paintGL(self):
"""
Clears the back buffer than calls the on_draw method
"""
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glLoadIdentity()
self.on_draw()
def on_draw():
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
glLoadIdentity()
glTranslatef(0, 0, -4)
glRotatef(rz, 0, 0, 1)
glRotatef(ry, 0, 1, 0)
glRotatef(rx, 1, 0, 0)
torus.draw()
def clear(self, color):
"Clear the window background with the given color"
glClearColor(
color[0] / 255,
color[1] / 255,
color[2] / 255,
1.0)
glClear(GL_COLOR_BUFFER_BIT)
def draw_camera():
gl.glViewport(0, 0, w, h)
gl.glMatrixMode(gl.GL_PROJECTION)
gl.glLoadIdentity()
gl.glOrtho(0, w, 0, h, -1, 1)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glLoadIdentity()
def start_render():
"""
Get set up to render. Required to be called before drawing anything to the
screen.
"""
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
def on_expose():
gl.glClearColor(1.0, 1.0, 1.0, 1.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
img.blit(
(win.width - img.width) / 2,
(win.height - img.height) / 2
)
def activate(self):
gl.glBindFramebufferEXT(gl.GL_FRAMEBUFFER_EXT, self._buffer)
gl.glPushAttrib(gl.GL_VIEWPORT_BIT)
gl.glViewport(0, 0, *self.render_target_size)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
def on_draw(self, gl=pyglet.gl):
"""Clear the current OpenGL context, reset the model/view matrix and
invoke the `draw()` methods of the renderers in order
"""
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glLoadIdentity()
for renderer in self.renderers:
renderer.draw()
def on_expose():
gl.glClearColor(1.0, 1.0, 1.0, 1.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
img.blit(
(win.width - img.width) / 2,
(win.height - img.height) / 2
)
def OnDraw(self, *args, **kwargs):
"Draw the window."
#clear the context
gl.glClear(gl.GL_COLOR_BUFFER_BIT|gl.GL_DEPTH_BUFFER_BIT)
#draw objects
self.draw_objects()
#update screen
self.SwapBuffers()
def render(self):
gl.glUseProgram(self.programA)
gl.glUniform1i(self.tex_pos_A, 0)
for i in range(args["outResolution"]):
gl.glUniform1i(self.slice_pos_A, i)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.framebufferA0[i])
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glDrawArrays(gl.GL_TRIANGLES, 0, 6)
def on_draw():
#w.clear()
global parent
global parentdiff
global olddrawing,newdrawing
global blitted
global image_pixels
global keeps
global i
if not blitted:
"""
At the start we've not seen the target before,
so draw it and store the pixel data.
"""
gl.glBindFramebufferEXT(gl.GL_FRAMEBUFFER_EXT, 0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
pic.blit(0,0)
blitted = 1
image_pixels = (gl.GLubyte * (4*size))(0)
gl.glReadPixels(0,
0,
newdrawing.width,
newdrawing.height,
gl.GL_RGBA,
gl.GL_UNSIGNED_BYTE,
image_pixels
)
image_pixels = np.frombuffer(image_pixels, dtype=np.uint8).astype(np.int32)
# Draw the new child
newdrawing.draw()
# Read the pixel data for the child and find out if its any good
gl.glReadPixels(0,
0,
newdrawing.width,
newdrawing.height,
gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, a)
diff = compute_diff(a)
if parent == None or diff < parentdiff:
# The new drawing is better.
# Redraw the parent as this child.
# Set this child's diff as the new one to beat.
parent = image.ImageData(newdrawing.width,newdrawing.height,"RGBA",a)
parentdiff = diff
draw_parent(parent, newdrawing.width)
else:
# The new drawing sucks. Replace it
newdrawing = olddrawing
i += 1
if (i % 20 == 0):
# Use the window title to let the user know how we're doing
w.set_caption(str(fps.get_fps())+" "+str(parentdiff) + " " + str(log(parentdiff,10))+ " " + str(i))
fps.tick()
def _endOfFlip(self, clearBuffer):
"""Override end of flip with custom color channel masking if required.
"""
if clearBuffer:
GL.glClear(GL.GL_COLOR_BUFFER_BIT)
# nop if we are still setting up the window
if hasattr(self, '_eyeBuffers'):
self.setBuffer('left', clear=clearBuffer)
def on_draw():
global started
glClearColor(1, 0.9, 0.8, 0)
glClear(GL_COLOR_BUFFER_BIT)
if not started:
return
cur.draw()
for line in lines:
line.draw()
def reset(self):
"""New frame"""
pyglet.clock.tick()
self.display_surface.dispatch_events()
pyglet.gl.glClearColor(1, 1, 1, 1)
from pyglet.gl import glClear
glClear(pyglet.gl.GL_COLOR_BUFFER_BIT)
self.main_batch = pyglet.graphics.Batch()
def on_expose(self):
gl.glClearColor(0.5, 0, 0, 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glLoadIdentity()
self.draw()
self.window.flip()
if self.capture_regression_image():
self.window.exit_handler.has_exit = True
def draw_board():
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
for x, y, direction in walls:
[
draw_sub_rect(x, height - y - 4, sx, sy, sw, sh, (0.0, 0.0, 1.0),
stage_batch)
for sx, sy, sw, sh in wall_vertices[direction]
]
def on_draw(self, context):
self.camera.push_state()
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
self.tilemap.draw(IndexGroup2D(self.static_grid, self.dynamic_grid))
self.fps_counter.draw()
self.camera.pop_state()
def on_draw(self):
self._update_meshes()
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glLoadIdentity()
# pull the new camera transform from the scene
transform_camera, _junk = self.scene.graph['camera']
# apply the camera transform to the matrix stack
gl.glMultMatrixf(_gl_matrix(transform_camera))
# dragging the mouse moves the view transform (but doesn't alter the
# scene)
transform_view = _view_transform(self.view)
gl.glMultMatrixf(_gl_matrix(transform_view))
# we want to render fully opaque objects first,
# followed by objects which have transparency
node_names = collections.deque(self.scene.graph.nodes_geometry)
count_original = len(node_names)
count = -1
while len(node_names) > 0:
count += 1
current_node = node_names.popleft()
# if the flag isn't defined, this will be None
# by checking False explicitly, it makes the default
# behaviour to render meshes with no flag defined.
# if self.node_flag(name_node, 'visible') is False:
# continue
transform, geometry_name = self.scene.graph[current_node]
if geometry_name is None:
continue
mesh = self.scene.geometry[geometry_name]
if (hasattr(mesh, 'visual') and
mesh.visual.transparency):
# put the current item onto the back of the queue
if count < count_original:
node_names.append(current_node)
continue
# add a new matrix to the model stack
gl.glPushMatrix()
# transform by the nodes transform
gl.glMultMatrixf(_gl_matrix(transform))
# get the mode of the current geometry
mode = self.vertex_list_mode[geometry_name]
# draw the mesh with its transform applied
self.vertex_list[geometry_name].draw(mode=mode)
# pop the matrix stack as we drew what we needed to draw
gl.glPopMatrix()
def on_draw(self):
#self.clear()
#self.set_3d()
# Draw world stuff
#glColor3d(1, 1, 1)
# self.world.batch.draw()
glClearColor(0.5, 0.1, 0.1, 1.0)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
glBindVertexArray(self.world.chunk.vao)
glDrawArrays(GL_TRIANGLES, 0, 3)
def render(shape):
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glLoadIdentity()
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glEnableClientState(gl.GL_COLOR_ARRAY)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, shape.vbo_id)
gl.glVertexPointer(2, gl.GL_FLOAT, 0, None)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, shape.vbo_color_id)
gl.glColorPointer(4, gl.GL_FLOAT, 0, None)
gl.glDrawArrays(shape.draw_mode, 0, shape.size)
def on_draw():
"""Clear the window on every frame and draw in game objects."""
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glColor4f(*SETTINGS.graphics.background)
WINDOW.clear()
helpers.draw_fan(SHAPES[0].shape.body.position, POINTS, (0.8, 0.3, 0.2, 1))
FPS.draw()
for id_, shape in SHAPES.items():
if id_ == 0:
helpers.draw_shape(shape.shape, shape.properties)
def draw_board():
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
for x, y in board_visibility:
draw_rect(x, y, (1.0, 1.0, 1.0))
draw_number(x, y, board[y][x])
[draw_rect(x, y, (1.0, 0.0, 0.0)) for x, y in flags]
batch.draw()
def draw():
data = (VERTEX * 3)(((-0.6, -0.5), (1.0, 0.0, 0.0, 1.0)),
((0.6, -0.5), (0.0, 1.0, 0.0, 1.0)),
((0.0, 0.5), (0.0, 0.0, 1.0, 1.0)))
gl.glClearColor(0.5, 0.6, 0.7, 1.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vertexbuffer)
gl.glBufferData(gl.GL_ARRAY_BUFFER, ctypes.sizeof(data), data, gl.GL_DYNAMIC_DRAW)
gl.glDrawArrays(gl.GL_TRIANGLES, 0, 3)
def draw(self):
"""
Draw the world.
"""
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glClearColor(255, 255, 255, 255)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
for ent in self.ents.values():
ent.draw()
def refresh_buffer():
global passes, start_time
with targetbuffer:
gl.glViewport(0, 0, FB_WIDTH, FB_HEIGHT)
gl.glClearColor(0.0, 0.0, 0.0, 1.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
passes = 0
start_time = time()
def on_key_press(self, symbol, modifiers):
if symbol == key.R:
self.rotation_x = 90
self.rotation_y = 0
self.x = 0
self.y = 0
self.zoom_level = 4
gl.glDisable(gl.GL_DEPTH_TEST)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
return None
def on_draw(self, context):
self.camera.push_state()
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
self.tilemap.draw()
self.player.draw()
self.origin_text.draw()
self.origin_text_x.draw()
self.origin_text_y.draw()
self.camera.pop_state()
def display(self, width, height):
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glMatrixMode(gl.GL_PROJECTION)
gl.glLoadIdentity()
gl.glOrtho(0, width, 0, height, -1, 1)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
gl.glTranslatef(self.trans[0], self.trans[1], 0)
gl.glScalef(self.trans[2], self.trans[2], self.trans[2])
# FIXME draw only visible part?
self.renderer.render()
def set_up_perspective(self):
glViewport(0, 0, self.width * 2, self.height * 2)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
glEnable(GL_DEPTH_TEST)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
gluPerspective(60., self.perspective, 1., 1000.)
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
glRotatef(90, 1, 0, 0)
def setup(self):
""" Does some one-time OpenGL setup.
"""
gl.glEnable(gl.GL_LIGHTING)
gl.glClearColor(1, 1, 1, 1)
gl.glColor3f(1, 0, 0)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_CULL_FACE)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glLoadIdentity()
self.is_setup = True
def OnDraw(self, *args, **kwargs):
"""Draw the window."""
# clear the context
if not self.IsShown():
return
self.canvas.SetCurrent(GLPanel.SharedGLContext)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
# draw objects
self.draw_objects()
# update screen
self.SwapBuffers()
def on_draw():
glClear(GL_COLOR_BUFFER_BIT)
BG_SPRITE.y = WINDOW.height - BG_SPRITE.height
BG_SPRITE.draw()
for row in board.board:
for tile in row:
if tile is not None:
tile.batch.draw()
if board.lost:
LOST_TEXT.text = "Final Score: " + str(board.score)
LOST_SCREEN.draw()
