def run(self):
"""Main loop"""
glfw.set_time(0) # resets the GLFW timer to 0
t = 0.0 # timer to redraw the graphics at regular intervals
while not glfw.window_should_close(self.win) and not self.exit_now:
# Update every x seconds
curr_time = glfw.get_time()
if curr_time - t > 0.1: # change 0.1 to adjust the rendering frame rate
# Update time
t = curr_time
# Clear and get ready for the next frame
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
# Build projection matrix
p_matrix = glutils.perspective(45.0, self.aspect, 0.1, 100.0)
mv_matrix = glutils.lookAt(
[0.0, 0.0, -2.0], [0.0, 0.0, 0.0], [0.0, 1.0, 0.0])
# render
self.scene.render(p_matrix, mv_matrix)
self.scene.step()
glfw.swap_buffers(self.win)
# Checks for any UI events
glfw.poll_events()
glfw.terminate()
def run(self):
# initializer timer
glfw.set_time(0.0)
t = 0.0
while not glfw.window_should_close(self.win) and not self.exitNow:
# update every x seconds
currT = glfw.get_time()
if currT - t > 0.1:
# update time
t = currT
# clear
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
# build projection matrix
pMatrix = glutils.perspective(45.0, self.aspect, 0.1, 100.0)
mvMatrix = glutils.lookAt([0.0, 0.0, -2.0], [0.0, 0.0, 0.0],
[0.0, 1.0, 0.0])
# render
self.scene.render(pMatrix, mvMatrix)
# step
self.scene.step()
glfw.swap_buffers(self.win)
# Poll for and process events
glfw.poll_events()
# end
glfw.terminate()
def pasa_dia(self):
glfw.set_time(0)
print('Día', self.est.dias[-1])
self.est.dias.append(self.est.dias[-1] + 1)
numero_enfermos = 0
for k in self.personas:
if k.estado == 'Enferma':
for e in self.personas:
if e.estado == 'Sana' and k.esta_en_radio(
e, self.radio) and random.random() < self.prob:
e.estado = 'Contagiada'
e.enfermar()
numero_enfermos += 1
k.pos[0] = k.pos[1]
x = k.pos[0][0] + 0.2 * random.uniform(-1, 1)
y = k.pos[0][1] + 0.2 * random.uniform(-1, 1)
if x > 0.95:
x = 0.95
if x < -0.95:
x = -0.95
if y > 0.95:
y = 0.95
if y < -0.95:
y = -0.95
#k.model.transform = tr.translate(x, y,0)
k.pos[1] = [x, y]
self.s = 0
for k in self.personas:
if k.estado == 'Contagiada':
k.estado = 'Enferma'
self.est.enfermos.append(self.est.enfermos[-1] + numero_enfermos)
def toggle_playing():
global state
if state == 1:
state = 2
glfw.set_time(0.0)
elif state == 2:
state = 1
def on_key(self, _win, key, _scancode, action, _mods):
""" 'Q' or 'Escape' quits """
if action == glfw.PRESS or action == glfw.REPEAT:
if key == glfw.KEY_ESCAPE or key == glfw.KEY_Q:
glfw.set_window_should_close(self.win, True)
if key == glfw.KEY_W:
GL.glPolygonMode(GL.GL_FRONT_AND_BACK, next(self.fill_modes))
if key == glfw.KEY_SPACE: glfw.set_time(0)
def on_key(self, _win, key, _scancode, action, _mods):
""" 'Q' or 'Escape' quits """
if action == glfw.PRESS or action == glfw.REPEAT:
if key == glfw.KEY_ESCAPE:
glfw.set_window_should_close(self.win, True)
if key == glfw.KEY_SPACE: # space resets the time
glfw.set_time(0)
if key == glfw.KEY_M: # change view mode with M
GL.glPolygonMode(GL.GL_FRONT_AND_BACK, next(self.fill_modes))
def do_for_each_drawable(self, drawable, view, projection, model, **param):
drawable.draw(projection,
view,
model,
self.shaders,
color=(1, 0, 1),
win=self.win,
**param)
if glfw.get_key(self.win, glfw.KEY_F2) == glfw.PRESS:
glfw.set_time(0)
def __init__(
self,
size_pix=(760, 760),
colour=(0.5, 0.5, 0.5),
event_buffer_size=20,
gamma=None,
close_on_exit=True,
global_quit=True,
):
self._global_quit = global_quit
self.close_on_exit = close_on_exit
self._event_buffer = collections.deque(maxlen=event_buffer_size)
glfw.init()
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, 1)
glfw.window_hint(glfw.DOUBLEBUFFER, glfw.TRUE)
self.monitor = glfw.get_primary_monitor()
self._orig_gamma = glfw.get_gamma_ramp(self.monitor)
if gamma is not None:
glfw.set_gamma(monitor=self.monitor, gamma=gamma)
self.win = glfw.create_window(
width=size_pix[0],
height=size_pix[1],
title="window",
monitor=None,
share=None,
)
glfw.make_context_current(self.win)
glfw.swap_interval(0)
glfw.set_key_callback(self.win, self.key_event_callback)
glfw.set_window_close_callback(self.win, self.window_close_callback)
self.colour = colour
self.flip()
glfw.set_time(0.0)
self.nests = 0
def run(self):
glfw.set_time(0.0)
t = 0.0
while not glfw.window_should_close(self.window) and not self.exitNow:
currT = glfw.get_time()
if currT - t > 1.0 / self.frame_rate:
t = currT
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
self.scene.render()
glfw.swap_buffers(self.window)
glfw.poll_events()
glfw.terminate()
def draw(self, projection, view, model, win, **param):
""" When redraw requested, interpolate our node transform from keys """
if glfw.get_key(win, glfw.KEY_SPACE) == glfw.PRESS:
glfw.set_time(0)
self.passedTime = 0
currentTime = glfw.get_time() - self.passedTime
if self.resetTime != None and currentTime >= self.resetTime:
self.passedTime = glfw.get_time()
currentTime = 0
self.transform = self.keyframes.value(currentTime)
super().draw(projection, view, model, **param)
def key_callback(self, window, key, scancode, action, mode):
if key == glfw.KEY_ESCAPE and action == glfw.PRESS:
glfw.set_window_should_close(window, GL_TRUE)
if key == glfw.KEY_SPACE and action == glfw.PRESS:
self.reset_game(self.ball)
if key == glfw.KEY_A or key == glfw.KEY_D:
if action == glfw.PRESS:
glfw.set_time(0)
self.platform.curr_movement = self.platform.LEFT if key == glfw.KEY_A else self.platform.LEFT
elif action == glfw.RELEASE:
self.platform.curr_movement = self.platform.STOP
def on_key(self, _win, key, _scancode, action, _mods):
""" 'Q' or 'Escape' quits """
if action == glfw.PRESS or action == glfw.REPEAT:
if key == glfw.KEY_ESCAPE or key == glfw.KEY_Q:
glfw.set_window_should_close(self.win, True)
if key == glfw.KEY_W:
GL.glPolygonMode(GL.GL_FRONT_AND_BACK, next(self.fill_modes))
if key == glfw.KEY_R:
os.system("pkill aplay")
os.system("aplay T-Rex.wav &")
glfw.set_time(0)
if key == glfw.KEY_N:
self.normal_mapping = 1 - self.normal_mapping
def next_frame():
global current_frame
if state == 1:
if len(points) > (current_frame + 1):
current_frame = current_frame + 1
else:
points.append([])
current_frame = current_frame + 1
elif state == 2:
glfw.set_time(0.0)
if len(points) > (current_frame + 1):
current_frame = current_frame + 1
else:
current_frame = 0
def on_key(self, _win, key, _scancode, action, _mods):
""" 'Q' or 'Escape' quits """
if action == glfw.PRESS or action == glfw.REPEAT:
if key == glfw.KEY_ESCAPE or key == glfw.KEY_Q:
glfw.set_window_should_close(self.win, True)
if key == glfw.KEY_W:
GL.glPolygonMode(GL.GL_FRONT_AND_BACK, next(self.fill_modes))
if key == glfw.KEY_SPACE:
glfw.set_time(0)
if key == glfw.KEY_UP:
print("up")
print(self.trackball.pos2d)
print(self.trackball.distance)
print(self.trackball.view_matrix())
self.drawables[0].set_z()
self.trackball.zoom(0.1, glfw.get_window_size(_win)[1])
def on_key(self, _win, key, _scancode, action, _mods):
""" 'Q' or 'Escape' quits """
if action == glfw.PRESS or action == glfw.REPEAT:
if key == glfw.KEY_ESCAPE or key == glfw.KEY_Q:
glfw.set_window_should_close(self.win, True)
if key == glfw.KEY_W:
GL.glPolygonMode(GL.GL_FRONT_AND_BACK, next(self.fill_modes))
if key == glfw.KEY_SPACE:
glfw.set_time(0.0)
if key == glfw.KEY_A:
AL.oalQuit()
if key == glfw.KEY_S:
source = AL.oalOpen("lotr.wav")
source.play()
# call Node.key_handler which calls key_handlers for all drawables
self.key_handler(key)
def run(self):
glfw.set_time(0)
glClearColor(1,1,1,1)
lastT = glfw.get_time()
frames = 0
while not glfw.window_should_close(self.win) and not self.exitNow:
currT = glfw.get_time()
if frames == 20:
elapsed = currT - lastT
print('fps = {}'.format(frames/elapsed))
lastT = currT
frames = 0
self.scene.render_shading()
frames += 1
glfw.swap_buffers(self.win)
glfw.poll_events()
glfw.terminate()
def run(self):
global p2, v, w, tp, sp
# initializer timer
glfw.set_time(0.0)
t = 0.0
while not glfw.window_should_close(self.window) and not self.exitNow:
# update every x seconds
currT = glfw.get_time()
if currT - t > 1.0 / self.frame_rate:
# update time
t = currT
# clear
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
# render scene
if holdstateL == True:
p2 = glfw.get_cursor_pos(self.window)
p2 = self.projectOnSphere(p2[0], p2[1], self.r)
v = np.cross(p1, p2)
w = np.arccos(np.dot(p1, p2))
if holdstateR == True:
tp = np.array(glfw.get_cursor_pos(self.window))
tp[0] = tp[0] / (self.width / 2)
tp[1] = 1 - (tp[1] / (self.height / 2))
if holdstateM == True:
sp = np.array(glfw.get_cursor_pos(self.window))
sp[0] = sp[0] / (self.width / 2)
sp[1] = 1 - (sp[1] / (self.height / 2))
self.scene.render()
#self.scene.dRender()
glfw.swap_buffers(self.window)
# Poll for and process events
glfw.poll_events()
glfw.terminate()
def run():
# initializer timer
glfw.set_time(0.0)
t = 0.0
while not glfw.window_should_close(window):
# update every x seconds
currT = glfw.get_time()
if currT - t > 1.0 / frame_rate:
# update time
t = currT
# clear
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
display()
# Poll for and process events
glfw.poll_events()
# end
glfw.terminate()
def run(self):
# initializer timer
glfw.set_time(0.0)
t = 0.0
while not glfw.window_should_close(self.window) and not self.exitNow:
# update every x seconds
currT = glfw.get_time()
if currT - t > 1.0 / self.frame_rate:
# update time
t = currT
# clear
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
# render scene
self.scene.render()
glfw.swap_buffers(self.window)
# Poll for and process events
glfw.poll_events()
# end
glfw.terminate()
def run(self):
# initializer timer
glfw.set_time(0.0)
t = 0.0
while not glfw.window_should_close(self.window) and not self.exitNow:
# update every x seconds
curr_t = glfw.get_time()
if curr_t - t > 1.0 / self.frame_rate:
# update time
t = curr_t
# clear
glEnable(GL_DEPTH_TEST)
glEnable(GL_LIGHTING)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
if self.scene.show_object:
self.scene.render(False)
if self.scene.show_shadow:
# drawing shadow
glPushMatrix()
glTranslatef(self.scene.l0_pos[0], self.scene.l0_pos[1],
self.scene.l0_pos[2])
glMultMatrixf(self.scene.shadow_mat)
glTranslatef(-self.scene.l0_pos[0], -self.scene.l0_pos[1],
-self.scene.l0_pos[2])
# render object again
self.scene.render(True)
glPopMatrix()
glDisable(GL_LIGHTING)
self.draw_coordinate_system()
glfw.swap_buffers(self.window)
# Poll for and process events
glfw.poll_events()
# end
glfw.terminate()
def main():
if not glfw.init():
print("failed to initialize GLFW")
return
resolution = (1000, 1000)
window = glfw.create_window(*resolution, 'simulation', None, None)
if not window:
glfw.terminate()
print("failed to create window")
return
glfw.make_context_current(window)
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 4)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 5)
model: models.Model = models.Boids()
model.setup(window)
fps = 30
glfw.set_time(0)
current = glfw.get_time()
previous = glfw.get_time()
glClearColor(0, 0, 0, 0)
while not glfw.window_should_close(window):
if current - previous >= 1.0 / fps:
glClear(GL_COLOR_BUFFER_BIT)
model.render()
glfw.swap_buffers(window)
previous = current
glfw.poll_events()
current = glfw.get_time()
glfw.destroy_window(window)
glfw.terminate()
def set_time(time=0.0):
glfw.set_time(time)
translate_keys = {0: vec(0, 0, 0), 2: vec(1, 1, 0), 4: vec(0, 0, 0)}
rotate_keys = {
0: quaternion(),
2: quaternion_from_euler(180, 45, 90),
3: quaternion_from_euler(180, 0, 180),
4: quaternion()
}
scale_keys = {0: 1, 2: 0.5, 4: 1}
# keynode = KeyFrameControlNode(translate_keys, rotate_keys, scale_keys)
base_node = KeyFrameControlNode(translate_keys, rotate_keys, scale_keys)
base_node.add(base_shape, rotate1)
viewer.add(base_node)
# meshes = load_textured("cube/cube/cube.obj")
# meshes = load("suzanne.obj")
# for m in meshes:
# keynode.add(m)
# viewer.add(keynode)
# start rendering loop
viewer.run()
if __name__ == '__main__':
glfw.init() # initialize window system glfw
glfw.set_time(0)
main() # main function keeps variables locally scoped
glfw.terminate() # destroy all glfw windows and GL contexts
def main():
""" create a window, add scene objects, then run rendering loop """
viewer = Viewer()
# my_keyframes = KeyFrames({0: 1, 3: 7, 6: 20})
# my_keyframes.value(glfw.get_time())
# node = RotationControlNode(glfw.KEY_LEFT, glfw.KEY_RIGHT, vec(0, 1, 0), transform_after=translate(360, 0, 360) @ scale(0.2))
saturn = Node(transform=rotate((0, 1, 0), -72))
saturn.add(Saturn())
wormhole = Node(transform=translate(350, 0, 350))
wormhole.add(WormHole())
glfw.set_time(0)
spaceship = RotationControlNode(
glfw.KEY_RIGHT,
glfw.KEY_LEFT,
vec(1, 0, 0),
precision=2,
transform_before=translate(350, 0, 350) @ scale(0.2) @ rotate(
(0, 0, 1), 90),
transform_after=translate(0, -9, 0))
spaceship.add(Spaceship())
bullet = RotationControlNode(
glfw.KEY_RIGHT,
glfw.KEY_LEFT,
vec(1, 0, 0),
precision=2,
transform_before=translate(350, 0, 350) @ scale(0.2) @ rotate(
(0, 0, 1), 90),
transform_after=rotate((0, 0, 1), 90) @ translate(8, 5, 0))
bullet1 = RotationControlNode(
glfw.KEY_RIGHT,
glfw.KEY_LEFT,
vec(1, 0, 0),
precision=2,
transform_before=translate(350, 0, 350) @ scale(0.2) @ rotate(
(0, 0, 1), 90),
transform_after=rotate((0, 0, 1), 90) @ translate(-8, 5, 0))
bullet2 = RotationControlNode(
glfw.KEY_RIGHT,
glfw.KEY_LEFT,
vec(1, 0, 0),
precision=2,
transform_before=translate(350, 0, 350) @ scale(0.2) @ rotate(
(0, 0, 1), 90),
transform_after=rotate((0, 0, 1), 90) @ translate(0, 5, -8))
bullet3 = RotationControlNode(
glfw.KEY_RIGHT,
glfw.KEY_LEFT,
vec(1, 0, 0),
precision=2,
transform_before=translate(350, 0, 350) @ scale(0.2) @ rotate(
(0, 0, 1), 90),
transform_after=rotate((0, 0, 1), 90) @ translate(0, 5, 8))
bullet.add(Bullet())
bullet1.add(Bullet())
bullet2.add(Bullet())
bullet3.add(Bullet())
transform_bullet = Node()
transform_bullet.add(bullet, bullet1, bullet2, bullet3)
transform_spaceship = Node()
transform_spaceship.add(spaceship, transform_bullet)
transform_wormhole = Node()
transform_wormhole.add(wormhole, transform_spaceship)
transform_saturn = Node()
transform_saturn.add(saturn, transform_wormhole)
viewer.add(transform_saturn)
print('the window is resizable')
print('time can be set to 0 with key_space')
print('spaceship can rotate on itself with key_right and key_left')
viewer.run()
def main():
# init GLFW
glfw.init()
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, GL_TRUE)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
window_width, window_height = 1280, 720
window_aspect = window_width / float(window_height)
window = glfw.create_window(window_width, window_height, 'Triangle', None, None)
glfw.make_context_current(window)
# init GL
glViewport(0, 0, window_width, window_height)
glEnable(GL_DEPTH_TEST)
glClearColor(0.5, 0.5, 0.5, 1)
program = glutils.loadShaders(strVS, strFS)
vertexData = numpy.array([-0.5, -0.5, 0.0, 0.5, -0.5, 0.0, 0.0, 0.5, 0.0,], numpy.float32)
vao = glGenVertexArrays(1)
glBindVertexArray(vao)
vertexBuffer = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer)
glBufferData(GL_ARRAY_BUFFER, 4*len(vertexData), vertexData, GL_STATIC_DRAW)
glEnableVertexAttribArray(0)
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None)
glBindVertexArray(0)
glfw.set_time(0)
win_t = 0.0
while not glfw.window_should_close(window):
currT = glfw.get_time()
if currT - win_t > 0.1:
# rotation angle
# print(win_t)
win_t = currT
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
# render scene
glUseProgram(program)
glBindVertexArray(vao)
glDrawArrays(GL_TRIANGLE_FAN, 0, 4)
glBindVertexArray(0)
glfw.swap_buffers(window)
glfw.poll_events()
glfw.terminate()
def draw(self, projection, view, model, win=None, **param):
assert win is not None
# rotation management
self.angle += 2 * int(glfw.get_key(win, self.key_left) == glfw.PRESS)
self.angle -= 2 * int(glfw.get_key(win, self.key_right) == glfw.PRESS)
rotation = rotate(self.axis, self.angle)
# translation management
movement_magnitude = self.speed * (
int(glfw.get_key(win, self.key_forward) == glfw.PRESS) -
int(glfw.get_key(win, self.key_backward) == glfw.PRESS))
forward_vector = -rotation @ vec(
0, 0, movement_magnitude,
1) # the - and magnitude on z is here to correct the dae oriention
old_translation = translate(self.transform[0][3], self.transform[1][3],
self.transform[2][3])
translation = old_translation + translate(forward_vector[0], 0,
forward_vector[2])
goalx = 0
goaly = 0
# a lot of booleans to test if we need to set the time to zero
if glfw.get_time() > self.time:
if (glfw.get_key(win, self.key_forward) == glfw.PRESS):
# resets walking animation when key is held
glfw.set_time(0)
if (self.show and
(glfw.get_key(win, self.key_toggle) != glfw.PRESS
and glfw.get_key(win, self.key_toggle2) != glfw.PRESS)):
# resets idle animation
glfw.set_time(0)
if (self.interact
and glfw.get_key(win, self.key_forward) != glfw.PRESS):
glfw.set_time(0)
# this part makes sure the eating animation starts from the beginning everytime we press the spacebar.
if self.interact:
if self.first_time and glfw.get_key(win,
self.key_toggle) == glfw.PRESS:
glfw.set_time(0)
self.first_time = False
if not (self.first_time) and glfw.get_key(
win, self.key_toggle) != glfw.PRESS:
self.first_time = True
self.transform = translation @ rotation
# call Node's draw method to pursue the hierarchical tree calling
# a lot of boolean conditions to draw or not the different dinosaurs
if self.show:
if (glfw.get_key(win, self.key_toggle) != glfw.PRESS
and glfw.get_key(win, self.key_toggle2) != glfw.PRESS):
super().draw(projection,
view,
model,
win=win,
x=translation[0][3] / 2,
z=translation[2][3] / 2,
**param)
else:
if (not (self.interact)
and glfw.get_key(win, self.key_toggle) == glfw.PRESS):
super().draw(projection,
view,
model,
win=win,
x=translation[0][3] / 2,
z=translation[2][3] / 2,
**param)
elif (self.interact
and glfw.get_key(win, self.key_toggle) == glfw.PRESS
and glfw.get_key(win, self.key_forward) != glfw.PRESS):
super().draw(projection,
view,
model,
win=win,
x=translation[0][3] / 2,
z=translation[2][3] / 2,
**param)
