def start(self, level=1): w, h = SCREEN_SIZE self.window = pyglet.window.Window(width=w, height=h, caption=NAME) self.game = self.scene = Scene(self, level=level) self.squid = self.game.world.squid self.editor = Editor(self, self.game.world) gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthFunc(gl.GL_ALWAYS) gl.glMatrixMode(gl.GL_MODELVIEW) gl.glTranslatef(0, 0, -0.5) gl.glEnable(gl.GL_ALPHA_TEST) gl.glAlphaFunc(gl.GL_GREATER, 0) self.fps_display = pyglet.clock.ClockDisplay() pyglet.clock.schedule_interval(self.update, 1 / TARGET_FPS) pyglet.clock.set_fps_limit(TARGET_FPS) self.window.push_handlers(on_key_press=self.on_key_press) self.window.push_handlers() if level == 1: self.title_screen() else: self.next_level() pyglet.app.run()
def _setup_3d(self): w, h = self.get_size() gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthFunc(gl.GL_LEQUAL) gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_CULL_FACE) viewport = self.get_viewport_size() gl.glViewport(0, 0, max(1, viewport[0]), max(1, viewport[1])) gl.glMatrixMode(gl.GL_PROJECTION) gl.glLoadIdentity() gl.gluPerspective(*self.perspective) gl.glMatrixMode(gl.GL_MODELVIEW) gl.glLoadIdentity() y, x = self.rotation gl.glRotatef(x, 0, 1, 0) gl.glRotatef(-y, math.cos(math.radians(x)), 0, math.sin(math.radians(x))) # NOTE: for GL render, its x-z plane is the ground plane, # so we unpack the position using `(x, z, y)` instead of `(x, y, z)` x, z, y = self.position if not self.debug_mode: y += self.perspective_over_drone[0] z += self.perspective_over_drone[1] gl.glTranslatef(-x, -y, -z)
def draw(self): gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthFunc(gl.GL_LEQUAL) dx = self.tile_size[0] dy = self.tile_size[1] stack = self.half_stack # terrain pass x, y = self.start_x, self.start_y for row in self.__map: x = self.start_x for tile, item in row: tile.blit(x, y, 0) x += dx y += dy # bullet pass for bullet in self.bullets: bullet.draw() # item pass x, y = self.start_x, self.start_y for row in self.__map: x = self.start_x for tile, item in row: if item is not None: item.blit(x, y + stack, 1) x += dx y += dy
def gl_enable_depth(z_near, z_far): gl.glDepthRange(z_near, z_far) gl.glClearDepth(1.0) gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthFunc(gl.GL_LEQUAL) gl.glEnable(gl.GL_CULL_FACE)
def set_state(self): self.program.bind() gl.glEnable(pyglet.gl.GL_LINE_SMOOTH) gl.glLineWidth(3) gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthFunc(gl.GL_LESS)
def set_state(self): self.program.use() gl.glActiveTexture(gl.GL_TEXTURE0) gl.glBindTexture(self.texture.target, self.texture.id) gl.glActiveTexture(gl.GL_TEXTURE1) gl.glBindTexture(self.normal_map.target, self.normal_map.id) gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthFunc(gl.GL_LESS)
def set_depth_test(self, on=True): """Enables z test. On by default""" if on: gl.glClearDepth(1.0) gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthFunc(gl.GL_LEQUAL) gl.glHint(gl.GL_PERSPECTIVE_CORRECTION_HINT, gl.GL_NICEST) else: gl.glDisable(gl.GL_DEPTH_TEST)
def _gl_enable_depth(): gl.glDepthRange(0.0, 1000.0) gl.glClearDepth(1.0) gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthFunc(gl.GL_LEQUAL) gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_CULL_FACE)
def set_state(self): self.program.use() gl.glActiveTexture(gl.GL_TEXTURE0) gl.glBindTexture(self.texture.target, self.texture.id) # gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, # gl.GL_MIRRORED_REPEAT) # gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, # gl.GL_MIRRORED_REPEAT) gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthFunc(gl.GL_LESS)
def init_gl(self): """ Perform the magic incantations to create an OpenGL scene. """ # the background color gl.glClearColor(.97, .97, .97, 1.0) max_depth = (np.abs(self.scene.bounds).max(axis=1)**2).sum()**.5 max_depth = np.clip(max_depth, 500.00, np.inf) gl.glDepthRange(0.0, max_depth) gl.glClearDepth(1.0) gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthFunc(gl.GL_LEQUAL) gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_CULL_FACE) gl.glEnable(gl.GL_LIGHTING) gl.glEnable(gl.GL_LIGHT0) gl.glEnable(gl.GL_LIGHT1) # put the light at one corner of the scenes AABB gl.glLightfv( gl.GL_LIGHT0, gl.GL_POSITION, rendering.vector_to_gl(np.append(self.scene.bounds[1], 0))) gl.glLightfv(gl.GL_LIGHT0, gl.GL_SPECULAR, rendering.vector_to_gl(.5, .5, 1, 1)) gl.glLightfv(gl.GL_LIGHT0, gl.GL_DIFFUSE, rendering.vector_to_gl(1, 1, 1, .75)) gl.glLightfv(gl.GL_LIGHT0, gl.GL_AMBIENT, rendering.vector_to_gl(.1, .1, .1, .2)) gl.glColorMaterial(gl.GL_FRONT_AND_BACK, gl.GL_AMBIENT_AND_DIFFUSE) gl.glEnable(gl.GL_COLOR_MATERIAL) gl.glShadeModel(gl.GL_SMOOTH) gl.glMaterialfv(gl.GL_FRONT, gl.GL_AMBIENT, rendering.vector_to_gl(0.192250, 0.192250, 0.192250)) gl.glMaterialfv(gl.GL_FRONT, gl.GL_DIFFUSE, rendering.vector_to_gl(0.507540, 0.507540, 0.507540)) gl.glMaterialfv(gl.GL_FRONT, gl.GL_SPECULAR, rendering.vector_to_gl(.5082730, .5082730, .5082730)) gl.glMaterialf(gl.GL_FRONT, gl.GL_SHININESS, .4 * 128.0) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnable(gl.GL_LINE_SMOOTH) gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST) gl.glLineWidth(1.5) gl.glPointSize(4)
def SetDrawMosaicState(): gl.glEnable(gl.GL_TEXTURE_2D) gl.glDisable(gl.GL_CULL_FACE) gl.glEnable(GL_DEPTH_TEST) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP_TO_BORDER) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP_TO_BORDER) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_ONE, gl.GL_ZERO) gl.glDepthFunc(gl.GL_LESS)
def _gl_enable_depth(camera): """ Enable depth test in OpenGL using distances from `scene.camera`. """ # set the culling depth from our camera object gl.glDepthRange(camera.z_near, camera.z_far) gl.glClearDepth(1.0) gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthFunc(gl.GL_LEQUAL) gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_CULL_FACE)
def OnInitGL(self, call_reshape=True): '''Initialize OpenGL for use in the window.''' if self.GLinitialized: return self.GLinitialized = True # create a pyglet context for this panel self.pygletcontext = gl.Context(gl.current_context) self.pygletcontext.canvas = self self.pygletcontext.set_current() # normal gl init glClearColor(0, 0, 0, 1) glColor3f(1, 0, 0) glEnable(GL_DEPTH_TEST) glClearDepth(1.0) glDepthFunc(GL_LEQUAL) glEnable(GL_CULL_FACE) glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) # Uncomment this line for a wireframe view # glPolygonMode(GL_FRONT_AND_BACK, GL_LINE) # Simple light setup. On Windows GL_LIGHT0 is enabled by default, # but this is not the case on Linux or Mac, so remember to always # include it. glEnable(GL_LIGHTING) glEnable(GL_LIGHT0) glEnable(GL_LIGHT1) glLightfv(GL_LIGHT0, GL_POSITION, vec(.5, .5, 1, 0)) glLightfv(GL_LIGHT0, GL_SPECULAR, vec(.5, .5, 1, 1)) glLightfv(GL_LIGHT0, GL_DIFFUSE, vec(1, 1, 1, 1)) glLightfv(GL_LIGHT1, GL_POSITION, vec(1, 0, .5, 0)) glLightfv(GL_LIGHT1, GL_DIFFUSE, vec(.5, .5, .5, 1)) glLightfv(GL_LIGHT1, GL_SPECULAR, vec(1, 1, 1, 1)) glShadeModel(GL_SMOOTH) glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, vec(0.5, 0, 0.3, 1)) glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, vec(1, 1, 1, 1)) glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 50) glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, vec(0, 0.1, 0, 0.9)) if call_reshape: self.OnReshape() if hasattr(self.parent, "filenames") and self.parent.filenames: for filename in self.parent.filenames: self.parent.load_file(filename) self.parent.autoplate() if hasattr(self.parent, "loadcb"): self.parent.loadcb() self.parent.filenames = None
def init_gl(): gl.glClearDepth(1.0) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glDepthFunc(gl.GL_LEQUAL) gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthFunc(gl.GL_LEQUAL) gl.glShadeModel(gl.GL_SMOOTH) gl.glHint(gl.GL_PERSPECTIVE_CORRECTION_HINT, gl.GL_NICEST) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_REPEAT) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_REPEAT)
def OnInitGL(self, call_reshape = True): '''Initialize OpenGL for use in the window.''' if self.GLinitialized: return self.GLinitialized = True # create a pyglet context for this panel self.pygletcontext = gl.Context(gl.current_context) self.pygletcontext.canvas = self self.pygletcontext.set_current() # normal gl init glClearColor(0, 0, 0, 1) glColor3f(1, 0, 0) glEnable(GL_DEPTH_TEST) glClearDepth(1.0) glDepthFunc(GL_LEQUAL) glEnable(GL_CULL_FACE) glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) # Uncomment this line for a wireframe view # glPolygonMode(GL_FRONT_AND_BACK, GL_LINE) # Simple light setup. On Windows GL_LIGHT0 is enabled by default, # but this is not the case on Linux or Mac, so remember to always # include it. glEnable(GL_LIGHTING) glEnable(GL_LIGHT0) glEnable(GL_LIGHT1) glLightfv(GL_LIGHT0, GL_POSITION, vec(.5, .5, 1, 0)) glLightfv(GL_LIGHT0, GL_SPECULAR, vec(.5, .5, 1, 1)) glLightfv(GL_LIGHT0, GL_DIFFUSE, vec(1, 1, 1, 1)) glLightfv(GL_LIGHT1, GL_POSITION, vec(1, 0, .5, 0)) glLightfv(GL_LIGHT1, GL_DIFFUSE, vec(.5, .5, .5, 1)) glLightfv(GL_LIGHT1, GL_SPECULAR, vec(1, 1, 1, 1)) glShadeModel(GL_SMOOTH) glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, vec(0.5, 0, 0.3, 1)) glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, vec(1, 1, 1, 1)) glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 50) glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, vec(0, 0.1, 0, 0.9)) if call_reshape: self.OnReshape() if hasattr(self.parent, "filenames") and self.parent.filenames: for filename in self.parent.filenames: self.parent.load_file(filename) self.parent.autoplate() if hasattr(self.parent, "loadcb"): self.parent.loadcb() self.parent.filenames = None
def __init__(self, *args, **kwargs): super(Window, self).__init__(*args, **kwargs) self.camera = Camera() self.axis = Axis(40 + self.width / -2, 40 + self.height / -2, 0) self.border = Border(self.width - 32, self.height - 32) self.models = [] for n in xrange(24): self.models.append(DroneModel(n * -100, -100, 000 + n * -110)) self.terrain = TerrainModel(0, self.height / -4) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glDepthFunc(gl.GL_LEQUAL) pyglet.clock.schedule(self.update) self.clock = pyglet.clock.ClockDisplay() self.step = 0.0
def draw(self, viewport): for s in self.sprites: s.draw() # Draw with depth testing gl.glDepthFunc(gl.GL_LEQUAL) if self.splash_group: self.splash_group.draw() for a in self.actors: a.draw() if self.crashed: # Keep particles going self.particles.draw() elif not self.won: self.squid.draw() gl.glDepthFunc(gl.GL_ALWAYS)
def SetDrawTextureState(): gl.glEnable(gl.GL_TEXTURE_2D) gl.glDisable(gl.GL_CULL_FACE) gl.glEnable(GL_DEPTH_TEST) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP_TO_BORDER) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP_TO_BORDER) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_ONE, gl.GL_ONE) gl.glDepthFunc(gl.GL_LESS)
def init_gl(self, on_init=None, **kwargs): gl.glClearColor(.97, .97, .97, 1.0) max_depth = (np.abs(self.scene.bounds).max(axis=1)**2).sum()**.5 max_depth = np.clip(max_depth, 500.00, np.inf) gl.glDepthRange(0.0, max_depth) gl.glClearDepth(1.0) gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthFunc(gl.GL_LEQUAL) gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_CULL_FACE) gl.glEnable(gl.GL_LIGHTING) gl.glEnable(gl.GL_LIGHT0) gl.glEnable(gl.GL_LIGHT1) # put the light at one corner of the scenes AABB gl.glLightfv(gl.GL_LIGHT0, gl.GL_POSITION, _gl_vector(np.append(self.scene.bounds[1], 0))) gl.glLightfv(gl.GL_LIGHT0, gl.GL_SPECULAR, _gl_vector(.5, .5, 1, 1)) gl.glLightfv(gl.GL_LIGHT0, gl.GL_DIFFUSE, _gl_vector(1, 1, 1, .75)) gl.glLightfv(gl.GL_LIGHT0, gl.GL_AMBIENT, _gl_vector(.1, .1, .1, .2)) gl.glColorMaterial(gl.GL_FRONT_AND_BACK, gl.GL_AMBIENT_AND_DIFFUSE) gl.glEnable(gl.GL_COLOR_MATERIAL) gl.glShadeModel(gl.GL_SMOOTH) gl.glMaterialfv(gl.GL_FRONT, gl.GL_AMBIENT, _gl_vector(0.192250, 0.192250, 0.192250)) gl.glMaterialfv(gl.GL_FRONT, gl.GL_DIFFUSE, _gl_vector(0.507540, 0.507540, 0.507540)) gl.glMaterialfv(gl.GL_FRONT, gl.GL_SPECULAR, _gl_vector(.5082730, .5082730, .5082730)) gl.glMaterialf(gl.GL_FRONT, gl.GL_SHININESS, .4 * 128.0) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnable(gl.GL_LINE_SMOOTH) gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST) gl.glLineWidth(1.5) gl.glPointSize(4) if on_init: on_init(gl, **kwargs)
def set_3d(self): width, height = self.get_size() glEnable(GL_CULL_FACE) glEnable(GL_DEPTH_TEST) glDepthFunc(GL_LESS) glViewport(0, 0, width, height) glMatrixMode(GL_PROJECTION) glLoadIdentity() gluPerspective(45.0, width / float(height), 0.1, 60.0) glMatrixMode(GL_MODELVIEW) glLoadIdentity() yaw, pitch = self.camera.rotation glRotatef(yaw, 0, 1, 0) glRotatef(-pitch, math.cos(math.radians(yaw)), 0, math.sin(math.radians(yaw))) x, y, z = self.camera.position glTranslatef(-x, -y, -z)
def enable_3d(self): gl.glViewport(0, 0, self.width, self.height) gl.glMatrixMode(gl.GL_PROJECTION) gl.glLoadIdentity() gl.gluPerspective(60., self.width / float(self.height), .1, 1000.) gl.glMatrixMode(gl.GL_MODELVIEW) gl.glDepthFunc(gl.GL_LEQUAL) gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_CULL_FACE) # update the camera self.camera.look() # TODO: probably find a better place to enable and configure these # TODO TODO: Just use shader-based lighting anyway. gl.glEnable(gl.GL_LIGHTING) gl.glEnable(gl.GL_LIGHT0) gl.glLightfv(gl.GL_LIGHT0, gl.GL_POSITION, (gl.GLfloat * 4)(0, 0, 100, 1))
def OnInitGL(self, call_reshape=True): '''Initialize OpenGL for use in the window.''' if self.GLinitialized: return self.GLinitialized = True # create a pyglet context for this panel self.pygletcontext = gl.Context(gl.current_context) self.pygletcontext.canvas = self self.pygletcontext.set_current() # normal gl init glClearColor(*self.color_background) glClearDepth(1.0) # set depth value to 1 glDepthFunc(GL_LEQUAL) glEnable(GL_COLOR_MATERIAL) glEnable(GL_DEPTH_TEST) glEnable(GL_CULL_FACE) glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) if call_reshape: self.OnReshape()
def OnInitGL(self, call_reshape = True): '''Initialize OpenGL for use in the window.''' if self.GLinitialized: return self.GLinitialized = True # create a pyglet context for this panel self.pygletcontext = gl.Context(gl.current_context) self.pygletcontext.canvas = self self.pygletcontext.set_current() # normal gl init glClearColor(*self.color_background) glClearDepth(1.0) # set depth value to 1 glDepthFunc(GL_LEQUAL) glEnable(GL_COLOR_MATERIAL) glEnable(GL_DEPTH_TEST) glEnable(GL_CULL_FACE) glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) if call_reshape: self.OnReshape()
def setup(self): self.camera = PlotCamera(self, ortho=self.ortho) self.controller = PlotController(self, invert_mouse_zoom=self.invert_mouse_zoom) self.push_handlers(self.controller) pgl.glClearColor(1.0, 1.0, 1.0, 0.0) pgl.glClearDepth(1.0) pgl.glDepthFunc(pgl.GL_LESS) pgl.glEnable(pgl.GL_DEPTH_TEST) pgl.glEnable(pgl.GL_LINE_SMOOTH) pgl.glShadeModel(pgl.GL_SMOOTH) pgl.glLineWidth(self.linewidth) pgl.glEnable(pgl.GL_BLEND) pgl.glBlendFunc(pgl.GL_SRC_ALPHA, pgl.GL_ONE_MINUS_SRC_ALPHA) if self.antialiasing: pgl.glHint(pgl.GL_LINE_SMOOTH_HINT, pgl.GL_NICEST) pgl.glHint(pgl.GL_POLYGON_SMOOTH_HINT, pgl.GL_NICEST) self.camera.setup_projection()
def render(self, position, chunk_meshes): gl.glViewport(0, 0, *self.size) gl.glDisable(gl.GL_BLEND) gl.glDisable(gl.GL_ALPHA_TEST) gl.glEnable(gl.GL_CULL_FACE) gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthFunc(gl.GL_LEQUAL) gl.glDepthMask(gl.GL_TRUE) x, y, z = position view_matrices = [ Matrix4.new_scale(-1, -1, 1).rotatey(pi / 2).translate(-x, -y, -z), # +X Matrix4.new_scale(-1, -1, 1).rotatey(-pi / 2).translate(-x, -y, -z), # -X Matrix4.new_rotatex(-pi / 2).translate(-x, -y, -z), # +Y Matrix4.new_rotatex(pi / 2).translate(-x, -y, -z), # -Y Matrix4.new_scale(-1, -1, 1).rotatey(pi).translate(-x, -y, -z), # +Z Matrix4.new_scale(-1, -1, 1).translate(-x, -y, -z) # -Z ] model_matrix = Matrix4.new_scale( 1, 1, constants.WALL_TEXTURE_HEIGHT / (constants.WALL_TEXTURE_WIDTH / sqrt(2) * (sqrt(3)))) gl.glUniformMatrix4fv(1, 1, gl.GL_FALSE, gl_matrix(model_matrix)) with self.program, self.name: view_matrix = make_view_matrix_persp(position) gl.glUniformMatrix4fv(0, 1, gl.GL_FALSE, gl_matrix(view_matrix)) for chunk, mesh in chunk_meshes.items(): mesh.draw()
def render(self, world_state, goals=[], time_step = None, wait=True): """" Renders the world state. Spawn a window if called for the first time. Parameters ---------- world_state: state of the world as an instance of `roboball2d.physics.world_state.WorldState` goals: list of tuple (x1, x2, (r,g,b)). For each item, a goal will be drawn on the ground, using the specified color time_step: allows to force a frame rate by either; - having rendering waiting a suitable amount of time (wait=True) or - skipping some frames (wait=False) wait: see time_step above """ if time_step is not None: # if wait : sleep the right amount of time such that the correct framerate is met # TODO: Does it make sense to wait before actually having rendered? This will result in a slower # framerate than desired. Should be right before self.window.flip() if wait: if self._t_last_frame is None: sleep_time = 0.0 else: sleep_time = max(0.0, time_step - (time.time() - self._t_last_frame)) time.sleep(sleep_time) self._t_last_frame = time.time() # if not wait : skipping frame if required else : t = time.time() if self._t_last_frame is None: self._t_last_frame = t if t-self._t_last_frame < time_step : return self._t_last_frame = t if self.window is None: self.window = pyglet.window.Window(width = self.rendering_config.window.width, height = self.rendering_config.window.height, vsync = False, resizable = True) self.window.set_location(self.rendering_config.location[0], self.rendering_config.location[1]) gl.glClearColor(*self.rendering_config.background_color) @self.window.event def on_resize(width, height): gl.glViewport(0, 0, width, height) gl.glMatrixMode(gl.GL_PROJECTION) gl.glLoadIdentity() gl.glOrtho(0., self.rendering_config.visible_area_width, -0.1*float(height)/width*self.rendering_config.visible_area_width, 0.9*float(height)/width*self.rendering_config.visible_area_width, -1., 1.) gl.glMatrixMode(gl.GL_MODELVIEW) return pyglet.event.EVENT_HANDLED self.window.clear() self.window.switch_to() self.window.dispatch_events() gl.glLoadIdentity() # enable depth test (objects with higher values of the z coordinate # will occlude other objects; if z coordinates are the same, newer # object will occlude older one) pyglet.graphics.glEnable(pyglet.graphics.GL_DEPTH_TEST) gl.glDepthFunc(gl.GL_LEQUAL) # balls if self.ball_configs: for ball,config in zip(world_state.balls,self.ball_configs): draw_ball(ball.position, ball.angle, config.radius, 16, config.color, config.line_color) # robots for robot in world_state.robots: robot.render() gl.glBegin(gl.GL_QUADS) gl.glColor3f(*self.rendering_config.ground_color) gl.glVertex2f(0., 0.) gl.glVertex2f(0., -10.) gl.glVertex2f(self.rendering_config.visible_area_width, -10.) gl.glVertex2f(self.rendering_config.visible_area_width, 0.) gl.glEnd() # goals (if any) for goal in goals: x1,x2,color = goal draw_box([(x1+x2)/2.0, -0.5*self.rendering_config.visual_height], max(x1,x2)-min(x1,x2), self.rendering_config.visual_height, 0., color) for callback in self._callbacks: callback(world_state) self.window.flip()
def init_gl(self): """ Perform the magic incantations to create an OpenGL scene. """ # default background color is white-ish background = [.99, .99, .99, 1.0] # if user passed a background color use it if 'background' in self.kwargs: try: # convert to (4,) uint8 RGBA background = to_rgba(self.kwargs['background']) # convert to 0.0 - 1.0 float background = background.astype(np.float64) / 255.0 except BaseException: log.error('background color wrong!', exc_info=True) # apply the background color gl.glClearColor(*background) max_depth = (np.abs(self.scene.bounds).max(axis=1)**2).sum()**.5 max_depth = np.clip(max_depth, 500.00, np.inf) gl.glDepthRange(0.0, max_depth) gl.glClearDepth(1.0) gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthFunc(gl.GL_LEQUAL) gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_CULL_FACE) gl.glEnable(gl.GL_LIGHTING) gl.glEnable(gl.GL_LIGHT0) gl.glEnable(gl.GL_LIGHT1) # put the light at one corner of the scenes AABB gl.glLightfv( gl.GL_LIGHT0, gl.GL_POSITION, rendering.vector_to_gl(np.append(self.scene.bounds[1], 0))) gl.glLightfv(gl.GL_LIGHT0, gl.GL_SPECULAR, rendering.vector_to_gl(.5, .5, 1, 1)) gl.glLightfv(gl.GL_LIGHT0, gl.GL_DIFFUSE, rendering.vector_to_gl(1, 1, 1, .75)) gl.glLightfv(gl.GL_LIGHT0, gl.GL_AMBIENT, rendering.vector_to_gl(.1, .1, .1, .2)) gl.glColorMaterial(gl.GL_FRONT_AND_BACK, gl.GL_AMBIENT_AND_DIFFUSE) gl.glEnable(gl.GL_COLOR_MATERIAL) gl.glShadeModel(gl.GL_SMOOTH) gl.glMaterialfv(gl.GL_FRONT, gl.GL_AMBIENT, rendering.vector_to_gl(0.192250, 0.192250, 0.192250)) gl.glMaterialfv(gl.GL_FRONT, gl.GL_DIFFUSE, rendering.vector_to_gl(0.507540, 0.507540, 0.507540)) gl.glMaterialfv(gl.GL_FRONT, gl.GL_SPECULAR, rendering.vector_to_gl(.5082730, .5082730, .5082730)) gl.glMaterialf(gl.GL_FRONT, gl.GL_SHININESS, .4 * 128.0) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnable(gl.GL_LINE_SMOOTH) gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST) gl.glLineWidth(1.5) gl.glPointSize(4)
def _initGL(self): gl.glClearColor(0.8, 0.8, 0.9, 0) gl.glClearDepth(1.0) # Enables Clearing Of The Depth Buffer gl.glDepthFunc(gl.GL_LESS) # The Type Of Depth Test To Do gl.glHint(gl.GL_PERSPECTIVE_CORRECTION_HINT, gl.GL_NICEST) # make stuff look nice gl.glEnable(gl.GL_LINE_SMOOTH) gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST) if self.anti_alias: gl.glLineWidth(0.1) else: gl.glLineWidth(1.0) #gl.glEnable(gl.GL_BLEND) #gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnable(gl.GL_DEPTH_TEST) # Enables Depth Testing gl.glEnable(gl.GL_LIGHTING) #gl.glEnable(gl.GL_NORMALIZE) #gl.glLightModeli(gl.GL_LIGHT_MODEL_TWO_SIDE, gl.GL_FALSE) if not gl.glUseProgram: print("Can't run shaders!") sys.exit(1) self.default_shader = compileProgram( compileShader( ''' varying vec3 vN; varying vec3 v; void main(void) { v = vec3(gl_ModelViewMatrix * gl_Vertex); vN = normalize(gl_NormalMatrix * gl_Normal); gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; } ''', gl.GL_VERTEX_SHADER), compileShader( ''' varying vec3 vN; varying vec3 v; #define MAX_LIGHTS 1 void main (void) { vec3 N = normalize(vN); vec4 finalColor = vec4(0.0, 0.0, 0.0, 0.0); for (int i=0;i<MAX_LIGHTS;i++) { vec3 L = normalize(gl_LightSource[i].position.xyz - v); vec3 E = normalize(-v); // we are in Eye Coordinates, so EyePos is (0,0,0) vec3 R = normalize(-reflect(L,N)); //calculate Ambient Term: vec4 Iamb = gl_FrontLightProduct[i].ambient; //calculate Diffuse Term: vec4 Idiff = gl_FrontLightProduct[i].diffuse * max(dot(N,L), 0.0); Idiff = clamp(Idiff, 0.0, 1.0); // calculate Specular Term: vec4 Ispec = gl_FrontLightProduct[i].specular * pow(max(dot(R,E),0.0),0.3*gl_FrontMaterial.shininess); Ispec = clamp(Ispec, 0.0, 1.0); finalColor += Iamb + Idiff + Ispec; } // write Total Color: gl_FragColor = gl_FrontLightModelProduct.sceneColor + finalColor; } ''', gl.GL_FRAGMENT_SHADER), ) self.cube_list = Cube().getVerticeList() self.coord_list = Coord().getVerticeList() self.grid_list = Grid().getVerticeList() # fill later self.mesh_lists = {} # type: Dict[str, Any]
and orientation on screen Found this code from: http://tartley.com/files/stretching_pyglets_wings/presentation/ """ from __future__ import division from math import sin, cos from pyglet.gl import ( glLoadIdentity, glMatrixMode, gluLookAt, gluOrtho2D, glDepthFunc, GL_MODELVIEW, GL_PROJECTION, GL_NEVER ) import pygsty.geometry glDepthFunc(GL_NEVER) class Target(object): def __init__(self, camera): self.x, self.y = camera.x, camera.y self.scale = camera.scale self.angle = camera.angle class Camera(object): def __init__(self, position=None, scale=None, angle=None): if position is None: position = (0, 0) self.x, self.y = position
def init_gl(self): """ Perform the magic incantations to create an OpenGL scene using pyglet. """ # default background color is white-ish background = [.99, .99, .99, 1.0] # if user passed a background color use it if 'background' in self.kwargs: try: # convert to (4,) uint8 RGBA background = to_rgba(self.kwargs['background']) # convert to 0.0 - 1.0 float background = background.astype(np.float64) / 255.0 except BaseException: log.error('background color set but wrong!', exc_info=True) # apply the background color gl.glClearColor(*background) # find the maximum depth based on # maximum length of scene AABB max_depth = (np.abs(self.scene.bounds).max(axis=1) ** 2).sum() ** .5 max_depth = np.clip(max_depth, 500.00, np.inf) gl.glDepthRange(0.0, max_depth) gl.glClearDepth(1.0) gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthFunc(gl.GL_LEQUAL) gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_CULL_FACE) # do some openGL things gl.glColorMaterial(gl.GL_FRONT_AND_BACK, gl.GL_AMBIENT_AND_DIFFUSE) gl.glEnable(gl.GL_COLOR_MATERIAL) gl.glShadeModel(gl.GL_SMOOTH) gl.glMaterialfv(gl.GL_FRONT, gl.GL_AMBIENT, rendering.vector_to_gl( 0.192250, 0.192250, 0.192250)) gl.glMaterialfv(gl.GL_FRONT, gl.GL_DIFFUSE, rendering.vector_to_gl( 0.507540, 0.507540, 0.507540)) gl.glMaterialfv(gl.GL_FRONT, gl.GL_SPECULAR, rendering.vector_to_gl( .5082730, .5082730, .5082730)) gl.glMaterialf(gl.GL_FRONT, gl.GL_SHININESS, .4 * 128.0) # enable blending for transparency gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) # make the lines from Path3D objects less ugly gl.glEnable(gl.GL_LINE_SMOOTH) gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST) # set the width of lines to 1.5 pixels gl.glLineWidth(1.5) # set PointCloud markers to 4 pixels in size gl.glPointSize(4) # set up the viewer lights using self.scene self.update_lighting()