def main():
""" create window, add shaders & scene objects, then run rendering loop """
width = 640
height = 480
camera = Camera(vec(0, 0, -5), 60, height / width, .3, 1000)
scene = Scene(camera,
light=vec(-.57735026919, -.57735026919, .57735026919) * .5)
pyramidMesh = Mesh(vertices=np.array(
((0, .5, 0), (.5, -.5, 0), (-.5, -.5, 0)), 'f'),
normals=np.array(
((0, 0, -1), (0.70710678118, 0, -0.70710678118),
(-0.70710678118, 0, -0.70710678118)), 'f'),
perVertexColor=np.array(
((1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0)),
'f'),
indexes=np.array((0, 1, 2), 'u4'))
suzanne = Mesh.LoadMeshes("models/suzanne.obj")[0]
scene.Add3DObject(
Object3D(0,
translate(-1.5, 0, 1) @ rotate(vec(0.0, 1.0, 0.0), -200),
suzanne, Material("shaders/rainbow_shaded.frag")))
scene.Add3DObject(
Object3D(1,
translate(1.5, 0, 1) @ rotate(vec(0.0, 1.0, 0.0), 200),
suzanne, Material("shaders/shaded.frag")))
renderer = Renderer(scene)
renderer.Run()
def __init__(self, name, height):
super().__init__(name)
cylinder = load("Objects/cylinder.obj")[0]
cube = load("Objects/cube/cube.obj")[0]
cylinderPerlin = PerlinMesh(cylinder)
door_left = Node(children=[cube],
transform=translate(5, 0, 0) @ scale(10, 2, 0.7))
scale_left = Node(children=[cylinderPerlin, door_left],
transform=scale(0.1, height, 0.1))
rotation_left = RotationControlNode(glfw.KEY_L,
glfw.KEY_P,
vec(0, 1, 0),
speed=0.5,
children=[scale_left])
node_left = Node(children=[rotation_left],
transform=translate(-1, 0, 0))
door_right = Node(children=[cube],
transform=translate(-5, 0, 0) @ scale(10, 2, 0.7))
scale_right = Node(children=[cylinderPerlin, door_right],
transform=scale(0.1, height, 0.1))
rotation_right = RotationControlNode(glfw.KEY_L,
glfw.KEY_P,
vec(0, -1, 0),
speed=0.5,
children=[scale_right])
node_right = Node(children=[rotation_right],
transform=translate(1, 0, 0))
self.add(node_left, node_right)
def main():
""" create a window, add scene objects, then run rendering loop """
viewer = Viewer()
# place instances of our basic objects
#
phi, theta, psi = 30, 20, 40
# # construct our robot arm hierarchy for drawing in viewer
cylinder = Cylinder(40) # re-use same cylinder instance
limb_shape = Node(transform=scale(1 / 4, 1 / 4, 5)) # make a thin cylinder
limb_shape.add(cylinder) # common shape of arm and forearm
rotate2 = RotationControlNode(glfw.KEY_E, glfw.KEY_D, (1, 0, 0))
rotate2.add(limb_shape)
forearm_node = Node(transform=translate(0, 0, 5 - 1 / 4) @ rotate(
(1, 0, 0), psi)) # robot arm rotation with phi angle
forearm_node.add(rotate2)
arm_node = Node(transform=translate(0, 0, 0.5) @ rotate(
(1, 0, 0), phi)) # robot arm rotation with phi angle
arm_node.add(limb_shape, forearm_node)
rotate1 = RotationControlNode(glfw.KEY_F, glfw.KEY_S, (1, 0, 0))
rotate1.add(arm_node)
# make a flat cylinder
base_shape = Node(transform=identity(), children=[cylinder])
# viewer.add(base_node)
viewer.add(TexturedPlane("control/arrows.png"))
# viewer.add(Cylinder(200))
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()
def main():
""" create window, add shaders & scene objects, then run rendering loop """
width = 640
height = 480
camera = Camera(vec(0, 0, -5), 60, height / width, .3, 1000)
viewer = Viewer(camera, vec(0, 0, 1), width, height)
color_shader = Shader("color.vert", "color.frag")
# place instances of our basic objects
viewer.add(SimpleTriangle(color_shader))
# start rendering loop
viewer.run()
def main():
""" create a window, add scene objects, then run rendering loop """
viewer = Viewer()
shader = Shader("color.vert", "color.frag")
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)
keynode.add(Cylinder(shader))
viewer.add(keynode)
# start rendering loop
viewer.run()
def asteroids(self):
mesh_rocher = Rocher(self.light_direction, color=[0.8,0.2,0.2])
node = Node("LaFinDuMonde")
for i in range(4):
oneNode = Node('', children=[mesh_rocher])
oneNode.scale_total(20)
oneNode.translate(0,100+randint(0,5),0)
self.randomize_creation(oneNode, rotation_max=360, axis_rotation=(0, 1, 0), axis_translation=(1, 1, 1))
translate_keys = {0: vec(0, 1000, 0), 4: vec(0, -800, 0)}
rotate_keys = {0: quaternion(), 57: quaternion()}
scale_keys = {0: 1,7:1}
keynode = KeyFrameControlNode(translate_keys, rotate_keys, scale_keys, resetTime=6)
keynode.add(oneNode)
node.add(keynode)
return node
def get_translate_keys(self):
# generate translate keys
start = random() * 0.9
height = randrange(-6, 8) / 10
return {
0:
vec(-start * self.direction, height, -start * self.direction),
2 * self.timeskip:
vec(-start * self.direction, height, start * self.direction),
3 * self.timeskip:
vec(start * self.direction, height, start * self.direction),
4 * self.timeskip:
vec(start * self.direction, height, -start * self.direction),
5 * self.timeskip:
vec(-start * self.direction, height, -start * self.direction)
}
def draw(self, projection, view, model, win, **param):
""" Recursive draw, passing down named parameters & model matrix. """
# merge named parameters given at initialization with those given here
param = dict(param, **self.param)
model2 = model @ self.transform
pos = model2@vec(0,0,0,1)
self.position = pos[:3]
for child in self.children:
child.draw(projection, view, model2, win, **param)
def draw(self, projection, view, model, color_shader, color_id):
# loading of the colors into the fragment shader
color_id_location = GL.glGetUniformLocation(color_shader.glid, 'color_id')
GL.glUseProgram(color_shader.glid)
GL.glUniform1i(color_id_location, color_id)
# loading of the transform matrix into the shader
if self.color_type:
matrix_location = GL.glGetUniformLocation(color_shader.glid, 'matrix')
projection_matrix = frustum(-.5, .5, -.5, .5, .01, 1000)
transform_matrix = rotate(vec(1, 0, 0), 15) @ rotate(vec(0, 1, 0), -15) @ scale(.5) @ translate(-1, 0, 0)
GL.glUniformMatrix4fv(matrix_location, 1, True, transform_matrix)
else:
matrix_location = GL.glGetUniformLocation(color_shader.glid, 'matrix')
projection_matrix = frustum(-.5, .5, -.5, .5, .01, 1000)
transform_matrix = rotate(vec(1, 0, 0), 15) @ rotate(vec(0, 1, 0), 15) @ scale(.5) @ translate(1, 0, 0)
GL.glUniformMatrix4fv(matrix_location, 1, True, transform_matrix)
self.vertex_arrays.draw(GL.GL_TRIANGLES)
def main():
""" create a window, add scene objects, then run rendering loop """
viewer = Viewer()
# cylinder_node = Node(name='my_cylinder', transform=translate(-1, 0, 0), color=(1, 0, 0.5, 1))
# cylinder_node.add(Cylinder())
# viewer.add(cylinder_node)
# place instances of our basic objects
# viewer.add(*[mesh for file in sys.argv[1:] for mesh in load(file)])
# construct our robot arm hierarchy for drawing in viewer
cylinder = Cylinder() # re-use same cylinder instance
limb_shape = Node(transform=(scale(0.2, 2, 0.2))) # make a thin cylinder
forearm_node = Node(
transform=rotate(axis=vec(0, 0, 1), angle=45) @ translate(
0, 0, 0)) # robot arm rotation with phi angle
forearm_node.add(limb_shape)
# limb_shape = Node(transform=(scale(0.2, 2, 0.2))) # make a thin cylinder
limb_shape.add(cylinder) # common shape of arm and forearm
arm_node = Node(transform=rotate(axis=vec(0, 0, 1), angle=45) @ translate(
0, 0, 0)) # robot arm rotation with phi angle
arm_node.add(limb_shape, forearm_node)
# make a flat cylinder
base_shape = Node(transform=scale(1, 0.5, 1), children=[cylinder])
base_node = Node(transform=rotate(axis=vec(
0, 1, 0), angle=45)) # robot base rotation with theta angle
base_node.add(base_shape, arm_node)
viewer.add(base_node)
# if len(sys.argv) < 2:
# print('Usage:\n\t%s [3dfile]*\n\n3dfile\t\t the filename of a model in'
# ' format supported by pyassimp.' % (sys.argv[0],))
# start rendering loop
viewer.run()
def __init__(self,
translate_keys,
rotate_keys,
scale_keys,
name='',
interpolate_translate=lerp,
**kwargs):
super().__init__(name, **kwargs)
self.keyframes = TransformKeyFrames(translate_keys, rotate_keys,
scale_keys, interpolate_translate)
self.position = vec(0, 0, 0)
def draw(self, projection, view, model, color_shader, color_id):
# loading of the colors into the fragment shader
color_id_location = GL.glGetUniformLocation(color_shader.glid, 'color_id')
GL.glUseProgram(color_shader.glid)
GL.glUniform1i(color_id_location, color_id)
# loading of the transform matrix into the shader
matrix_location = GL.glGetUniformLocation(color_shader.glid, 'matrix')
GL.glUniformMatrix4fv(matrix_location, 1, True, rotate(vec(0, 1, 1), 45))
self.vertex_array.draw(GL.GL_TRIANGLES)
def draw(self, projection, view, model):
GL.glUseProgram(self.shader.glid)
# draw triangle as GL_TRIANGLE vertex array, draw array call
GL.glBindVertexArray(self.glid)
GL.glDrawArrays(GL.GL_TRIANGLES, 0, 3)
color_loc = GL.glGetUniformLocation(self.shader.glid, 'color')
GL.glUniform3fv(color_loc, 1, self.color)
matrix_loc = GL.glGetUniformLocation(self.shader.glid, 'matrix')
GL.glUniformMatrix4fv(matrix_loc, 1, True, rotate(vec(1, 1, 1), 45))
def __init__(self,
planete,
vrot,
periode,
scale,
rayon,
name='',
**kwargs):
translate = {0: vec(0, 0, 0), 1: vec(0, 0, 0)}
rotate = {
0: quaternion(),
periode / 4: quaternion_from_axis_angle(vrot, degrees=90),
periode / 2: quaternion_from_axis_angle(vrot, degrees=180),
3 * periode / 4: quaternion_from_axis_angle(vrot, degrees=270),
periode: quaternion()
}
scale = {0: scale, 2: scale}
self.rayonModel = rayon
self.rayon = rayon
super().__init__(translate, rotate, scale, name, **kwargs)
self.add(*load_textured(planete))
def add_asteroid():
a_mesh = PhongMesh('resources/Asteroid/10464_Asteroid_v1_Iterations-2.obj')
asteroid_base = Node(
transform=translate(x=2.2, y=4, z=-10) @ scale(x=0.02))
asteroid_base.add(a_mesh)
translate_keys = {
0: vec(2, 5, -11),
2: vec(1.5, 3.5, -12),
4: vec(1, 2, -13),
6: vec(0.5, 0.5, -14),
8: vec(0, -1, -15),
10: vec(-0.2, -2.5, -16),
}
rotate_keys = {
0: quaternion_from_euler(30, 0, 150),
2: quaternion_from_euler(45, 0, 200),
4: quaternion_from_euler(50, 0, 250),
6: quaternion_from_euler(55, 0, 300),
8: quaternion_from_euler(60, 0, 350),
10: quaternion_from_euler(65, 0, 400)
}
scale_keys = {0: 0.1, 2: 0.08, 4: 0.06, 6: 0.04, 8: 0.01, 10: 0.001}
keynode = KeyFrameControlNode(translate_keys, rotate_keys, scale_keys)
keynode.add(asteroid_base)
return keynode
def __init__(self,
planete,
vrot,
periode1,
vecDeb,
scale,
vdirec,
periode2,
rayon,
name='',
lumineux=False,
**kwargs):
if (name == '' and lumineux == True):
print("Un objet lumineux doit avoir un nom")
vrot2 = np.cross(vecDeb, vdirec)
if (np.linalg.norm(vecDeb) == 0):
translate = {0: vec(0, 0, 0), 1: vec(0, 0, 0)}
else:
translate = {
0: vecDeb,
(periode2 / 4): rotate(vrot2, 90)[:3, :3] @ vecDeb,
(periode2 / 2): rotate(vrot2, 180)[:3, :3] @ vecDeb,
(3 * periode2 / 4): rotate(vrot2, 270)[:3, :3] @ vecDeb,
(periode2): vecDeb
}
demi_grand_axe = math.pow(
periode2 * periode2 * 66740 * math.pow(10, 15) /
(2 * np.pi * np.pi), 1 / 3)
rotate2 = {0: quaternion(), 1: quaternion()}
scale2 = {0: 1, 2: 1, 4: 1}
self.lumineux = lumineux
if (lumineux == True):
kwargs['light'] = (0, 0, 0)
super().__init__(translate, rotate2, scale2, name, lerpCircle,
**kwargs)
planeteP = Planete(planete, vrot, periode1, scale, rayon)
self.add(planeteP)
def draw(self, projection, view, model, color_shader, color, scaler,
rotater):
GL.glUseProgram(color_shader.glid)
my_color_location = GL.glGetUniformLocation(color_shader.glid, 'color')
# hard coded color : (0.6, 0.6, 0.9)
GL.glUniform3fv(my_color_location, 1, color)
matrix_location = GL.glGetUniformLocation(color_shader.glid, 'matrix')
GL.glUniformMatrix4fv(
matrix_location, 1, True,
perspective(35, 640 / 480, 0.001, 100) @ translate(0, 0, -1)
@ rotate(vec(0, 1, 0), rotater) @ scale(scaler))
# draw triangle as GL_TRIANGLE vertex array, draw array call
GL.glBindVertexArray(self.glid)
GL.glDrawArrays(GL.GL_TRIANGLES, 0, 3)
GL.glBindVertexArray(0)
def draw(self, projection, view, model, color_shader, color):
GL.glUseProgram(color_shader.glid)
# draw triangle as GL_TRIANGLE vertex array, draw array call
GL.glBindVertexArray(self.glid)
GL.glDrawArrays(GL.GL_TRIANGLES, 0, 3)
GL.glBindVertexArray(0)
# color as shader uniform (deactivated, not receiving this info in VS)
my_color_location = GL.glGetUniformLocation(color_shader.glid, 'color')
GL.glUniform3fv(my_color_location, 1, color)
# projection transform
projection_transform = frustum(-2, 2, -2, 2, -2, 2)
# triangle transformation
transformation = rotate(vec(1, 0, 0), 25) @ scale(0.7) @ translate(0.4, 0.7, 0)
transformation = transformation @ projection_transform
matrix_location = GL.glGetUniformLocation(color_shader.glid, 'matrix')
GL.glUniformMatrix4fv(matrix_location, 1, True, transformation)
def __init__(self,
key_forward,
key_backward,
key_left,
key_right,
key_toggle,
key_toggle2=glfw.KEY_Q,
show=True,
interact=False,
time=1,
speed=.5,
**param):
super().__init__(**param) # forward base constructor named arguments
self.axis, self.angle = vec(0, 1, 0), 0
self.key_forward, self.key_backward, self.key_left, self.key_right, self.key_toggle, self.key_toggle2 = key_forward, key_backward, key_left, key_right, key_toggle, key_toggle2
self.transform = translate(0, 0, 0)
self.speed = speed
self.show = show
self.time = time
self.interact = interact
self.first_time = True
def main():
""" main program """
viewer = Viewer()
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: vec(1, 1, 1), 2: vec(0.5, 0.5, 0.5), 4: vec(1, 1, 1)}
keynode = KeyFrameControlNode(translate_keys, rotate_keys, scale_keys)
keynode.add(Cylinder())
viewer.add(keynode)
viewer.run()
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_LEFT):
self.camera.SetPosition(self.camera.position + vec(-1, 0, 0) * 0.05)
if(key == glfw.KEY_RIGHT):
self.camera.SetPosition(self.camera.position + vec(1, 0, 0) * 0.05)
if(key == glfw.KEY_UP):
self.camera.SetPosition(self.camera.position + vec(0, 1, 0) * 0.05)
if(key == glfw.KEY_DOWN):
self.camera.SetPosition(self.camera.position + vec(0, -1, 0) * 0.05)
if(key == glfw.KEY_R):
self._LightDirection = (rotate(vec(0, 1, 0), 0.5) @ vec(self._LightDirection[0], self._LightDirection[1], self._LightDirection[2], 1))[0:3]
for drawable in self.drawables:
if hasattr(drawable, 'key_handler'):
drawable.key_handler(key)
# viewer.add(TexturedPlane("grass.png"))
# construct our robot arm hierarchy for drawing in viewer
# cylinder = Cylinder() # re-use same cylinder instance
# limb_shape = Node(transform=identity() @ translate(0, 1, 0) @ scale(0.5, 1, 0.5)) # make a thin cylinder
# limb_shape.add(cylinder) # common shape of arm and forearm
#
# arm_node = Node(transform=identity() @ translate(0, 2, 0) @ scale(0.7, 0.7, 0.7), children=[cylinder]) # robot arm rotation with phi angle
# arm_node.add(limb_shape)
#
# # make a flat cylinder
# base_shape = Node(transform=identity(), children=[cylinder])
# base_node = Node(transform=identity()) # robot base rotation with theta angle
# base_node.add(base_shape, arm_node)
# viewer.add(base_node)
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: vec(1,1,1), 2: vec(0.5,0.5,0.5), 4: vec(1,1,1)}
keynode = KeyFrameControlNode(translate_keys, rotate_keys, scale_keys)
keynode.add(Cylinder())
viewer.add(keynode)
viewer.run()
if __name__ == '__main__':
glfw.init() # initialize window system glfw
main() # main function keeps variables locally scoped
glfw.terminate() # destroy all glfw windows and GL contexts
def update(self, elapsed_time):
if self.rotate_light:
angle = 45 * elapsed_time
light_position = rotate(
(1, 0, 1), angle) @ vec(*self.light_position, 1)
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 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)
def LookAt(self, target):
self._ViewMatrix = lookat(self.position, target, vec(0, 1, 0))
self._ProjectionViewMatrix = self._ProjectionMatrix @ self._ViewMatrix
def __init__(self, name='', children=(), transform=identity(), **param):
self.transform, self.param, self.name = transform, param, name
self.children = list(iter(children))
pos = self.transform[:4,:4]@vec(0,0,0,1)
self.position = pos[:3]
def __init__(self, position, fov, aspect, near, far):
self.position = position
self._ProjectionMatrix = perspective(fov, aspect, near, far)
self._ViewMatrix = lookat(position, vec(0, 0, 0), vec(0, 1, 0))
self._ProjectionViewMatrix = self._ProjectionMatrix @ self._ViewMatrix
def value(self, time):
""" Compute each component's interpolation and compose TRS matrix """
translate_mat = translate(self.translate_keys.value(time))
rotate_mat = vec(self.rotate_keys.value(time))
scale_mat = vec(self.scale_keys.value(time))
return translate_mat * rotate_mat * scale_mat
def add_ufo_ship():
ufo_mesh = PhongMesh('resources/ufo/ufo.obj')
ufo_base = Node(transform=translate(x=-0.6, y=0, z=0) @ scale(x=0.04))
ufo_base.add(ufo_mesh)
translate_keys = {
0: vec(-8, 0.8, -10),
1: vec(-7, 0.7, -9),
2: vec(-6, 0.6, -8),
3: vec(-5, 0.5, -7),
4: vec(-4, 0.45, -6),
5: vec(-3, 0.38, -5),
6: vec(-2, 0.35, -4),
7: vec(-1, 0.25, -3),
8: vec(-0.3, 0.15, -2.5),
9: vec(-0.1, -0.1, -1),
10: vec(0.03, -0.25, -0.5),
11: vec(0.09, -0.44, 0.1)
}
rotate_keys = {
0: quaternion_from_euler(0, 0, 20),
1: quaternion_from_euler(0, 0, 20),
2: quaternion_from_euler(0, 0, 25),
3: quaternion_from_euler(0, 0, 28),
4: quaternion_from_euler(0, 0, 33),
5: quaternion_from_euler(0, 0, 35),
6: quaternion_from_euler(0, 0, 37),
7: quaternion_from_euler(0, 0, 30),
8: quaternion_from_euler(0, 0, 20),
9: quaternion_from_euler(0, 0, 15),
10: quaternion_from_euler(0, 0, 25),
11: quaternion_from_euler(0, 0, 10)
}
scale_keys = {
0: 0.2,
1: 0.25,
2: 0.3,
3: 0.3,
4: 0.3,
5: 0.3,
6: 0.3,
7: 0.3,
8: 0.3,
9: 0.3,
10: 0.3,
11: 0.3
}
keynode = KeyFrameControlNode(translate_keys, rotate_keys, scale_keys)
keynode.add(ufo_base)
return keynode
