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 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 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 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 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, 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()
