def bind_texture_region(texture, x, y, w, h, premultiplied=False, flip=False):
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER,
gl.GL_NEAREST)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_NEAREST)
gl.glEnable(gl.GL_SCISSOR_TEST)
gl.glEnable(gl.GL_BLEND)
if premultiplied:
gl.glBlendFunc(gl.GL_ONE, gl.GL_ONE_MINUS_SRC_ALPHA)
else:
gl.glBlendFuncSeparate(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA,
gl.GL_ONE, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
gl.glViewport(x, y, w, h)
gl.glScissor(x, y, w, h)
gl.glBindFramebufferEXT(gl.GL_DRAW_FRAMEBUFFER_EXT,
Manager.col_buffer.gl_buffer)
gl.glFramebufferTexture2DEXT(gl.GL_DRAW_FRAMEBUFFER_EXT,
gl.GL_COLOR_ATTACHMENT0_EXT, texture.target,
texture.id, 0)
gl.glMatrixMode(gl.GL_PROJECTION)
gl.glLoadIdentity()
if flip:
gl.gluOrtho2D(0, w, h, 0)
else:
gl.gluOrtho2D(0, w, 0, h)
def render(self):
"""Render all lights."""
gl.glEnable(gl.GL_TEXTURE_2D)
gl.glActiveTexture(gl.GL_TEXTURE0)
gl.glBindTexture(gl.GL_TEXTURE_2D, self.fbo.textures[0])
lighting_shader.bind()
lighting_shader.uniformi('diffuse_tex', 0)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_ONE, gl.GL_ONE)
vpw = self.viewport.w
vph = self.viewport.h
vpx, vpy = self.viewport.position
vpradius = sqrt(vpw * vpw + vph * vph) * 0.5
c = 0
for light in self.lights:
lx, ly = light.position
maxdist = light.radius + vpradius
dx = vpx - lx * self.tilew
dy = vpy - ly * self.tilew
dist = sqrt(dx * dx + dy * dy)
if dist < maxdist:
self.render_light(light)
c += 1
lighting_shader.unbind()
# Draw ambient using a full-screen quad
gl.glColor3f(*self.ambient)
self.viewport.draw_quad()
gl.glColor4f(1, 1, 1, 1)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
def main():
global gJoyStick
global show
gl.glClearColor(0.0, 0.0, 0.0, 0.0)
gl.glEnable( gl.GL_BLEND)
gl.glBlendFunc( gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
#pyglet.clock.set_fps_limit(60)
pyglet.clock.schedule_interval(update, 1/30.)
window.set_vsync(True)
for x in pyglet.input.get_joysticks():
#readStick(x)
pass
gJoyStick = pyglet.input.get_joysticks()[0]
gJoyStick.open()
for x in gJoyStick.device.get_controls():
#print x
pass
if len(sys.argv) > 1 and sys.argv[1] == '-b':
show = 'buttons'
else:
show = 'axes'
pyglet.app.run()
print ""
def setup():
""" Basic OpenGL configuration.
"""
# Set the color of "clear", i.e. the sky, in rgba.
gl.glClearColor(0.5, 0.69, 1.0, 1)
# Enable culling (not rendering) of back-facing facets -- facets that aren't
# visible to you.
gl.glEnable(gl.GL_CULL_FACE)
#gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_DST_ALPHA)
#gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glBlendFunc(gl.GL_ZERO, gl.GL_SRC_COLOR)
gl.glEnable(gl.GL_BLEND)
gl.glAlphaFunc(gl.GL_GREATER, 0.5);
gl.glEnable(gl.GL_ALPHA_TEST);
# Set the texture minification/magnification function to GL_NEAREST (nearest
# in Manhattan distance) to the specified texture coordinates. GL_NEAREST
# "is generally faster than GL_LINEAR, but it can produce textured images
# with sharper edges because the transition between texture elements is not
# as smooth."
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST)
gl.glTexEnvi(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_MODULATE)
setup_fog()
def setupOpenGL(self): gl.glClearColor(0., 0., 0., 1.) gl.glColor4f(1.0, 0.0, 0.0, 0.5) gl.glEnable(gl.GL_DEPTH_TEST) #gl.glEnable(gl.GL_CULL_FACE) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
def on_draw():
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
# Gradient sky
l, b = world_to_screen((0, 0))
r, t = world_to_screen((W, H))
horizon = 177 / 255.0, 202 / 255.0, 1.0
zenith = 68 / 255.0, 0.5, 1.0
pyglet.graphics.draw(4, gl.GL_QUADS,
('v2f', [l, b, l, t, r, t, r, b]),
('c3f', sum([horizon, zenith, zenith, horizon], ())),
)
cx, cy = camera
tx, ty = world_to_screen((-cx + W * 0.5, -cy + H * 0.5))
gl.glTranslatef(tx, ty, 0)
batch.draw()
# Water
l, b = world_to_screen((0, 0))
r, t = world_to_screen((1000, WATER_LEVEL))
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
pyglet.graphics.draw(4, gl.GL_QUADS,
('v2f', [l, b, l, t, r, t, r, b]),
('c4f', [0, 0.2, 0.8, 0.5] * 4),
)
def draw(self, delta):
if len(self._queue) == 0:
return
# self.clear_screen()
self.setup_shader_program_if_needed()
for layer in self._queue:
if len(layer._queue) == 0 or not layer.visible:
continue
if layer.vao is None:
layer.rasterize()
layer.gl_texture.use(1)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
with layer.vao:
self.program['Texture'] = 1 # self.texture_id
self.program['Projection'] = get_projection().flatten()
layer.gl_data_buf.write(layer.sprite_data)
layer.vao.render(gl.GL_TRIANGLE_STRIP,
instances=len(layer._queue))
layer.gl_data_buf.orphan()
layer.visible = False
layer.vao = None
def __init__(self, rows, columns, n_apples, *args, **kwargs):
super(PygletEngine, self).__init__(rows, columns, n_apples, *args, **kwargs)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
pyglet.clock.schedule_interval(lambda t: self.update_snakes(), 1/30.0)
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 interact(bld, fullscreen=False): # pragma: no cover
"""Interact with the billiard simulation.
Args:
bld: A billiard simulation.
fullscreen (optional): Set window to fullscreen, defaults to False.
"""
# print instructions
print("Play/Pause: Space, move: WASD, zoom: QE, simspeed: RF, exit: Esc")
# create window
window = BilliardWindow(bld, width=800, height=600, resizable=True)
if fullscreen:
window.set_fullscreen()
# OpenGL settings for high quality line drawing
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(pyglet.gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST)
gl.glLineWidth(2)
# show window, start simulation
pyglet.app.run()
def render_skybox(self):
import pyglet.gl as gl
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
tex = self.skyboxTexture
vs = \
( # vertices are represented as 2 element floats
self._anchorX, self._anchorY,
(self._width + self._anchorX), self._anchorY,
(self._width + self._anchorX), (self._height + self._anchorY),
self._anchorX, (self._height + self._anchorY),
)
#divide the skybox into 360 degrees horizontally and 180 vertically
#calculate the amount of skybox to display based on FOV:
hRat = self.camera.FOV / 2 / 360
vRat = np.arctan(np.tan(hRat * 2 * np.pi) * self._height / self._width)
ts = \
( # texture coordinates as a float,
0.0, 0.5,
1.0, 0.5,
1.0, 0.0,
0.0, 0.0,
)
vList = pyglet.graphics.vertex_list(4, ('v2f', vs), ('t2f', ts))
gl.glEnable(gl.GL_TEXTURE_2D)
gl.glBindTexture(gl.GL_TEXTURE_2D, tex.id)
vList.draw(pyglet.gl.GL_QUADS)
gl.glDisable(gl.GL_TEXTURE_2D)
def __init__(self):
super().__init__(resizable=True)
self.maximize()
self.set_minimum_size(*const.MAIN_MIN_SIZE)
self.set_caption(const.MAIN_TITLE)
# Blend alpha so that the more shapes overlap, the less transparent the intersection area.
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
pyglet.clock.set_fps_limit(const.FPS)
self.items = [] # All items rendered within this window
self.dragged_items = [] # Items being dragged at the moment
self.move_vectors = {} # Vectors for random movement
self.fullscreen_flag = False
self.multidrag_flag = True # Whether all overlapping items or only the uppermost one should be dragged.
self.random_move_flag = False # Whether shapes should be automatically moved
self.creation_flags = const.CREATE_NONE
# This will be popped off when needed
self.push_handlers(on_mouse_press=self.select_items,
on_mouse_drag=self.drag_items,
on_mouse_release=self.release_items)
self.push_handlers(on_mouse_press=self.check_buttons)
self.update_buttons()
def draw(self, frame):
# The gneneral plan here is:
# 1. Get the dots in the range of 0-255.
# 2. Create a texture with the dots data.
# 3. Draw the texture, scaled up with nearest-neighbor.
# 4. Draw a mask over the dots to give them a slightly more realistic look.
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glLoadIdentity()
# Draw the dots in this color:
#gl.glColor3f(1.0, 0.5, 0.25)
gl.glScalef(1, -1, 1)
gl.glTranslatef(0, -DMD_SIZE[1]*DMD_SCALE, 0)
#data = frame.get_data_mult()
#this new jk_get_data will read the dots using the dmd function
#and convert them via the map to rGB.
data = self.jk_get_data(frame)
image = pyglet.image.ImageData(DMD_SIZE[0], DMD_SIZE[1], 'RGB', data, pitch=DMD_SIZE[0] * 3)
gl.glTexParameteri(image.get_texture().target, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST)
image.blit(0, 0, width=DMD_SIZE[0]*DMD_SCALE, height=DMD_SIZE[1]*DMD_SCALE)
del image
gl.glScalef(DMD_SCALE/float(MASK_SIZE), DMD_SCALE/float(MASK_SIZE), 1.0)
gl.glColor4f(1.0, 1.0, 1.0, 1.0)
self.mask_texture.blit_tiled(x=0, y=0, z=0, width=DMD_SIZE[0]*MASK_SIZE, height=DMD_SIZE[1]*MASK_SIZE)
def __init__(self):
super(Evolves, self).__init__(caption="Evolves 2008",
width=100, height=100)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
self.setup()
def __init__(self, x=500, y=500, visible=False):
super(Drawer, self).__init__(x, y)
self.set_visible(visible)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
self.main_batch = pyglet.graphics.Batch()
self.scrot_name = None
def init(cls, caption: str, vsync: bool, w: int, h: int):
cls.window = pyglet.window.Window(caption=caption,
vsync=vsync,
width=w,
height=h)
cls.window.push_handlers(cls.keys)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glEnable(pyglet.gl.GL_ALPHA_TEST)
glAlphaFunc(pyglet.gl.GL_GREATER, .1)
cls.window.on_draw = cls.on_draw
from gameengine.managers.InputManager import InputManager
cls.window.on_mouse_motion = InputManager().on_mouse_motion
cls.window.on_mouse_press = InputManager().on_mouse_press
cls.window.on_mouse_release = InputManager().on_mouse_release
cls.window.on_mouse_drag = InputManager().on_mouse_drag
cls.window.on_mouse_scroll = InputManager().on_mouse_scroll
cls.window.on_key_press = InputManager().on_key_press
cls.window.on_key_release = InputManager().on_key_release
cls.fps_display = pyglet.window.FPSDisplay(cls.window)
def draw_ellipse_filled(center_x: float, center_y: float,
width: float, height: float, color: Color,
tilt_angle: float = 0):
num_segments = 128
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.glHint(gl.GL_POLYGON_SMOOTH_HINT, gl.GL_NICEST)
gl.glLoadIdentity()
gl.glTranslatef(center_x, center_y, 0)
gl.glRotatef(tilt_angle, 0, 0, 1)
# Set color
if len(color) == 4:
gl.glColor4ub(color[0], color[1], color[2], color[3])
elif len(color) == 3:
gl.glColor4ub(color[0], color[1], color[2], 255)
gl.glBegin(gl.GL_TRIANGLE_FAN)
gl.glVertex3f(0, 0, 0.5)
for segment in range(num_segments + 1):
theta = 2.0 * 3.1415926 * segment / num_segments
x = width * math.cos(theta)
y = height * math.sin(theta)
gl.glVertex3f(x, y, 0.5)
gl.glEnd()
gl.glLoadIdentity()
def on_draw(self):
"""Redraw the current image."""
# the pyglet.window docs specify:
# > The window will already have the GL context, so there is no need to
# > call `.switch_to`. The window’s `.flip` method will be called after
# > this event, so your event handler should not.
# self.switch_to()
# gl.glClearColor(0, 0, 0, 0)
self.clear()
if hasattr(self, 'texture'):
# do not interpolate when resizing textures
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_NEAREST)
# textures with alpha channels require gl blending capability
gl.glEnable(gl.GL_BLEND)
# Additive blending `R = S * F_s + D * F_d` for `c4f` f-RGBA
gl.glBlendEquation(gl.GL_FUNC_ADD)
# Factors `F_s = S_a` and `F_d = 1 - S_a` give transparency fx,
# >>> gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
# but we set `F_s = 1.` and `F_d = 0.` for complete overwrite.
# see https://learnopengl.com/Advanced-OpenGL/Blending
# and https://www.khronos.org/opengl/wiki/Blending
# and https://stackoverflow.com/a/18497511 (for opacity eqn)
gl.glBlendFunc(gl.GL_ONE, gl.GL_ZERO)
# draw the image data into the window's buffer as a texture
# blit transforms the texture data only virtually: the texture's
# `.width` and `.height` dims still retain original array's shape.
self.texture.blit(0, 0, width=self.width, height=self.height)
def setup():
""" Basic OpenGL configuration.
"""
# Set the color of "clear", i.e. the sky, in rgba.
gl.glClearColor(0.5, 0.69, 1.0, 1)
# Enable culling (not rendering) of back-facing facets -- facets that aren't
# visible to you.
gl.glEnable(gl.GL_CULL_FACE)
#gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_DST_ALPHA)
#gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glBlendFunc(gl.GL_ZERO, gl.GL_SRC_COLOR)
gl.glEnable(gl.GL_BLEND)
gl.glAlphaFunc(gl.GL_GREATER, 0.5)
gl.glEnable(gl.GL_ALPHA_TEST)
# Set the texture minification/magnification function to GL_NEAREST (nearest
# in Manhattan distance) to the specified texture coordinates. GL_NEAREST
# "is generally faster than GL_LINEAR, but it can produce textured images
# with sharper edges because the transition between texture elements is not
# as smooth."
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER,
gl.GL_NEAREST)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_NEAREST)
gl.glTexEnvi(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_MODULATE)
setup_fog()
def __init__(self, *args, **kwargs):
super(VIctorApp, self).__init__(640, 400, caption="victor")
self.set_default_options()
self.mode = vmode.NORMAL
self.down_action = None
self.text_event = None
self.batch = pyglet.graphics.Batch()
self.setup_cursor()
self.marks = dict()
self.command_area = CommandArea(0, 0, 550, self.batch)
self.keystrokes = Keystrokes(550, 0, 70, self.batch)
self.current_multiplier = None
self.normal_dispatcher = vnd.construct_dispatcher(self)
self.set_ex_commands()
self.groups = self.current_group = PathGroup()
self.current_path = None
self.time = time.time()
pyglet.clock.schedule_interval(self.on_timer_fire, 0.05)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnable(gl.GL_BLEND)
def __init__(self, *args, **kwargs):
pyglet.window.Window.__init__(self, *args, **kwargs)
self.set_exclusive_keyboard(False)
pyglet.clock.schedule_interval(lambda _: None, 0)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
self.states = [MainMenu(self)] #PlayLevel(self,*GRID_SIZE)
def on_resize(width, height):
pgl.glBlendFunc(pgl.GL_SRC_ALPHA, pgl.GL_ONE_MINUS_SRC_ALPHA)
pgl.glViewport(0, 0, 400, 400)
#pgl.glEnable(pgl.GL_CULL_FACE)
pgl.glScalef(100, 100, 0.01)
pgl.glTranslatef(2, 2, 2)
pgl.glRotatef(10, 0, 0, 1)
def draw(self, scale, pos):
LINE_COLOUR = (255, 255, 255)
#gl.glEnable(gl.GL_DEPTH_TEST);
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_DONT_CARE)
gl.glBegin(gl.GL_LINES)
for link in self.links:
if link.highlight:
gl.glColor3ub(*self.colour)
gl.glColor3ub(*self.colour)
else:
gl.glColor3ub(*LINE_COLOUR)
gl.glColor3ub(*LINE_COLOUR)
if link.highlight:
depth = 0.5
else:
depth = 0.5
gl.glVertex3f(
*util.add_tup(pos, util.scale_tup(link.points[0].pos, scale)) +
(depth, ))
gl.glVertex3f(
*util.add_tup(pos, util.scale_tup(link.points[1].pos, scale)) +
(depth, ))
print util.add_tup(pos, util.scale_tup(link.points[0].pos, scale))
gl.glEnd()
def draw(self):
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glColor4f(*(list(SELECTED_COLOUR) + [0.5]))
self.inner_circle.draw()
gl.glColor3f(*SELECTED_COLOUR)
self.circle.draw()
pyglet.graphics.draw(
len(self.vs) // 2,
gl.GL_LINES,
('v2f', self.vs),
)
if self.angle is not None:
centre = self.circle.centre
radius = self.circle.radius
l = 10
avs = list(
walk([
centre + v(radius + 4, 0).rotated(self.angle),
centre + v(radius + 4 + l, 0).rotated(self.angle)
]))
pyglet.graphics.draw(
2,
gl.GL_LINES,
('v2f', avs),
)
pos = centre + v(radius + 6 + l, 0).rotated(self.angle)
self.label.x, self.label.y = pos
self.label.anchor_x = 'right' if self.label.x < centre.x else 'left'
self.label.draw()
self.label.draw() # Draw twice because it doesn't come out well
def draw(self):
if self._dirty:
self._context = Context()
self._parts = []
self.free()
self.render()
self.build_vbo()
self._dirty = False
# set
gl.glEnable(self._texture.target)
gl.glBindTexture(self._texture.target, self._texture.id)
gl.glPushAttrib(gl.GL_COLOR_BUFFER_BIT)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glPushMatrix()
self.transform()
# cuadric.begin()
self._vertex_list.draw(gl.GL_TRIANGLES)
# cuadric.end()
# unset
gl.glPopMatrix()
gl.glPopAttrib()
gl.glDisable(self._texture.target)
def write_text(self, text):
#gl.glTexEnvf( gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_MODULATE )
#gl.glEnable( gl.GL_DEPTH_TEST )
gl.glEnable(gl.GL_BLEND)
#gl.glEnable( gl.GL_COLOR_MATERIAL )
#gl.glColorMaterial( gl.GL_FRONT_AND_BACK, gl.GL_AMBIENT_AND_DIFFUSE )
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnable(gl.GL_TEXTURE_2D)
gl.glBindTexture(gl.GL_TEXTURE_2D, self.texture_id)
gl.glColor4f(1, 1, 0, 1)
gl.glPushMatrix()
gl.glLoadIdentity()
gl.glScalef(0.003, 0.003, 0)
#gl.glTranslatef(10, 100, 0)
gl.glPushMatrix()
gl.glListBase(self.base)
gl.glCallLists(len(text), gl.GL_UNSIGNED_BYTE, bytes(text, 'utf-8'))
#for c in text:
# gl.glCallList(self.base + 1 + ord(c))
gl.glPopMatrix()
gl.glPopMatrix()
gl.glDisable(gl.GL_BLEND)
gl.glDisable(gl.GL_TEXTURE_2D)
def draw(self):
if len(self.sprite_list) == 0:
return
if self.vao is None:
self.calculate_sprite_buffer()
self.texture.use(0)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
# gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST)
# gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST)
with self.vao:
self.program['Texture'] = self.texture_id
self.program['Projection'] = get_projection().flatten()
if self.ambient_light is not None and self.light_list is not None:
light_data = []
for light in self.light_list:
light_data.append(light.x)
light_data.append(light.y)
self.program['point_light'] = light_data
if not self.is_static:
self.sprite_data_buf.write(self.sprite_data.tobytes())
self.vao.render(gl.GL_TRIANGLE_STRIP, instances=len(self.sprite_list))
if not self.is_static:
self.sprite_data_buf.orphan()
def render(shape: VertexBuffer):
"""
Render an shape previously created with a ``create`` function.
"""
# Set color
if shape.color is None:
raise ValueError("Error: Color parameter not set.")
gl.glLoadIdentity()
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, shape.vbo_vertex_id)
gl.glVertexPointer(2, gl.GL_FLOAT, 0, 0)
if shape.line_width:
gl.glLineWidth(shape.line_width)
if len(shape.color) == 4:
gl.glColor4ub(shape.color[0], shape.color[1], shape.color[2],
shape.color[3])
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
elif len(shape.color) == 3:
gl.glDisable(gl.GL_BLEND)
gl.glColor4ub(shape.color[0], shape.color[1], shape.color[2], 255)
gl.glDrawArrays(shape.draw_mode, 0, shape.size)
def set_state(self):
"""
Ensure that blending is set.
"""
gl.glPushAttrib(gl.GL_ENABLE_BIT | gl.GL_CURRENT_BIT)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
def draw(self):
""" Draw this list of sprites. """
if self.program is None:
# Used in drawing optimization via OpenGL
self.program = shader.program(vertex_shader=VERTEX_SHADER,
fragment_shader=FRAGMENT_SHADER)
if len(self.sprite_list) == 0:
return
if self.vao is None:
self._calculate_sprite_buffer()
self._texture.use(0)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
# gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST)
# gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST)
with self.vao:
self.program['Texture'] = self.texture_id
self.program['Projection'] = get_projection().flatten()
if not self.is_static:
self.sprite_data_buf.write(self.sprite_data.tobytes())
self.vao.render(gl.GL_TRIANGLE_STRIP,
instances=len(self.sprite_list))
if not self.is_static:
self.sprite_data_buf.orphan()
def draw(self, scale, pos):
LINE_COLOUR = (255, 255, 255)
# gl.glEnable(gl.GL_DEPTH_TEST);
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_DONT_CARE)
gl.glBegin(gl.GL_LINES)
for link in self.links:
if link.highlight:
gl.glColor3ub(*self.colour)
gl.glColor3ub(*self.colour)
else:
gl.glColor3ub(*LINE_COLOUR)
gl.glColor3ub(*LINE_COLOUR)
if link.highlight:
depth = 0.5
else:
depth = 0.5
gl.glVertex3f(*util.add_tup(pos, util.scale_tup(link.points[0].pos, scale)) + (depth,))
gl.glVertex3f(*util.add_tup(pos, util.scale_tup(link.points[1].pos, scale)) + (depth,))
print util.add_tup(pos, util.scale_tup(link.points[0].pos, scale))
gl.glEnd()
def __init__(self):
self._width = 800
self._height = 600
super().__init__(width=self._width,
height=self._height,
resizable=False,
vsync=False)
self._mouse = Mouse()
self._debug = False
try:
if os.environ['DEBUG'] in ('1', 'TRUE', 'True'):
self.push_handlers(pyglet.window.event.WindowEventLogger())
self._debug = True
except KeyError:
pass
glClearColor(0.0, 0.05, 0.2, 1.0)
glEnable(GL_BLEND)
glBlendFunc(GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA)
self._gc = GraphicsContext()
pyglet.clock.schedule_interval(self._main_loop, 1 / 60)
self.set_mouse_visible(False)
def set_state(self):
"""
Ensure that blending is set.
"""
gl.glPushAttrib(gl.GL_ENABLE_BIT | gl.GL_CURRENT_BIT)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
def init_gl(self):
gl.glClearColor(.93, .93, 1, 1)
#glColor3f(1, 0, 0)
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)
gl.glLightfv(gl.GL_LIGHT0, gl.GL_POSITION, _gl_vector(.5, .5, 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, 1))
gl.glLightfv(gl.GL_LIGHT1, gl.GL_POSITION, _gl_vector(1, 0, .5, 0))
gl.glLightfv(gl.GL_LIGHT1, gl.GL_DIFFUSE, _gl_vector(.5, .5, .5, 1))
gl.glLightfv(gl.GL_LIGHT1, gl.GL_SPECULAR, _gl_vector(1, 1, 1, 1))
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)
def init_gl(self):
gl.glClearColor(.93, .93, 1, 1)
# glColor3f(1, 0, 0)
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)
gl.glLightfv(gl.GL_LIGHT0, gl.GL_POSITION, _gl_vector(.5, .5, 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, 1))
gl.glLightfv(gl.GL_LIGHT1, gl.GL_POSITION, _gl_vector(1, 0, .5, 0))
gl.glLightfv(gl.GL_LIGHT1, gl.GL_DIFFUSE, _gl_vector(.5, .5, .5, 1))
gl.glLightfv(gl.GL_LIGHT1, gl.GL_SPECULAR, _gl_vector(1, 1, 1, 1))
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)
def draw(self):
if self._dirty:
self._context = Context()
self._parts = []
self.free()
self.render()
self.build_vbo()
self._dirty = False
# set
gl.glEnable(self._texture.target)
gl.glBindTexture(self._texture.target, self._texture.id)
gl.glPushAttrib(gl.GL_COLOR_BUFFER_BIT)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glPushMatrix()
self.transform()
# cuadric.begin()
self._vertex_list.draw(gl.GL_TRIANGLES)
# cuadric.end()
# unset
gl.glPopMatrix()
gl.glPopAttrib()
gl.glDisable(self._texture.target)
def on_draw(self):
gl.glClearColor(0, 0.0, 0.0, 1.)
self.clear()
width, height = self.get_size()
gl.glViewport(0, 0, width, height)
K_gl = get_projector_gl_intrinsics()
TF = get_extrinsics()
R = np.array([[-1., 0., 0., 0.], [0., 1., 0., 0.], [0., 0., -1., 0.],
[0., 0., 0., 1.]])
full_mat = np.ascontiguousarray((K_gl.dot(TF.dot(R))).astype('f4'))
with self.prog.using():
self.prog.uniforms.Mvp = full_mat.tolist()
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glPointSize(25.)
distance = (0, 0, 1)
gl.glPointParameterfv(gl.GL_POINT_DISTANCE_ATTENUATION,
(gl.GLfloat * 3)(*distance))
gl.glEnable(gl.GL_POINT_SPRITE)
self.vertex_info.draw(gl.GL_POINTS)
gl.glMatrixMode(gl.GL_PROJECTION)
gl.glLoadIdentity()
gl.glOrtho(0, width, 0, height, -1, 1)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
gl.glMatrixMode(gl.GL_TEXTURE)
gl.glLoadIdentity()
gl.glDisable(gl.GL_DEPTH_TEST)
gl.glDisable(gl.GL_BLEND)
self.fps_display.draw()
def __init__(self,
name: str,
width: int,
height: int,
resizable: bool = False,
game: BaseGame = None,
data: BaseData = None):
super(Window, self).__init__(width, height, resizable=resizable)
glEnable(GL_DEPTH_TEST)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glClearColor(0, 0, 0, 1)
# glEnable(GL_CULL_FACE)
self.name = name
self.num_frames = 0
self.start_time = datetime.now()
self.frame_start_time = datetime.now()
self.projection_matrix = identity()
if game is None:
game = BaseGame()
self.game = game
self.game.init()
if data is None:
data = BaseData()
self.data = data
def __init__(self, width=600, height=400, display=None):
display = self._get_display(display)
super().__init__(width=width, height=height, display=display)
self.model = None
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
def show(self):
self.generate(600,400)
self.window = pyglet.window.Window(self.image.width,self.image.height)
gl.glClearColor(0,0,0,1)
gl.glBlendFunc (gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnable(gl.GL_BLEND)
self.window.push_handlers(self)
pyglet.app.run()
def _InitGLState(self):
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_ONE, gl.GL_ONE)
gl.glEnable(gl.GL_TEXTURE_2D)
gl.glShadeModel(gl.GL_SMOOTH)
gl.glClearColor(0, 0, 0, 1)
# Rotated images can have a z-distance of more than one
gl.glDepthRangef(0, 2)
