def render(self, time, frame_time):
self.ctx.clear(0.2, 0.2, 0.2)
self.ctx.enable(moderngl.DEPTH_TEST)
self.fps = 1 / frame_time
self.control()
proj = Matrix44.perspective_projection(45.0, self.aspect_ratio, 0.1,
1000.0)
lookat = Matrix44.look_at(
(self.movX, self.movY, self.movZ),
(200.0, 200.0, 0.0),
(0.0, 0.0, 1.0),
)
self.light.value = (100, 0, 200)
self.texture.use(0)
self.mvp_map.write((proj * lookat).astype('f4'))
self.vao_map.render(moderngl.TRIANGLE_FAN)
model_rot = Matrix44.from_z_rotation(
3.14 / 4) * Matrix44.from_x_rotation(-3.14 / 2)
for x in range(int(self.positions.size / 3)):
size = 1 + self.production[x] * (2.5 - 1)
model_size = Matrix44.from_scale(np.array([size, size, size]))
self.gradient.value = self.production[x]
model = Matrix44.from_translation(np.array(
self.positions[x])) * model_rot * model_size
self.mvp.write((proj * lookat * model).astype('f4'))
self.vao.render()
self.render_ui()
def generate_twig_from_file(self, filepath):
f = open(filepath, 'r')
for line in f:
if line.startswith("sphere"):
arr = line.split(" ")
if len(arr) > 10:
self.needle_num += 1
zenith_rotation_angle = degree_to_rad(float(arr[13]))
azimuth_rotation_angle = degree_to_rad(float(arr[18]))
translate_vector = Vector3([float(arr[20]), float(arr[21]), float(arr[22])])
matrix = Matrix44.from_y_rotation(zenith_rotation_angle)
matrix = matrix * Matrix44.from_z_rotation(azimuth_rotation_angle)
matrix = matrix * Matrix44.from_translation(translate_vector)
# applying rotation
newNeedle_vertexes = list(map(lambda x: matrix * Vector3(x), self.prim_needle.vertexes))
self.vertexes += newNeedle_vertexes
f.close()
# generate twig
r = math.pi * self.twig_diameter / 6.0
lower_plane, upper_plane = [], []
for i in range(0, 360, 60):
angle_rad = degree_to_rad(i)
x = r * math.cos(angle_rad)
y = r * math.sin(angle_rad)
lower_plane.append([x, y, 0])
upper_plane.append([x, y, self.twig_length])
self.twig_vertexes = lower_plane + upper_plane
def render(self, time: float, frame_time: float):
self.ctx.clear(1.0, 1.0, 1.0)
self.ctx.enable(moderngl.DEPTH_TEST)
proj = Matrix44.perspective_projection(45.0, self.aspect_ratio, 0.1, 1000.0)
lookat = Matrix44.look_at(
(47.697, -8.147, 24.498),
(0.0, 0.0, 8.0),
(0.0, 0.0, 1.0),
)
rotate = Matrix44.from_z_rotation(np.sin(time) * 0.5 + 0.2)
self.use_texture.value = False
self.light.value = (67.69, -8.14, 52.49)
self.mvp.write((proj * lookat * rotate).astype('f4').tobytes())
self.color.value = (0.67, 0.49, 0.29)
self.objects['ground'].render()
self.color.value = (0.46, 0.67, 0.29)
self.objects['grass'].render()
self.color.value = (1.0, 1.0, 1.0)
self.objects['billboard'].render()
self.color.value = (0.2, 0.2, 0.2)
self.objects['billboard-holder'].render()
self.use_texture.value = True
self.texture.use()
self.objects['billboard-image'].render()
def rotate_relative(self, rotation):
pos = self.get_position()
rotate_matrix = Matrix44.from_x_rotation(rotation.x) * \
Matrix44.from_y_rotation(rotation.y) * \
Matrix44.from_z_rotation(rotation.z)
self.matrix = rotate_matrix * self.matrix
self.set_position(pos)
def render(self, time: float, frame_time: float):
self.ctx.clear(1.0, 1.0, 1.0)
self.ctx.enable(moderngl.DEPTH_TEST | moderngl.CULL_FACE)
proj = Matrix44.perspective_projection(45.0, self.aspect_ratio, 0.1,
1000.0)
lookat = Matrix44.look_at(
(47.697, -8.147, 24.498),
(0.0, 0.0, 8.0),
(0.0, 0.0, 1.0),
)
rotate = Matrix44.from_z_rotation(np.sin(time) * 0.5 + 0.2)
self.use_texture.value = False
self.light.value = (67.69, -8.14, 52.49)
self.mvp.write((proj * lookat * rotate).astype('f4').tobytes())
self.color.value = (0.67, 0.49, 0.29)
self.vao_ground.render()
self.color.value = (0.46, 0.67, 0.29)
self.vao_grass.render()
self.color.value = (1.0, 1.0, 1.0)
self.vao_billboard.render()
self.color.value = (0.2, 0.2, 0.2)
self.vao_holder.render()
self.use_texture.value = True
self.texture.use()
self.vao_image.render()
def render(self, time, frame_time):
if SimpleRenderer.callback and frame_time > 0:
SimpleRenderer.callback(frame_time)
# print(time, frame_time)
self.camera.update()
self.ctx.clear(0.1, 0.1, 0.1)
self.ctx.enable(moderngl.DEPTH_TEST)
# print('---------')
# print(self.camera.elevation, self.camera.azimuth)
# print(self.camera.mat_lookat*Vector4([0,0,0,1]))
# grid
self.mvp.write((self.camera.mat_projection *
self.camera.mat_lookat.inverse).astype('f4'))
self.grid_vao.render(moderngl.LINES)
# objects
for obj in SimpleRenderer.objects:
# model matrix
scale = Matrix44.from_scale([obj.radius, obj.radius, obj.radius])
rotation = Matrix44.from_z_rotation(
-np.arctan2(obj.vel.y, obj.vel.x))
translation = Matrix44.from_translation([obj.pos.x, obj.pos.y, 0])
model = translation * rotation * scale
# render object
self.mvp.write(
(self.camera.mat_projection * self.camera.mat_lookat.inverse *
model).astype('f4'))
self.cyl_vao.render(moderngl.TRIANGLES)
def get_rotation(x, y, z):
logger.debug('Create rotation matrix with (x:{}, y:{}, z:{})'.format(
x, y, z))
x_rotation = Matrix44.from_x_rotation(x)
y_rotation = Matrix44.from_y_rotation(y)
z_rotation = Matrix44.from_z_rotation(z)
return z_rotation * y_rotation * x_rotation
def buildTransMatrix(pos=[0, 0, 0], rot=[0, 0, 0], scale=[1, 1, 1]):
trans = Matrix44.from_translation(pos)
rotX = Matrix44.from_x_rotation(np.radians(rot[0]))
rotY = Matrix44.from_y_rotation(np.radians(rot[1]))
rotZ = Matrix44.from_z_rotation(np.radians(rot[2]))
scale = Matrix44.from_scale(scale)
tMatrix = trans * scale * rotX * rotY * rotZ
return tMatrix
def applyTransforms(vector, projectionMat):
r = time.clock() + vector[0] * 10 # rotation offset based on vector's 1st component
rotX = Matrix44.from_x_rotation(r)
rotY = Matrix44.from_y_rotation(r)
rotZ = Matrix44.from_z_rotation(r)
trans = Matrix44.from_translation(vector) * Matrix44.from_translation([1,1,-5]) # move view back by -5
scale = Matrix44.from_scale([.5,.5,.5]) # uniformly scale by 0.5
tMatrix = projectionMat * trans * scale * rotX * rotY * rotZ
prog['transform'].write(tMatrix.astype('f4').tobytes())
def scatterCubes(vector, projectionMat):
view = window.getViewMatrix()
r = vector[0] * 10.0 # cube rotation offset based on vector's 1st component
rotX = Matrix44.from_x_rotation(r*time.clock()/10.0) # rotate cubes over time
rotY = Matrix44.from_y_rotation(r)
rotZ = Matrix44.from_z_rotation(r)
trans = Matrix44.from_translation(vector) * Matrix44.from_translation([1.0,1.0,-5.0])
scale = Matrix44.from_scale([.5,.5,.5]) # uniformly scale by 0.5
tMatrix = projectionMat * view * trans * scale * rotX * rotY * rotZ
prog['transform'].write(tMatrix.astype('f4').tobytes())
def render(self):
width, height = self.wnd.size
self.ctx.viewport = self.wnd.viewport
self.ctx.clear(1.0, 1.0, 1.0)
self.ctx.enable(moderngl.DEPTH_TEST)
proj = Matrix44.perspective_projection(45.0, width / height, 0.1,
1000.0)
lookat = Matrix44.look_at(
(47.697, -8.147, 24.498),
(0.0, 0.0, 8.0),
(0.0, 0.0, 1.0),
)
rotate = Matrix44.from_z_rotation(np.sin(self.wnd.time) * 0.5 + 0.2)
for mode in ['render_to_texture', 'render_to_window']:
if mode == 'render_to_texture':
self.fbo.clear(1.0, 1.0, 1.0)
self.fbo.use()
else:
self.ctx.screen.use()
self.use_texture.value = False
self.light.value = (67.69, -8.14, 52.49)
self.mvp.write((proj * lookat * rotate).astype('f4').tobytes())
self.color.value = (0.67, 0.49, 0.29)
self.objects['ground'].render()
self.color.value = (0.46, 0.67, 0.29)
self.objects['grass'].render()
self.color.value = (1.0, 1.0, 1.0)
self.objects['billboard'].render()
self.color.value = (0.2, 0.2, 0.2)
self.objects['billboard-holder'].render()
self.use_texture.value = True
if mode == 'render_to_texture':
self.texture1.use()
else:
self.texture2.use()
self.objects['billboard-image'].render()
def update(dt):
proj = Matrix44.perspective_projection(50, width / height, 0.1, 1000.0)
rotX = Matrix44.from_x_rotation(0)
rotY = Matrix44.from_y_rotation(time.clock() * 1.5)
rotZ = Matrix44.from_z_rotation(
180 * np.pi / 180) # rotate 180 degrees. Convert degrees to radians
trans = Matrix44.from_translation(
[np.sin(time.clock()) / 4,
np.sin(time.clock()) / 4,
-1.3]) # bounce diagonally from corner to corner, move back by -1.3
scale = Matrix44.from_scale([.5, .5, .5]) # uniformly scale by 0.5
tMatrix = proj * trans * scale * rotX * rotY * rotZ
prog['transform'].write(tMatrix.astype('f4').tobytes())
ctx.clear(.1, .1, .1)
vao.render()
def getModelMatrix(self):
scale = mat4.from_scale([0.2, 0.2, 0.2])
roty = mat4.from_y_rotation(-self.hAngle)
vdiff = self.vAngle - self.oldvAngle
rotx = mat4.from_x_rotation(self.getxRot(vdiff))
zdiff = self.hAngle - self.oldhAngle
rotz = mat4.from_z_rotation(-self.getzRot(zdiff))
trans = mat4.from_translation(self.position, dtype='f')
self.oldhAngle = self.hAngle
self.oldvAngle = self.vAngle
return scale * rotz * rotx * roty * trans
def build_matrix(self):
"""Builds and stores the transformation matrix internally"""
m = Matrix44.identity()
if isinstance(self.scale, list) or isinstance(self.scale, tuple):
m.m11 = self.scale[0]
m.m22 = self.scale[1]
m.m33 = self.scale[2]
else:
m *= self.scale
m.m44 = 1
m = Matrix44.from_x_rotation(math.radians(self.pitch)) * m
m = Matrix44.from_y_rotation(math.radians(self.yaw)) * m
m = Matrix44.from_z_rotation(math.radians(self.roll)) * m
m = Matrix44.from_translation(Vector3(self.position)) * m
self.m = numpy.array(m).astype("f4")
def render(self, time, frame_time):
self.ctx.clear(1.0, 1.0, 1.0)
# self.ctx.enable(mgl.DEPTH_TEST)
proj = Matrix44.perspective_projection(45.0, self.aspect_ratio, 0.1,
1000.0)
lookat = Matrix44.look_at(
(47.697, -8.147, 24.498),
(0.0, 0.0, 8.0),
(0.0, 0.0, 1.0),
)
rotate = Matrix44.from_z_rotation(np.sin(time) * 0.5 + 0.2)
w, h = self.texture.size
gw, gh = 16, 16
nx, ny, nz = int(w / gw), int(h / gh), 1
print('=' * 50)
self.compute['time'] = time
GL_WRITE_ONLY = 0x88B9
GL_R32F = 0x822E
self.texture.bind_to_image(0, GL_WRITE_ONLY, GL_R32F)
self.compute.run(nx, ny, nz)
print('-' * 50)
with self.scope:
self.prog['UseTexture'] = False
self.prog['Light'] = (67.69, -8.14, 52.49)
self.prog['Mvp'] = (proj * lookat * rotate).astype('f4').tobytes()
self.prog['Color'] = (0.67, 0.49, 0.29)
self.objects['ground'].render()
self.prog['Color'] = (0.46, 0.67, 0.29)
self.objects['grass'].render()
self.prog['Color'] = (1.0, 1.0, 1.0)
self.objects['billboard'].render()
self.prog['Color'] = (0.2, 0.2, 0.2)
self.objects['billboard-holder'].render()
self.prog['UseTexture'] = True
self.objects['billboard-image'].render()
def render(self, time, frame_time):
self.ctx.clear(1.0, 1.0, 1.0)
# self.ctx.enable(mgl.DEPTH_TEST)
proj = Matrix44.perspective_projection(45.0, self.aspect_ratio, 0.1, 1000.0)
lookat = Matrix44.look_at(
(47.697, -8.147, 24.498),
(0.0, 0.0, 8.0),
(0.0, 0.0, 1.0),
)
rotate = Matrix44.from_z_rotation(np.sin(time) * 0.5 + 0.2)
w, h = self.texture.size
gw, gh = 16, 16
nx, ny, nz = int(w/gw), int(h/gh), 1
print('=' * 50)
self.compute['time'] = time
GL_WRITE_ONLY = 0x88B9
GL_R32F = 0x822E
self.texture.bind_to_image(0,GL_WRITE_ONLY, GL_R32F)
self.compute.run(nx, ny, nz)
print('-' * 50)
with self.scope:
self.prog['UseTexture'] = False
self.prog['Light'] = (67.69, -8.14, 52.49)
self.prog['Mvp'] = (proj * lookat * rotate).astype('f4').tobytes()
self.prog['Color'] = (0.67, 0.49, 0.29)
self.objects['ground'].render()
self.prog['Color'] = (0.46, 0.67, 0.29)
self.objects['grass'].render()
self.prog['Color'] = (1.0, 1.0, 1.0)
self.objects['billboard'].render()
self.prog['Color'] = (0.2, 0.2, 0.2)
self.objects['billboard-holder'].render()
self.prog['UseTexture'] = True
self.objects['billboard-image'].render()
def build_matrix(self):
"""Builds and stores the viewport matrix internally
Automatically builds the MVP matrix as well"""
# Note that by nature, a camera perspective inverts everything
# So we negate everything and also do it in reverse
# Overrides PositionMatrix, reverse everything, ignore scale
m = Matrix44.identity()
m = Matrix44.from_translation(-1 * Vector3(self.position)) * m
m = Matrix44.from_z_rotation(-math.radians(self.roll)) * m
m = Matrix44.from_y_rotation(-math.radians(self.yaw)) * m
m = Matrix44.from_x_rotation(-math.radians(self.pitch)) * m
if self.tp:
# Third person enabled
m = Matrix44.from_translation([0, 0, -self.tp_distance]) * m
self.m = m
self.mvp = numpy.array(self.p * self.m).astype("f4")
def render(self):
width, height = self.wnd.size
self.ctx.screen.viewport = self.wnd.viewport
self.ctx.clear(1.0, 1.0, 1.0)
with self.ctx.scope(mgl.DEPTH_TEST):
proj = Matrix44.perspective_projection(45.0, width / height, 0.1,
1000.0)
lookat = Matrix44.look_at(
(47.697, -8.147, 24.498),
(0.0, 0.0, 8.0),
(0.0, 0.0, 1.0),
)
rotate = Matrix44.from_z_rotation(
np.sin(self.wnd.time) * 0.5 + 0.2)
self.prog['UseTexture'] = False
self.prog['Light'] = (67.69, -8.14, 52.49)
self.prog['Mvp'] = (proj * lookat * rotate).astype('f4').tobytes()
self.prog['Color'] = (0.67, 0.49, 0.29)
self.objects['ground'].render()
self.prog['Color'] = (0.46, 0.67, 0.29)
self.objects['grass'].render()
self.prog['Color'] = (1.0, 1.0, 1.0)
self.objects['billboard'].render()
self.prog['Color'] = (0.2, 0.2, 0.2)
self.objects['billboard-holder'].render()
self.prog['UseTexture'] = True
# self.texture.use()
self.sampler.use()
self.objects['billboard-image'].render()
def frames():
with create_context() as ctx:
renderer = Renderer(ctx, (w, h), mesh, projection=projection)
for _ in count():
t = time.time() - beginning
theta = t * angular_velocity
rotation = Matrix44.from_z_rotation(
theta[2]) * Matrix44.from_y_rotation(
theta[1]) * Matrix44.from_x_rotation(theta[0])
camera = Matrix44.from_translation(np.array([0, 0, -d
])) * rotation
renderer.render(camera, light1)
buffer = np.mean(renderer.snapshot2(), axis=-1)
lines = ascii.shade(buffer)
text = "resolution: {w}x{h}, fov: {fov:.2f}, fps: {fps:.2f}, d: {d:.2f}, by: vidstige 2020".format(
w=w, h=h, fov=fov, fps=fps, d=d)
lines[-2] = scroller(lines[-2], text, t, w=-12)
yield b"\033[2J\033[1;1H" + b'\n'.join(lines) + b"\n"
duration = (time.time() - beginning) - t
if dt - duration > 0:
time.sleep(dt - duration)
def render(self, time, frame_time):
self.ctx.clear(1.0, 1.0, 1.0)
# self.ctx.enable(mgl.DEPTH_TEST)
proj = Matrix44.perspective_projection(45.0, self.aspect_ratio, 0.1,
1000.0)
lookat = Matrix44.look_at(
(47.697, -8.147, 24.498),
(0.0, 0.0, 8.0),
(0.0, 0.0, 1.0),
)
rotate = Matrix44.from_z_rotation(np.sin(time) * 0.5 + 0.2)
self.fbo.clear(0, (1.0, 1.0, 1.0))
self.fbo.clear(-1, 1.0)
for scope in [self.scope1, self.scope2]:
with scope:
self.prog['UseTexture'] = False
self.prog['Light'] = (67.69, -8.14, 52.49)
self.prog['Mvp'] = (proj * lookat *
rotate).astype('f4').tobytes()
self.prog['Color'] = (0.67, 0.49, 0.29)
self.objects['ground'].render()
self.prog['Color'] = (0.46, 0.67, 0.29)
self.objects['grass'].render()
self.prog['Color'] = (1.0, 1.0, 1.0)
self.objects['billboard'].render()
self.prog['Color'] = (0.2, 0.2, 0.2)
self.objects['billboard-holder'].render()
self.prog['UseTexture'] = True
self.objects['billboard-image'].render()
def __init__(self,
shader,
transform_matrix=None,
parent_transform=None,
parent=None):
super().__init__(parent=parent)
self.shader = shader
self._ptr = parent_transform
self._pos = [0.0, 0.0, 0.0]
self._tm = Matrix44.from_translation(self._pos)
self._angle = 0.0
self._rm = Matrix44.from_z_rotation(self._angle)
self._scale = [1.0, 1.0, 1.0]
self._sm = Matrix44.from_scale(self.scale)
if transform_matrix:
self._trfm = transform_matrix
else:
self._trfm = self._tm * self._rm * self._sm
self._gtr = self._trfm # global transform include parent transformations
if self.parent and self.parent.__class__ is TransformGrp:
self._gtr = self.parent.transform * self._trfm
self.dirty = True # global transform calculated
def render(self, clr_color=(1.0, 1.0, 1.0)):
fbo = self.fbo
fbo.clear(*clr_color)
cam_ratio = self.fbo.size[0] / self.fbo.size[1]
p = Matrix44.perspective_projection(self.cam_angle, cam_ratio, 0.00001,
1000000.0)
v = Matrix44.look_at(
self.cam_pos,
(0, 0, 0),
self.cam_up,
)
rx = Matrix44.from_x_rotation(self.rotate_x)
ry = Matrix44.from_y_rotation(self.rotate_y)
rz = Matrix44.from_z_rotation(self.rotate_z)
m = rx * ry * rz
self._projection.write(p.astype('f4').tobytes())
mv = v * m
self._modelview.write(mv.astype('f4').tobytes())
n = mv.inverse.transpose()
self._normalMat.write(n.astype('f4').tobytes())
self._mode.value = 2 # Phong
#lightPos.value = tuple(tuple(n*Vector4.from_vector3(light_pos))[:3])
self._lightPos.value = tuple(self.light_pos)
self._lightColor.value = tuple(self.light_color)
self._lightPower.value = self.light_power
self._ambientColor.value = tuple(self.ambien_color)
self._diffuseColor.value = tuple(self.diffuse_color)
self._specColor.value = tuple(self.spec_color)
self._shininess.value = self.shininess
self._mainColor.value = tuple(self.main_color)
self.vao.render()
return fbo.read()
def render(self):
width, height = self.wnd.size
self.ctx.screen.viewport = self.wnd.viewport
self.ctx.clear(1.0, 1.0, 1.0)
with self.ctx.scope(mgl.DEPTH_TEST):
proj = Matrix44.perspective_projection(45.0, width / height, 0.1, 1000.0)
lookat = Matrix44.look_at(
(47.697, -8.147, 24.498),
(0.0, 0.0, 8.0),
(0.0, 0.0, 1.0),
)
rotate = Matrix44.from_z_rotation(np.sin(self.wnd.time) * 0.5 + 0.2)
self.prog['UseTexture'] = False
self.prog['Light'] = (67.69, -8.14, 52.49)
self.prog['Mvp'] = (proj * lookat * rotate).astype('f4').tobytes()
self.prog['Color'] = (0.67, 0.49, 0.29)
self.objects['ground'].render()
self.prog['Color'] = (0.46, 0.67, 0.29)
self.objects['grass'].render()
self.prog['Color'] = (1.0, 1.0, 1.0)
self.objects['billboard'].render()
self.prog['Color'] = (0.2, 0.2, 0.2)
self.objects['billboard-holder'].render()
self.prog['UseTexture'] = True
# self.texture.use()
self.sampler.use()
self.objects['billboard-image'].render()
def render(self, time, frame_time):
self.ctx.clear(1.0, 1.0, 1.0)
# self.ctx.enable(mgl.DEPTH_TEST)
proj = Matrix44.perspective_projection(45.0, self.aspect_ratio, 0.1, 1000.0)
lookat = Matrix44.look_at(
(47.697, -8.147, 24.498),
(0.0, 0.0, 8.0),
(0.0, 0.0, 1.0),
)
rotate = Matrix44.from_z_rotation(np.sin(time) * 0.5 + 0.2)
self.fbo.clear(0, (1.0, 1.0, 1.0))
self.fbo.clear(-1, 1.0)
for scope in [self.scope1, self.scope2]:
with scope:
self.prog['UseTexture'] = False
self.prog['Light'] = (67.69, -8.14, 52.49)
self.prog['Mvp'] = (proj * lookat * rotate).astype('f4').tobytes()
self.prog['Color'] = (0.67, 0.49, 0.29)
self.objects['ground'].render()
self.prog['Color'] = (0.46, 0.67, 0.29)
self.objects['grass'].render()
self.prog['Color'] = (1.0, 1.0, 1.0)
self.objects['billboard'].render()
self.prog['Color'] = (0.2, 0.2, 0.2)
self.objects['billboard-holder'].render()
self.prog['UseTexture'] = True
self.objects['billboard-image'].render()
def main():
glfw.init()
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
window = glfw.create_window(800, 600, "LearnOpenGL", None, None)
if not window:
print("Window Creation failed!")
glfw.terminate()
glfw.make_context_current(window)
glfw.set_window_size_callback(window, on_resize)
shader = Shader(CURDIR / 'shaders/5.1.transform.vs', CURDIR / 'shaders/5.1.transform.fs')
vertices = [
# positions tex_coords
0.5, 0.5, 0.0, 1.0, 1.0, # top right
0.5, -0.5, 0.0, 1.0, 0.0, # bottom right
-0.5, -0.5, 0.0, 0.0, 0.0, # bottom left
-0.5, 0.5, 0.0, 0.0, 1.0, # top left
]
vertices = (c_float * len(vertices))(*vertices)
indices = [
0, 1, 3,
1, 2, 3
]
indices = (c_uint * len(indices))(*indices)
vao = gl.glGenVertexArrays(1)
gl.glBindVertexArray(vao)
vbo = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo)
gl.glBufferData(gl.GL_ARRAY_BUFFER, sizeof(vertices), vertices, gl.GL_STATIC_DRAW)
ebo = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, ebo)
gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, gl.GL_STATIC_DRAW)
gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, 5 * sizeof(c_float), c_void_p(0))
gl.glEnableVertexAttribArray(0)
gl.glVertexAttribPointer(1, 2, gl.GL_FLOAT, gl.GL_FALSE, 5 * sizeof(c_float), c_void_p(3 * sizeof(c_float)))
gl.glEnableVertexAttribArray(1)
# -- load texture 1
texture1 = gl.glGenTextures(1)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture1)
# -- texture wrapping
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_REPEAT)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_REPEAT)
# -- texture filterting
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR)
img = Image.open(Tex('container.jpg')).transpose(Image.FLIP_TOP_BOTTOM)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, img.width, img.height, 0, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, img.tobytes())
gl.glGenerateMipmap(gl.GL_TEXTURE_2D)
# -- load texture 2
texture2 = gl.glGenTextures(1)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture2)
# -- texture wrapping
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_REPEAT)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_REPEAT)
# -- texture filterting
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR)
img = Image.open(Tex('awesomeface.png')).transpose(Image.FLIP_TOP_BOTTOM)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, img.width, img.height, 0, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, img.tobytes())
gl.glGenerateMipmap(gl.GL_TEXTURE_2D)
shader.use()
shader.set_int("texture1", 0)
shader.set_int("texture2", 1)
while not glfw.window_should_close(window):
process_input(window)
gl.glClearColor(.2, .3, .3, 1.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glActiveTexture(gl.GL_TEXTURE0)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture1)
gl.glActiveTexture(gl.GL_TEXTURE1)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture2)
translation = Matrix44.from_translation([0.5, -0.5, 0.0])
rotation = Matrix44.from_z_rotation(glfw.get_time())
transform = translation * rotation
shader.use()
shader.set_mat4('transform', transform)
gl.glBindVertexArray(vao)
gl.glDrawElements(gl.GL_TRIANGLES, 6, gl.GL_UNSIGNED_INT, c_void_p(0))
# -- second container
translation = Matrix44.from_translation([-0.5, 0.5, 0.0])
scale = Matrix44.from_scale([math.sin(glfw.get_time())]*3)
transform = translation * scale
shader.set_mat4('transform', transform)
gl.glDrawElements(gl.GL_TRIANGLES, 6, gl.GL_UNSIGNED_INT, c_void_p(0))
glfw.poll_events()
glfw.swap_buffers(window)
gl.glDeleteVertexArrays(1, id(vao))
gl.glDeleteBuffers(1, id(vbo))
gl.glDeleteBuffers(1, id(ebo))
glfw.terminate()
def update(self):
center = Matrix44.from_translation(self.target)
azim = Matrix44.from_z_rotation(self.azimuth)
elev = Matrix44.from_x_rotation(self.elevation)
dist = Matrix44.from_translation([0, 0, self.distance])
self.mat_lookat = center * azim * elev * dist
proj = Matrix44.perspective_projection(45.0, width / height, 0.1, 1000.0)
lookat = Matrix44.look_at(
(2, 2, 1), # eye / camera position
(0.0, 0.0, 0.0), # lookat
(0.0, 0.0, 1.0), # camera up vector
)
import matplotlib.pyplot as plt
f, axarr = plt.subplots(1, 13, sharex=True, sharey=True, figsize=(20, 2))
base_light = np.array((100, 100, 100))
for rot in np.arange(0, 6.1, 0.5):
fbo.clear(0.0, 0.0, 0.0, 0.0)
rotate = np.array(Matrix44.from_z_rotation(rot))
# this keep the light in place
prog['Lights'].value = tuple(
np.matmul(rotate[:3, :3], base_light).reshape(1, -1)[0])
# prog['Lights'].value = (10, 10, 10)
prog['Mvp'].write((proj * lookat * rotate).astype('f4').tobytes())
for vb, color in zip(vertex_buffers, FACE_COLORS):
prog['Color'].value = color
vb.render(moderngl.TRIANGLES)
img = Image.frombytes('RGB', fbo.size, fbo.read(), 'raw', 'RGB', 0, -1)
# plt.subplot(171 + (rot * 2))
def render(self, time, frame_time):
# Move our camera depending on keybinds
self.move_camera()
# Black background, turn on depth
self.ctx.clear(0.0, 0.0, 0.0)
self.ctx.enable(moderngl.DEPTH_TEST)
# Set our world scale for tessellation
self.scale.write(np.float32(self.camera.scale).astype('f4').tobytes()) # pylint: disable=too-many-function-args
# Put projection and look-at matrix into uniform
self.mvp.write((self.camera.mat_projection *
self.camera.mat_lookat).astype('f4').tobytes())
# Setup time, camera_position into shaders
self.time.write(np.float32(time * 0.2).astype('f4').tobytes()) # pylint: disable=too-many-function-args
self.camera_position.write(
self.camera.camera_position.xy.astype('f4').tobytes())
# Tessellate that floor!
self.vao.render(moderngl.PATCHES)
# ZEBRA TIME
# Put in projection, camera position (which we call light for some reason?), and the time
self.zmvp.write((self.camera.mat_projection *
self.camera.mat_lookat).astype('f4').tobytes())
self.zlight.write((self.camera.camera_position).astype('f4').tobytes())
self.ztime.write(np.float32(time * 0.2).astype('f4').tobytes()) # pylint: disable=too-many-function-args
self.zuse.write(np.float32(self.zebraTime).astype('f4').tobytes()) # pylint: disable=too-many-function-args
if not self.zebraTime:
# Make the car look forwards properly
wheresMyCar = Matrix44.from_translation([0, 0, -0.02])
wheresMyCar = Matrix44.from_x_rotation(np.pi) * wheresMyCar
wheresMyCar = Matrix44.from_z_rotation(
(np.pi / 2) - self.camera.angle) * wheresMyCar
# Put that movement into the shader
self.zrotate.write((wheresMyCar).astype('f4').tobytes())
# Set our texture, then render every part of the car with the right color
self.car["texture"].use()
for i in self.carDict:
color = self.carDict[i]
self.zcolor.write(np.array(color).astype('f4').tobytes())
self.car[i]["vao"].render()
else:
# We need to get our zebra looking the right way and also slightly lower than where he starts
rotateMyZebra = Matrix44.from_translation([0, -0.05, 0])
rotateMyZebra = Matrix44.from_x_rotation(np.pi / 2) * rotateMyZebra
rotateMyZebra = Matrix44.from_z_rotation(
(np.pi / 2) - self.camera.angle) * rotateMyZebra
# Put that movement into the shader
self.zrotate.write((rotateMyZebra).astype('f4').tobytes())
# Show us the zebra!
self.texture.use()
self.vao2.render()
def rotate_z(self, angle):
self._rotation *= Matrix44.from_z_rotation(angle)
self._update_uniforms()
def angle(self, val):
self._angle = val
self._rm = Matrix44.from_z_rotation(self._angle)
self.dirty = True
def render(self, time: float, _frame_time: float):
# pass 0: clear buffers
self.ctx.clear(1.0, 1.0, 1.0)
self.ctx.enable(moderngl.DEPTH_TEST)
cam_proj = Matrix44.perspective_projection(45.0, self.aspect_ratio,
0.1, 1000.0)
cam_look_at = Matrix44.look_at(
(47.697, -8.147, 24.498),
(0.0, 0.0, 8.0),
(0.0, 0.0, 1.0),
)
cam_rotate = Matrix44.from_z_rotation(np.sin(time) * 0.5 + 0.2)
cam_mvp = cam_proj * cam_look_at * cam_rotate
self.mvp.write(cam_mvp.astype('f4').tobytes())
# build light camera
light_rotate = Matrix44.from_z_rotation(time)
light_pos = light_rotate * Vector3((-60.69, -40.14, 52.49))
self.light.value = tuple(light_pos)
light_look_at = Matrix44.look_at(
light_pos,
target=(0, 0, 0),
up=(0.0, 0.0, 1.0),
)
# light projection matrix (scene dependant)
light_proj = Matrix44.perspective_projection(
fovy=90.0 / 4, # smaller value increase shadow precision
aspect=self.wnd.aspect_ratio,
near=60.0,
far=100.0)
# light model view projection matrix
mvp_light = light_proj * light_look_at
bias_matrix = (Matrix44.from_translation(
(0.5, 0.5, 0.5), dtype='f4') * Matrix44.from_scale(
(0.5, 0.5, 0.5), dtype='f4'))
mvp_depth_bias = bias_matrix * mvp_light
# send uniforms to shaders
self.mvp_depth.write(mvp_depth_bias.astype('f4').tobytes())
self.mvp_shadow.write(mvp_light.astype('f4').tobytes())
# pass 1: render shadow-map (depth framebuffer -> texture) from light view
self.fbo_depth.use()
self.fbo_depth.clear(1.0, 1.0, 1.0)
# https://moderngl.readthedocs.io/en/stable/reference/context.html?highlight=culling#moderngl.Context.front_face
# clock wise -> render back faces
self.ctx.front_face = 'cw'
for vao_shadow in self.objects_shadow.values():
vao_shadow.render()
# pass 2: render the scene and retro project depth shadow-map
# counter clock wise -> render front faces
self.ctx.front_face = 'ccw'
self.use_color_texture.value = False
self.ctx.screen.use()
self.sampler_depth.use(location=0)
self.tex_depth.use(location=0)
# pass 2a: render colored scene with shadow
for object_name, object_color in (
("ground", (0.67, 0.49, 0.29)),
("grass", (0.46, 0.67, 0.29)),
("billboard", (1.0, 1.0, 1.0)),
("billboard-holder", (0.2, 0.2, 0.2)),
):
self.color.value = object_color
self.objects[object_name].render()
# pass 2b: render textured scene with shadow
self.use_color_texture.value = True
self.objects['billboard-image'].render()
def renderSceneFromEye(self, fbo_curr, eEyePos):
fbo_curr.use()
fbo_curr.clear(1.0, 1.0, 1.0, 1.0)
'''
if self.fbo_left == fbo_curr:
fbo_curr.clear(0.32, 0.0, 0.0, 1.0)
else:
fbo_curr.clear(0.0, 0.0, 0.32, 1.0)
'''
ipd_translate = None
if eyePosition.LEFT == eEyePos:
ipd_translate = Matrix44.from_translation(Vector4([ 0.0, 5.0, 0.0, 1.0]))
elif eyePosition.RIGHT == eEyePos:
ipd_translate = Matrix44.from_translation(Vector4([ 0.0, -5.0, 0.0, 1.0]))
else:
ipd_translate = Matrix44.from_translation(Vector4([ 0.0, 0.0, 0.0, 1.0]))
self.ctx.enable(moderngl.DEPTH_TEST)
'''
self.mvp_sample.write((self.proj_sample * self.lookat_sample).astype('f4').tobytes())
self.texture_sample.use()
self.vao_sample.render(moderngl.TRIANGLE_STRIP)
'''
time_sample = time.clock() - self.start_time
rotate = Matrix44.from_z_rotation(np.sin(time_sample*10.0) * 0.5 + 0.2)
self.bUseTexture_sample.value = False
self.light_sample.value = (67.69, -8.14, 52.49)
if visualMode.STEREO == self.eVisualMode:
self.mvp_sample.write((self.proj_sample_stereo * self.lookat_sample * ipd_translate * rotate).astype('f4').tobytes())
else:
self.mvp_sample.write((self.proj_sample * self.lookat_sample * ipd_translate * rotate).astype('f4').tobytes())
#self.mvp_sample.write((self.proj_sample * self.lookat_sample * ipd_translate).astype('f4').tobytes())
#self.mvp_sample.write((self.proj_sample * self.lookat_sample).astype('f4').tobytes())
#self.mvp_sample.write((self.proj_sample * ipd_translate * rotate).astype('f4').tobytes())
self.color_sample.value = (0.67, 0.49, 0.29)
self.objects['ground'].render()
self.color_sample.value = (0.46, 0.67, 0.29)
self.objects['grass'].render()
self.color_sample.value = (1.0, 1.0, 1.0)
self.objects['billboard'].render()
self.color_sample.value = (0.2, 0.2, 0.2)
self.objects['billboard-holder'].render()
self.bUseTexture_sample.value = True
self.texture_sample.use()
self.objects['billboard-image'].render()
vertices = np.dstack([x, y, z])
print(vertices.shape)
vbo = ctx.buffer(vertices.astype('f4').tobytes())
vao = ctx.simple_vertex_array(prog, vbo, 'in_vert')
width = 512
height = 512
ctx.enable(moderngl.DEPTH_TEST)
fbo = ctx.simple_framebuffer((width, height))
fbo.use()
fbo.clear(1.0, 1.0, 1.0, 1.0)
proj = Matrix44.perspective_projection(45.0, width / height, 0.1, 1000.0)
lookat = Matrix44.look_at(
(0, 1, 3), # eye / camera position
(0.0, 0.0, 0.0), # lookat
(0.0, 0.0, 1.0), # camera up vector
)
rotate = Matrix44.from_z_rotation(np.sin(0) * 0.5 + 0.2)
prog['Mvp'].write((proj * lookat * rotate).astype('f4').tobytes())
# prog['Light'].value = (67.69, -8.14, 52.49)
prog['Color'].value = (1, 0, 0)
vao.render(moderngl.LINE_STRIP)
Image.frombytes('RGB', fbo.size, fbo.read(), 'raw', 'RGB', 0, -1).show()
def rotate(self, angle):
self._angle += angle
self._rm = Matrix44.from_z_rotation(self._angle)
self.dirty = True
def rotate_z(self, angle):
"""Helper function that multiplies the `model_matrix` with a rotation
matrix around the z axis."""
m = Matrix44.from_z_rotation(angle)
self.model_matrix = m.dot(self.model_matrix)
