def render(self, time, frame_time):
pyglet.clock.tick()
time = self.timer.get_time()
# Prepare camera matrix
translation = matrix44.create_from_translation((
self.track_cam_x.time_value(time),
self.track_cam_y.time_value(time),
self.track_cam_z.time_value(time),
),
dtype='f4')
rotation = matrix44.create_from_eulers((
math.radians(self.track_cam_rot_x.time_value(time)),
math.radians(self.track_cam_rot_tilt.time_value(time)),
math.radians(self.track_cam_rot_z.time_value(time)),
),
dtype='f4')
projection = self.camera.projection.matrix
modelview = matrix44.multiply(matrix44.multiply(translation, rotation),
self.camera.matrix)
# Render active effects
self.offscreen.use()
self.offscreen.clear()
for effect in self.router.gen_active_effects(time):
effect.render(time=time,
projection=projection,
modelview=modelview)
# # Postprocessing
self.wnd.use()
self.offscreen.color_attachments[0].use()
self.screen_quad_prog['fade'].value = self.track_fade.time_value(time)
self.screen_quad.render(self.screen_quad_prog)
def render(self, time, frametime):
# time = self.wnd.frames / 30
self.ctx.enable_only(moderngl.DEPTH_TEST | moderngl.CULL_FACE)
self.render_pygame(time)
rotate = matrix44.create_from_eulers((time, time * 1.2, time * 1.3), dtype='f4')
translate = matrix44.create_from_translation((0, 0, -3.5), dtype='f4')
camera = matrix44.multiply(rotate, translate)
self.texture_prog['m_camera'].write(camera)
self.pg_texture.use()
self.cube.render(self.texture_prog)
def draw(self, time, frametime, target):
matrix = matrix44.multiply(
# Rotate earth around its own axis
matrix44.multiply(
matrix44.create_from_eulers([0.0, 0.0, -time / 5.0]),
# Translate out from the sun and rotate around it
matrix44.multiply(
matrix44.create_from_translation([-40, 0, 0]),
matrix44.create_from_eulers([0, 0, 0]) # time/100.0])
),
),
self.sys_camera.view_matrix)
self.program['m_proj'].write(self.sys_camera.projection.tobytes())
self.program['m_mv'].write(matrix.astype('f4').tobytes())
self.program['m_proj'].write(self.sys_camera.projection.tobytes())
self.program['sun_pos'].write(self.parent.sun_pos.tobytes())
self.program['texture_day'].value = 1
self.program['texture_night'].value = 2
self.program['texture_clouds'].value = 3
self.texture_day.use(location=1)
self.texture_night.use(location=2)
self.texture_clouds.use(location=3)
self.sphere.render(self.program)
def render(self, time: float, frametime: float):
"""Render the scene"""
self.ctx.enable_only(moderngl.DEPTH_TEST) # | moderngl.CULL_FACE)
# Create camera matrix with rotation and translation
translation = matrix44.create_from_translation((0, 0, -1.5))
# rotation = matrix44.create_from_eulers((time, time, time))
rotation = matrix44.create_from_eulers((0, 0, 0))
model_matrix = matrix44.multiply(rotation, translation)
camera_matrix = matrix44.multiply(model_matrix, self.camera.matrix)
self.scene.draw(
projection_matrix=self.camera.projection.matrix,
camera_matrix=camera_matrix,
time=time,
)
def draw(self, ctx, camera):
"""Draw skybox."""
ctx.use_program("skybox")
old_cull_face_mode = glGetIntegerv(GL_CULL_FACE_MODE)
old_depth_func_mode = glGetIntegerv(GL_DEPTH_FUNC)
glCullFace(GL_FRONT)
glDepthFunc(GL_LEQUAL)
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_CUBE_MAP, self.skybox_texture_id)
uniforms = camera.gen_uniforms(
matrix44.multiply(
matrix44.create_from_eulers(self.rot, dtype=np.float32),
matrix44.create_from_translation(camera.pos, dtype=np.float32),
))
ctx.update_uniforms(uniforms)
model = ctx.get_model("skybox")
glDrawArrays(GL_TRIANGLES, model.offset, model.indices)
glCullFace(old_cull_face_mode)
glDepthFunc(old_depth_func_mode)
def test_create_from_eulers(self):
# just call the function
# TODO: check the result
matrix44.create_from_eulers([1,2,3])
def test_create_from_eulers(self):
# just call the function
# TODO: check the result
matrix44.create_from_eulers([1, 2, 3])
def test_create_from_eulers(self):
e = Vector3([1, 2, 3])
m = Matrix44.from_eulers(e)
self.assertTrue(
np.array_equal(m, matrix44.create_from_eulers([1, 2, 3])))
def render(self, time):
self.program['model_matrix'].write(
matrix44.create_from_eulers((0, time / 8, 0), dtype='f4'))
self.vao.render(vertices=self.count, mode=moderngl.POINTS)
def _update_transform(self):
self.transform = matrix44.multiply(
matrix44.create_from_eulers(self.rot, dtype=np.float32),
matrix44.create_from_translation(self.pos, dtype=np.float32),
)
def test_create_from_eulers(self):
e = Vector3([1,2,3])
m = Matrix44.from_eulers(e)
self.assertTrue(np.array_equal(m, matrix44.create_from_eulers([1,2,3])))
