def generate_lines(obj: Object, camera: Camera, viewport: Polygon, front_brightness: float, back_brightness: float) -> List[Line]:
# Create transformation matrix
translation = Matrix44.from_translation(obj.translation)
rotation = Matrix44.from_eulers(obj.rotation)
projection = Matrix44.perspective_projection(
camera.fovy, camera.aspect, camera.near, camera.far)
cam = matrix44.create_look_at(camera.eye, camera.target, [0, 1.0, 0])
matrix = projection * cam * translation * rotation
# Transform vertices, remove hidden faces and get edges for faces
# TODO: Make the rendering pipeline more generic
vertices = [matrix * vertex for vertex in obj.mesh.vertices]
front_faces = [face for face in obj.mesh.faces
if cull_face(vertices, face, 'front')]
back_faces = [face for face in obj.mesh.faces
if cull_face(vertices, face, 'back')]
front_edges = find_edges(front_faces, obj.mesh.edges)
back_edges = find_edges(back_faces, obj.mesh.edges)
# Clip lines
lines = edges_to_lines(front_edges, vertices, front_brightness) + \
edges_to_lines(back_edges, vertices, back_brightness)
return [clipped
for clipped in [clip_line(line, viewport) for line in lines]
if clipped is not None]
def _gl_look_at(self, pos, target, up) -> numpy.ndarray:
"""The standard lookAt method.
Args:
pos: current position
target: target position to look at
up: direction up
Returns:
numpy.ndarray: The matrix
"""
z = vector.normalise(pos - target)
x = vector.normalise(vector3.cross(vector.normalise(up), z))
y = vector3.cross(z, x)
translate = Matrix44.identity(dtype="f4")
translate[3][0] = -pos.x
translate[3][1] = -pos.y
translate[3][2] = -pos.z
rotate = Matrix44.identity(dtype="f4")
rotate[0][0] = x[0] # -- X
rotate[1][0] = x[1]
rotate[2][0] = x[2]
rotate[0][1] = y[0] # -- Y
rotate[1][1] = y[1]
rotate[2][1] = y[2]
rotate[0][2] = z[0] # -- Z
rotate[1][2] = z[1]
rotate[2][2] = z[2]
return rotate * translate
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 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 fit_inside(self, box: Box, anchor: Vector3):
scale = np.amin(box.size() / self.bounding_box().size())
extra = box.size() - (self.bounding_box().size() * scale)
matrix = Matrix44.from_translation(-self.bounding_box().min)
matrix = Matrix44.from_scale([scale, scale, scale]) * matrix
matrix = Matrix44.from_translation(box.min + (extra * anchor)) * matrix
self.transform(matrix)
def render(self, time, frame_time):
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,
100.0)
camera_pos = np.array([
np.cos(self.angleY) * np.cos(self.angleX),
np.sin(self.angleX),
np.sin(self.angleY)
]) * self.distance
lookat = Matrix44.look_at(
tuple(camera_pos + self.origin), # eye
tuple(self.origin), # target
(0.0, 0.0, 1.0), # up
)
self.light.value = (0, -3, 3)
self.texture.use()
for coord in self.coords:
model = Matrix44.from_translation(coord)
self.mvp.write((proj * lookat * model).astype('f4'))
self.vao.render()
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 on_draw(self):
self.ctx.enable_only(self.ctx.CULL_FACE, self.ctx.DEPTH_TEST)
# Draw the current cube using the last one as a texture
self.fbo1.use()
self.fbo1.clear(color=(1.0, 1.0, 1.0, 1.0), normalized=True)
rotate = Matrix44.from_eulers(
(self.time, self.time * 0.77, self.time * 0.01), dtype='f4')
translate = Matrix44.from_translation((0, 0, -1.75), dtype='f4')
modelview = translate * rotate
if self.frame > 0:
self.program['use_texture'] = 1
self.fbo2.color_attachments[0].use()
self.program['modelview'] = modelview.flatten()
self.cube.render(self.program)
self.ctx.disable(self.ctx.DEPTH_TEST)
# Draw the current cube texture
self.use()
self.clear()
self.fbo1.color_attachments[0].use()
self.quad_fs.render(self.quad_program)
# Swap offscreen buffers
self.fbo1, self.fbo2 = self.fbo2, self.fbo1
self.frame += 1
def render(self):
if self.current_pointcloud < len(self.pointclouds):
self.handle_mouse()
self.handle_keys()
self.ctx.viewport = self.wnd.viewport
self.ctx.clear(0.0, 0.0, 0.0)
self.ctx.enable(mgl.BLEND)
vertices = np.load(file=self.pointclouds[self.current_pointcloud])
self.vbo.write(vertices.astype('f4').tobytes())
model = Matrix44.from_scale((self.zoom, self.zoom, self.zoom))
model *= Matrix44.from_x_rotation(-self.theta[1])
model *= Matrix44.from_y_rotation(-self.theta[0])
view = Matrix44.look_at((0.0, 0.0, 1.0), (0.0, 0.0, 0.0),
(0.0, 1.0, 0.0))
projection = Matrix44.perspective_projection(
45.0, self.wnd.ratio, 0.1, 100.0)
self.mvp.write((projection * view * model).astype('f4').tobytes())
self.vao.render(mode=mgl.POINTS)
self.sleep_to_target_fps(60)
self.current_pointcloud += 1
else:
if self.out_dir is None:
self.current_pointcloud = 0
else:
QtCore.QCoreApplication.instance().quit()
def on_render(self, gl_area, gl_context):
glClearColor(0.0, 0.0, 0.0,
0.0) # Set the background colour for the window -> Black
glClear(
GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT
) # Clear the window background colour to black by resetting the COLOR_BUFFER and clear the DEPTH_BUFFER
eye = (0.0, 5, 18.0) # Eye coordinates (location of the camera)
target = (0.0, 7.0, 0.0
) # Target coordinates (where the camera is looking)
up = (0.0, 1.0, 0.0) # A vector representing the 'up' direction.
view_matrix = Matrix44.look_at(eye, target,
up) # Calculate the view matrix
glUniformMatrix4fv(self.__location_viewMatrix, 1, GL_FALSE,
view_matrix)
model_matrix = Matrix44.from_translation(
[0.0, 0.0, 0.0]) * pyrr.matrix44.create_from_axis_rotation(
(0.0, 1.0, 0.0), self.application_clock) * Matrix44.from_scale(
[1.0, 1.0, 1.0])
glUniformMatrix4fv(
self.__location_modelMatrix, 1, GL_FALSE, model_matrix
) # Update the value of the ModelViewPerspective matrix attribute variable in the vertex buffer
glBindVertexArray(self.chibi[0])
glEnableVertexAttribArray(0)
glEnableVertexAttribArray(1)
glBindTexture(GL_TEXTURE_2D, self.chibi[2])
glDrawArrays(GL_TRIANGLES, 0, self.chibi[1])
self.queue_draw() # Schedules a redraw for Gtk.GLArea
def processData(data):
if isinstance(data, Matrix44):
return data
elif isinstance(data, list) and len(data) == 3:
return Matrix44([data[0], data[1], data[2], data[3]])
else:
return Matrix44()
def test_oo_examples(self):
from pyrr import Quaternion, Matrix44, Vector3
import numpy as np
point = Vector3([1., 2., 3.])
orientation = Quaternion()
translation = Vector3()
scale = Vector3([1., 1., 1.])
# translate along X by 1
translation += [1.0, 0.0, 0.0]
# rotate about Y by pi/2
rotation = Quaternion.from_y_rotation(np.pi / 2.0)
orientation = rotation * orientation
# create a matrix
# start our matrix off using the scale
matrix = Matrix44.from_scale(scale)
# apply our orientation
# we can multiply matricies and quaternions directly!
matrix = matrix * orientation
# apply our translation
translation = Matrix44.from_translation(translation)
matrix = matrix * translation
# transform our point by the matrix
# vectors are transformable by matrices and quaternions directly
point = matrix * point
def on_render(self, gl_area, gl_context):
glClearColor(0.0, 0.0, 0.0, 0.0) # Set the background colour for the window -> Black
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # Clear the window background colour to black by resetting the COLOR_BUFFER and clear the DEPTH_BUFFER
eye = (0.0, 5, 18.0) # Eye coordinates (location of the camera)
target = (0.0, 7.0, 0.0) # Target coordinates (where the camera is looking)
up = (0.0, 1.0, 0.0) # A vector representing the 'up' direction.
view_matrix = Matrix44.look_at(eye, target, up) # Calculate the view matrix
model_matrix = Matrix44.from_translation([0.0, 0.0, 0.0]) * pyrr.matrix44.create_from_axis_rotation((0.0, 1.0, 0.0), self.application_clock) * Matrix44.from_scale([1.0, 1.0, 1.0])
# self.camera.move()
# for entity in list_of_entities_to_render:
# self.renderer.processEntity(entity)
# self.renderer.render(self.lights, self.camera)
# self.guiRenderer.render(self.guis)
glUseProgram(self.shader) # Tells OpenGL to use the shader program for rendering geometry
glUniformMatrix4fv(self.viewMatrixLocationInShader, 1, GL_FALSE, view_matrix)
glUniformMatrix4fv(self.modelMatrixLocationInShader, 1, GL_FALSE, model_matrix)
glUniform3f(self.lightPositionLocationInShader, 0.0, 3.0, 10.0)
glUniform3f(self.lightColourLocationInShader, 1.0, 1.0, 1.0)
glUniform1f(self.useFakeLightingLocationInShader, 0.0)
glBindVertexArray(self.vertex_array_object) # Binds the self.vertex_array_object to the OpenGL pipeline vertex target
glDrawArrays(GL_TRIANGLES, 0, len(self.blenderModel.vertices))
glBindVertexArray(0)
glUseProgram(0) # Tells OpenGL to use the shader program for rendering geometry
self.queue_draw() # Schedules a redraw for Gtk.GLArea
def __init__(self):
self.color = Color(0.0, 0.0, 0.0)
self.aabb = aabb.create_from_bounds([0.0, 0.0, 0.0], [0.5, 0.5, 0.5])
self.translation_matrix = Matrix44.identity()
self.scale_matrix = Matrix44.identity()
self.rotation_matrix = Matrix44.identity()
self.selected = False
def render(self):
angle = self.wnd.time * 0.2
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)
camera_pos = (np.cos(angle) * 5.0, np.sin(angle) * 5.0, 2.0)
proj = Matrix44.perspective_projection(45.0, width / height, 0.1,
1000.0)
lookat = Matrix44.look_at(
camera_pos,
(0.0, 0.0, 0.5),
(0.0, 0.0, 1.0),
)
self.mvp.write((proj * lookat).astype('f4').tobytes())
self.light.value = camera_pos
crate_z = np.sin(self.crate_a * self.wnd.time + self.crate_b) * 0.2
coordinates = np.dstack([self.crate_x, self.crate_y, crate_z])
self.vbo2.write(coordinates.astype('f4').tobytes())
self.vao.render(instances=1024)
def look_at(self, position, target, world_up):
# 1.Position = known
# 2.Calculate cameraDirection
zaxis = vector.normalise(position - target)
# 3.Get positive right axis vector
xaxis = vector.normalise(
vector3.cross(vector.normalise(world_up), zaxis))
# 4.Calculate the camera up vector
yaxis = vector3.cross(zaxis, xaxis)
# create translation and rotation matrix
translation = Matrix44.identity()
translation[3][0] = -position.x
translation[3][1] = -position.y
translation[3][2] = -position.z
rotation = Matrix44.identity()
rotation[0][0] = xaxis[0]
rotation[1][0] = xaxis[1]
rotation[2][0] = xaxis[2]
rotation[0][1] = yaxis[0]
rotation[1][1] = yaxis[1]
rotation[2][1] = yaxis[2]
rotation[0][2] = zaxis[0]
rotation[1][2] = zaxis[1]
rotation[2][2] = zaxis[2]
return translation * rotation
def render(self, batch_size):
warp = np.empty(
(batch_size, self.height, self.width, 2), dtype=np.float32)
for i in range(batch_size):
translation = Matrix44.from_translation((
np.random.uniform(self.x_low, self.x_high),
np.random.uniform(self.y_low, self.y_high),
0.0
))
rotation = Matrix44.from_matrix33(
self.rand_rotation_matrix(self.deflection)
)
view = Matrix44.look_at(
(0.0, 0.0, np.random.uniform(self.close, self.far)),
(0.0, 0.0, 0.0),
(0.0, 1.0, 0.0),
)
projection = Matrix44.perspective_projection(
45.0, self.width / self.height, 0.1, 1000.0
)
# TODO: translation or rotation first?
transform = projection * view * translation * rotation
self.fbo.use()
self.fbo.clear()
self.mvp.write(transform.astype('f4').tobytes())
self.vao.render()
framebuffer = self.fbo.read(components=2, floats=True)
warp[i] = np.frombuffer(framebuffer, dtype=np.float32).reshape(
(self.height, self.width, 2))[::-1]
return warp
def render(ctx, prog, objects, fbo, q, x, img):
print(q)
m = q.rotation_matrix
#q から 回転ベクトルだけ取り出して 変換かければ良さそう
eye = np.array([47.697, -8.147, 24.498])
eyedir = np.array([-47.7, 8.15, -16.5])
up = np.array([0.0, 0.0, 1.0])
mvp = prog['Mvp']
proj = Matrix44.perspective_projection(58.0, float(W) / H, 0.1, 1000.0)
lookat = Matrix44.look_at(
eye,
np.dot(m, eyedir) + eye,
np.dot(m, up),
)
print(m)
mvp.write((proj * lookat).astype('f4').tobytes())
color = prog['Color']
fbo.clear(0.0, 0.0, 0.0, 0.0)
color.value = (0.67, 0.49, 0.29)
objects['ground'].render()
color.value = (0.46, 0.67, 0.29)
objects['grass'].render()
myimg = np.asarray(
Image.frombytes('RGBA', fbo.size, fbo.read(components=4)))
obj_mask = myimg[:, :, 3]
obj_img = myimg[:, :, 0:3]
idx = (obj_mask != 0)
img[idx] = obj_img[idx]
cv2.imshow('RealSense', img)
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 __init__(self, data):
self.name = data.get('name')
self.children = data.get('children')
self.matrix = data.get('matrix')
self.mesh = data.get('mesh')
self.camera = data.get('camera')
self.translation = data.get('translation')
self.rotation = data.get('rotation')
self.scale = data.get('scale')
if self.matrix:
self.matrix = Matrix44(self.matrix)
else:
self.matrix = Matrix44.identity()
if self.translation is not None:
self.matrix = self.matrix * Matrix44.from_translation(self.translation)
if self.rotation is not None:
quat = quaternion.create(
x=self.rotation[0],
y=self.rotation[1],
z=self.rotation[2],
w=self.rotation[3],
)
self.matrix = self.matrix * Matrix44.from_quaternion(quat).transpose()
if self.scale is not None:
self.matrix = self.matrix * Matrix44.from_scale(self.scale)
def __init__(self,
width=1280,
height=720,
name='OpenGL Window',
cameraSpeed=0.1,
mouseSpeed=0.3,
invertMouse=False,
resizable=False,
vsync=False):
super().__init__(width, height, name, resizable=resizable, vsync=vsync)
self.cameraSpeed = cameraSpeed
self.mouseSpeed = mouseSpeed
self.invertMouse = invertMouse
self.cameraPos = Vector3([0.0, 0.0, 0.0])
self.cameraTarget = Vector3([0.0, 0.0, -1.0])
self.cameraUp = Vector3([0.0, 1.0, 0.0])
self.worldUp = Vector3([0.0, 1.0, 0.0])
self.yaw = -90.0
self.pitch = 0.0
self.pressedKeys = []
self.set_mouse_visible(False)
self.set_exclusive_mouse(True)
# Matrices
self.projection = Matrix44.perspective_projection(
45.0, width / height, 0.1, 1000.0)
self.view = Matrix44.look_at(self.cameraPos, self.cameraTarget,
self.cameraUp)
def test_oo_examples(self):
from pyrr import Quaternion, Matrix44, Vector3
import numpy as np
point = Vector3([1.,2.,3.])
orientation = Quaternion()
translation = Vector3()
scale = Vector3([1.,1.,1.])
# translate along X by 1
translation += [1.0, 0.0, 0.0]
# rotate about Y by pi/2
rotation = Quaternion.from_y_rotation(np.pi / 2.0)
orientation = rotation * orientation
# create a matrix
# start our matrix off using the scale
matrix = Matrix44.from_scale(scale)
# apply our orientation
# we can multiply matricies and quaternions directly!
matrix = matrix * orientation
# apply our translation
translation = Matrix44.from_translation(translation)
matrix = matrix * translation
# transform our point by the matrix
# vectors are transformable by matrices and quaternions directly
point = matrix * point
def init(self, width, height, render_samples=16):
if not self._initialized:
self.ctx = ContextManager.get_offscreen_context()
self._scene = Scene(self.ctx)
self._scene.init()
# A fullscreen quad just for rendering one pass to offscreen textures
self.quad_fs = QuadFS(self.ctx)
self.quad_fs.m_model.write(
Matrix44.identity().astype('f4').tobytes())
self.quad_fs.m_view.write(
Matrix44.identity().astype('f4').tobytes())
self.quad_fs.m_proj.write(
Matrix44.orthogonal_projection(-1, 1, 1, -1, 1,
10).astype('f4').tobytes())
self.quad_fs.flip_v.value = 0
# aa sampler
self.setRenderSamples(render_samples)
self._initialized = True
print("Workbench initialized")
if (self._width, self._height) != (width, height):
self.resize(width, height)
def select_object(self, camera, x, y):
red = green = blue = 8
def make_mask(bits):
return 0xFFFFFFFF >> (32 - bits)
red_mask = make_mask(red) << (green + blue)
green_mask = make_mask(green) << blue
blue_mask = make_mask(blue)
red_shift = green + blue
green_shift = blue
for i, obj in enumerate(self.objects):
r = ((i & red_mask) >> red_shift) / 255.0
g = ((i & green_mask) >> green_shift) / 255.0
b = (i & blue_mask) / 255.0
camera.push_matrix()
camera.matrix *= Matrix44.from_translation(obj.position) * Matrix44.from_scale(obj.scale)
obj.render_for_selection_hit(camera, r, g, b)
camera.pop_matrix()
data = struct.unpack('b'*3, glReadPixels(x, y, 1, 1, GL_RGB, GL_UNSIGNED_BYTE))
index = (data[0] << red_shift) | (data[1] << green_shift) | data[2]
if self.objects and 0 <= index < len(self.objects):
return self.objects[index]
return None
def __init__(self, data):
self.name = data.get("name")
self.children = data.get("children")
self.matrix = data.get("matrix")
self.mesh = data.get("mesh")
self.camera = data.get("camera")
self.translation = data.get("translation")
self.rotation = data.get("rotation")
self.scale = data.get("scale")
if self.matrix:
self.matrix = Matrix44(self.matrix)
else:
self.matrix = Matrix44.identity()
if self.translation is not None:
self.matrix = self.matrix * Matrix44.from_translation(
self.translation)
if self.rotation is not None:
quat = quaternion.create(
x=self.rotation[0],
y=self.rotation[1],
z=self.rotation[2],
w=self.rotation[3],
)
self.matrix = self.matrix * Matrix44.from_quaternion(
quat).transpose()
if self.scale is not None:
self.matrix = self.matrix * Matrix44.from_scale(self.scale)
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.camera = KeyboardCamera(self.wnd.keys,
aspect_ratio=self.wnd.aspect_ratio)
self.terrain_program = self.load_program('my_shader.glsl')
self.ctx.front_face = 'cw'
# self.ctx.wireframe = True
self.translate = Matrix44.from_translation((0, 1., .25))
self.rotate = Matrix44.look_at((0., 1., .25), (0., 0., -1.),
(0., 1., 0.))
self.projection = (self.camera.projection.matrix *
(self.translate * self.rotate)).astype('f4')
self.terrain_program['projection'].write(self.projection.tobytes())
terrain_resolution = 5
points = generate(terrain_resolution).astype('f4')
self.buffer = self.ctx.buffer(points)
indices = generate_index_buffer(terrain_resolution).astype('i4')
print(indices)
self.index_buffer = self.ctx.buffer(indices)
self.vao_1 = VAO(name='vao_1')
self.vao_1.buffer(self.buffer, '3f', ['in_position'])
self.vao_1.index_buffer(self.index_buffer)
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 __init__(self, cam_intrinsic_settings = CameraIntrinsicSettings(), scene_object = None):
super(Camera, self).__init__(scene_object)
self.camera_matrix = Matrix44.identity()
self.projection_matrix = Matrix44.identity()
self.set_instrinsic_settings(cam_intrinsic_settings)
def update(self):
"""
Updates the camera's view matricies to match the camera's settings.
"""
eye = self.eye
at = self.at
up = self.up
# orthonormalization of camera axes
n = (eye - at).normalised
u = up.cross(n).normalised
v = n.cross(u)
# camera view matrix
self.view = Matrix44([[u.x, u.y, u.z, -u.dot(eye)],
[v.x, v.y, v.z, -v.dot(eye)],
[n.x, n.y, n.z, -n.dot(eye)], [0, 0, 0, 1]])
fovx = self.fovx
aspect = self.aspect
near = self.near
far = self.far
# symmetrical perspective projection matrix
recip_tan_fov = 1 / np.tan(fovx / 2)
a = recip_tan_fov
b = aspect * recip_tan_fov
c = -(far + near) / (far - near)
d = -2 * far * near / (far - near)
self.proj = Matrix44([[a, 0, 0, 0], [0, b, 0, 0], [0, 0, c, d],
[0, 0, -1, 0]])
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 __init__(self, ctx, width, height, Type, id):
self.ctx = ctx
self.type = Type
self.ParentCube = id
self.color = self.fromTypeToColor(self.type)
self.width = width
self.height = height
self.x_rot = 0
self.y_rot = 0
self.x_last = 0
self.y_last = 0
self.x_cur = 0
self.y_cur = 0
self.isRotating = False
self.orientation = pyrr.quaternion.create(0.0, 0.0, 0.0, 1.0)
self.proj = Matrix44.perspective_projection(45.0,
self.width / self.height,
0.1, 100.0)
self.camera_pos = [0, 3, -8.0]
self.vertexes = VERTICES[self.fromTypeTOIndex(Type)]
self.rotation = Matrix44.identity()
self.rotationLayer = Matrix44.identity()
self.degree = 0
self.translation = Matrix44.identity()
self.view = Matrix44.look_at(
self.camera_pos, # position of camera in world coordinate
(0.0, 0.0, 0.0), # target
(0.0, 1.0, 0.0),
)
self.prog = self.ctx.program(
vertex_shader='''
#version 330
uniform mat4 Mvp;
in vec3 in_vert;
in vec3 in_color;
out vec3 v_color;
out vec4 Position;
void main() {
gl_Position = Mvp*vec4(in_vert, 1.0);
v_color = in_color;
Position=vec4(in_vert,1.0);
}
''',
fragment_shader='''
#version 330
in vec3 v_color;
in vec4 Position;
out vec4 f_color;
void main()
{
f_color=vec4(v_color,1);
}
''',
)
def createTransformationMatrix(position, rotX=0, rotY=0, rotZ=0, scale=1):
if rotX == 0 and rotY == 0 and rotZ == 0:
return Matrix44.from_translation(position) * Matrix44.from_scale(
[scale, scale, scale])
return Matrix44.from_translation(
position) * pyrr.matrix44.create_from_axis_rotation(
(rotX, rotY, rotZ), rotY) * Matrix44.from_scale(
[scale, scale, scale])
def update(dt):
ctx.viewport = (0, 0, wnd.width, wnd.height)
ctx.clear(0.9, 0.9, 0.9)
ctx.enable(ModernGL.DEPTH_TEST)
proj = Matrix44.perspective_projection(45.0, wnd.width / wnd.height, 0.1, 1000.0)
lookat = Matrix44.look_at(
(40.0, 30.0, 20.0),
(0.0, 0.0, 0.0),
(0.0, 0.0, 1.0),
def draw(self, *args):
width, height = Window.size
self.ctx.viewport = (0, 0, width, height)
self.ctx.clear(0.9, 0.9, 0.9)
self.ctx.enable(ModernGL.DEPTH_TEST)
proj = Matrix44.perspective_projection(45.0, width / height, 0.1, 1000.0)
lookat = Matrix44.look_at(
(40.0, 30.0, 20.0),
(0.0, 0.0, 0.0),
(0.0, 0.0, 1.0),
def render(self, time, frame_time):
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(
(40.0, 30.0, 30.0),
(0.0, 0.0, 0.0),
(0.0, 0.0, 1.0),
)
self.mvp.write((proj * lookat).astype('f4').tobytes())
self.vao.render(moderngl.LINES)
def render(self):
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, self.wnd.ratio, 0.1, 1000.0)
lookat = Matrix44.look_at(
(40.0, 30.0, 30.0),
(0.0, 0.0, 0.0),
(0.0, 0.0, 1.0),
)
self.prog['Mvp'] = (proj * lookat).astype('f4').tobytes()
self.vao.render(mgl.LINES)
def render(self, time, frame_time):
angle = time * 0.2
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(
(np.cos(angle), np.sin(angle), 0.8),
(0.0, 0.0, 0.1),
(0.0, 0.0, 1.0),
)
self.mvp.write((proj * lookat).astype('f4').tobytes())
self.vao.render(moderngl.TRIANGLE_STRIP)
def render(self, time: float, frame_time: float):
camera_pos = (np.cos(time) * 300.0, np.sin(time) * 300.0, 120.0)
proj = Matrix44.perspective_projection(45.0, self.aspect_ratio, 0.1, 1000.0)
lookat = Matrix44.look_at(
camera_pos,
(0.0, 0.0, 50.0),
(0.0, 0.0, 1.0),
)
with self.scope:
self.prog['Mvp'] = (proj * lookat).astype('f4').tobytes()
self.prog['Eye'] = camera_pos
self.ctx.clear(1.0, 1.0, 1.0)
self.vao.render()
def init(wid, hig):
"""Initialises the display."""
global modelmtx, chaem
GL.glClearColor(0.0, 0.2, 0.15, 0.0)
GL.glClearDepth(1.0)
GL.glDepthFunc(GL.GL_LESS)
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glShadeModel(GL.GL_SMOOTH)
shades()
rematr(wid, hig)
modelmtx = matrix.from_scale([2, 2, 2]) * matrix.from_translation([0, 0, -.5])
chaem = Raimv((), deltam)
chaem.rotspe = 2*pi
GL.glUniformMatrix4fv(GL.glGetUniformLocation(shaderp, 'viewmatrix'), 1, False, chaem.lookat())
GL.glUniformMatrix4fv(GL.glGetUniformLocation(shaderp, 'modelmatrix'), 1, False, modelmtx)
def resizeGL(self, w, h):
glViewport(0, 0, w, h)
self.viewport = (w, h)
self.projTransform = Matrix44.perspective_projection(
50, float(w) / h,
0.01, 100.0,
)
def mouseMoveEvent(self, event):
pos = event.pos()
# compute point on sphere under pointer
(w, h) = self.viewport
t = (2*self.old_pos.x() - w) / float(w)
u = -(2*self.old_pos.y() - h) / float(h)
# compute inverse of view transform ignoring rotation
m = Matrix44.from_translation(Vector3([0, 0, -self.zoom])) * self.projTransform
m = matrix44.inverse(m)
rayOri = m * Vector3([t, u, -1])
rayEnd = m * Vector3([t, u, 1])
rayDir = rayEnd - rayOri
self.picked = intersectRayUnitSphere(rayOri, rayDir)
# rotate on left-drag
if event.buttons() & QtCore.Qt.LeftButton > 0:
# the rotation vector is the displacement vector rotated by 90 degrees
dx = pos.x() - self.old_pos.x()
dy = pos.y() - self.old_pos.y()
if dx == 0 and dy == 0:
return
v = Vector3([dy, dx, 0])
# update the current orientation
self.layers.multiplyOrientation(Quaternion.from_axis_rotation(
-v.normalised,
-v.length * 0.002,
))
elif event.buttons() & QtCore.Qt.RightButton > 0:
dz = pos.y() - self.old_pos.y()
self.zoom = max(0, self.zoom + dz / 100.0)
self.old_pos = pos
self.update()
def rematr(wid, hig):
"""Resets the projection matrix."""
if hig == 0:
hig = 1
# This method has FOV in degrees for some reason???
pm = matrix.perspective_projection(whel, wid/hig, 0.01, 100)
GL.glUniformMatrix4fv(GL.glGetUniformLocation(shaderp, 'projectmatrix'), 1, False, pm)
def onsc(window, yof):
"""Wheels. """
global whel
sz = window.get_size()
whel = clip(whel - yof, 1, 180)
pm = matrix.perspective_projection(whel, sz[0] / sz[1], 0.01, 100)
GL.glUniformMatrix4fv(GL.glGetUniformLocation(shaderp, 'projectmatrix'), 1, False, pm)
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 draw():
"""Put the main drawing code in here."""
global luxp
chaem.mochae(timedelta)
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
GL.glEnable(GL.GL_TEXTURE_2D)
GL.glUseProgram(shaderp)
luxp = [sin(lasttime) * 5, cos(lasttime) * 5, 0.0]
GL.glUniform3f(GL.glGetUniformLocation(shaderp, 'lightPos'), *luxp)
GL.glUniform3f(GL.glGetUniformLocation(shaderp, 'viewpos'), *chaem.pos)
rematr()
architincture.draw()
mmoodd = modelmatrix * matrix.from_scale([0.2, 0.2, 0.2]) * matrix.from_translation(luxp) * \
matrix.from_eulers([lasttime, lasttime, lasttime])
lux.draw(rematr, mmoodd)
def render(self, time, frame_time):
angle = time
self.ctx.clear(1.0, 1.0, 1.0)
camera_pos = (np.cos(angle) * 5.0, np.sin(angle) * 5.0, 2.0)
proj = Matrix44.perspective_projection(45.0, self.aspect_ratio, 0.1, 1000.0)
lookat = Matrix44.look_at(
camera_pos,
(0.0, 0.0, 0.0),
(0.0, 0.0, 1.0),
)
self.prog['Mvp'] = (proj * lookat).astype('f4').tobytes()
self.prog['Light'] = camera_pos
self.vao.render()
def init():
"""Initialises the display."""
global projectmatrix, modelmatrix, chaem
GL.glClearColor(0.0, 0.2, 0.15, 0.0)
GL.glClearDepth(1.0)
GL.glDepthFunc(GL.GL_LESS)
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glShadeModel(GL.GL_SMOOTH)
shades()
chaem = Fremv((), deltam)
GL.glUniform3f(GL.glGetUniformLocation(shaderp, 'lightColour'), *[1.0, 1.0, 1.0])
modelmatrix = matrix.from_scale([2, 2, 2]) * matrix.from_translation([0, 0, -1])
wid, hig = window.get_size()
hig = hig or 1
projectmatrix = matrix.perspective_projection(whel, wid/hig, 0.01, 100)
rematr()
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(moderngl.DEPTH_TEST)
proj = Matrix44.perspective_projection(45.0, self.aspect_ratio, 0.1, 1000.0)
lookat = Matrix44.look_at(
(-85, -180, 140),
(0.0, 0.0, 65.0),
(0.0, 0.0, 1.0),
)
self.light.value = (-140.0, -300.0, 350.0)
self.color.value = (1.0, 1.0, 1.0, 0.25)
self.mvp.write((proj * lookat).astype('f4').tobytes())
self.texture.use()
self.vao.render()
def render(self):
angle = self.wnd.time
self.ctx.screen.viewport = self.wnd.viewport
camera_pos = (np.cos(angle) * 5.0, np.sin(angle) * 5.0, 2.0)
proj = Matrix44.perspective_projection(45.0, self.wnd.ratio, 0.1, 1000.0)
lookat = Matrix44.look_at(
camera_pos,
(0.0, 0.0, 0.5),
(0.0, 0.0, 1.0),
)
self.prog['Mvp'] = (proj * lookat).astype('f4').tobytes()
self.prog['Light'] = camera_pos
self.ctx.replay(self.bytecode)
def test_m44_q_equivalence(self):
"""Test for equivalance of matrix and quaternion rotations.
Create a matrix and quaternion, rotate each by the same values
then convert matrix<->quaternion and check the results are the same.
"""
m = Matrix44.from_x_rotation(np.pi / 2.)
mq = Quaternion.from_matrix(m)
q = Quaternion.from_x_rotation(np.pi / 2.)
qm = Matrix44.from_quaternion(q)
self.assertTrue(np.allclose(np.dot([1., 0., 0., 1.], m), [1., 0., 0., 1.]))
self.assertTrue(np.allclose(np.dot([1., 0., 0., 1.], qm), [1., 0., 0., 1.]))
self.assertTrue(np.allclose(q * Vector4([1., 0., 0., 1.]), [1., 0., 0., 1.]))
self.assertTrue(np.allclose(mq * Vector4([1., 0., 0., 1.]), [1., 0., 0., 1.]))
np.testing.assert_almost_equal(np.array(q), np.array(mq), decimal=5)
np.testing.assert_almost_equal(np.array(m), np.array(qm), decimal=5)
def resize (self: 'GLQuadRenderer', width: int, height: int) -> None:
super ().resize (width, height)
if not self.__loaded:
return
y = self.__image_height / self.__image_width * \
self.gl_widget.width / self.gl_widget.height
x = self.__image_width / self.__image_height * \
self.gl_widget.height / self.gl_widget.width
if self.gl_widget.height * self.__image_width / self.__image_height > self.gl_widget.width:
self.world = Matrix44.from_scale ([1, y, 1]) * \
Matrix44.from_translation ([0, (1 - y) / 2, 0])
else:
self.world = Matrix44.from_scale ([x, 1, 1]) * \
Matrix44.from_translation ([(1 - x) / 2, 0, 0])
GL.glUniformMatrix4fv (self.__uniform_world, 1, False, self.world)
def render(self, time, frame_time):
self.ctx.clear(1.0, 1.0, 1.0)
self.bg_texture.use()
self.ctx.enable_only(moderngl.BLEND)
self.canvas_vao.render(moderngl.TRIANGLE_STRIP)
self.ctx.enable_only(moderngl.DEPTH_TEST)
proj = Matrix44.perspective_projection(30.0, self.aspect_ratio, 1.0, 1000.0)
lookat = Matrix44.look_at(
(46.748, -280.619, 154.391),
(-23.844, 2.698, 44.493),
(0.0, 0.0, 1.0),
)
self.mvp.write((proj * lookat).astype('f4').tobytes())
self.light.value = (-143.438, -159.072, 213.268)
self.mug_texture.use()
self.mug_vao.render()
self.ctx.enable_only(moderngl.DEPTH_TEST | moderngl.BLEND)
self.sticker_texture.use()
self.sticker_vao.render(moderngl.TRIANGLE_STRIP)
def render(self, time, frame_time):
angle = time * 0.2
self.ctx.clear(1.0, 1.0, 1.0)
self.ctx.enable(moderngl.DEPTH_TEST)
camera_pos = (np.cos(angle) * 5.0, np.sin(angle) * 5.0, 2.0)
proj = Matrix44.perspective_projection(45.0, self.aspect_ratio, 0.1, 1000.0)
lookat = Matrix44.look_at(
camera_pos,
(0.0, 0.0, 0.5),
(0.0, 0.0, 1.0),
)
self.mvp.write((proj * lookat).astype('f4').tobytes())
self.light.value = camera_pos
crate_z = np.sin(self.crate_a * time + self.crate_b) * 0.2
coordinates = np.dstack([self.crate_x, self.crate_y, crate_z])
self.vbo2.write(coordinates.astype('f4').tobytes())
self.vao.render(instances=1024)
def main():
window = initWindow()
classicProgram, normalMapProgram, skyboxProgram, asteroidProgram = initShaders()
glEnable(GL_DEPTH_TEST)
glDepthFunc(GL_LESS)
# Initialize objects
planets, spaceship, skybox, belt = initObjects(classicProgram, normalMapProgram,
skyboxProgram, asteroidProgram)
projMatrix = mat4.perspective_projection(60,
float(WIDTH/HEIGHT),
0.1,
10000.0,
dtype='f')
eye, viewMatrix = initCamera()
dt, oldTime = 0.0, glfw.GetTime()
animation_speed = 800
while not glfw.WindowShouldClose(window):
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
currentTime = glfw.GetTime()
dt = currentTime - oldTime
oldTime = currentTime
hAngle, vAngle, eye, direction, right, up, viewMatrix, animation_speed = getNewViewMatrixAndEye(window,
animation_speed,
dt,
eye,
WIDTH,
HEIGHT)
for planet in planets:
planet.update(animation_speed)
planet.draw(eye, viewMatrix, projMatrix)
spaceship.update(eye, direction, right, up, hAngle, vAngle)
spaceship.draw(eye, viewMatrix, projMatrix)
belt.update(0.1)
belt.draw(eye, viewMatrix, projMatrix)
skybox.draw(viewMatrix, projMatrix)
# Swap front and back buffers
glfw.SwapBuffers(window)
# Poll for and process events
glfw.PollEvents()
glfw.Terminate()
def render(self, app, currentTime):
glBindVertexArray(self._vao.identifier)
try:
glUseProgram(self._program.identifier)
bg_color = (
math.sin(currentTime) * 0.5 + 0.5,
math.cos(currentTime) * 0.5 + 0.5,
0.0,
1.0
)
glClearBufferfv(GL_COLOR, 0, bg_color)
glClearBufferfv(GL_DEPTH, 0, [1])
f = currentTime * 0.3
mv_matrix = Matrix44.identity(dtype='f4')
mv_matrix *= Matrix44.from_x_rotation(
currentTime * math.radians(81))
mv_matrix *= Matrix44.from_y_rotation(
currentTime * math.radians(45))
mv_matrix *= Matrix44.from_translation([
math.sin(2.1 * f) * 0.5,
math.cos(1.7 * f) * 0.5,
math.sin(1.3 * f) * math.cos(1.5 * f) * 2.0])
mv_matrix *= Matrix44.from_translation([0.0, 0.0, -4.0])
self._uniform_block.mv_matrix[:] = mv_matrix.reshape(16)
glBufferSubData(
GL_UNIFORM_BUFFER,
0,
ctypes.sizeof(self._uniform_block),
ctypes.byref(self._uniform_block))
self._torus_obj.render()
finally:
glBindVertexArray(NULL_GL_OBJECT)
def render(self):
angle = self.wnd.time
self.ctx.screen.viewport = self.wnd.viewport
self.ctx.clear(1.0, 1.0, 1.0)
with self.ctx.scope(mgl.DEPTH_TEST):
camera_pos = (np.cos(angle) * 20.0, np.sin(angle) * 20.0, 5.0)
proj = Matrix44.perspective_projection(45.0, self.wnd.ratio, 0.1, 1000.0)
lookat = Matrix44.look_at(
camera_pos,
(0.0, 0.0, 0.5),
(0.0, 0.0, 1.0),
)
self.prog['Mvp'] = (proj * lookat).astype('f4').tobytes()
self.prog['Light'] = camera_pos
# self.vbo2.write(Matrix33.from_z_rotation(self.wnd.time).astype('f4').tobytes(), offset=24)
self.vbo2.write(b''.join(struct.pack(
'15f',
*car['color'],
*car['pos'],
1.0, 0.0, 0.0,
0.0, 1.0, 0.0,
0.0, 0.0, 1.0,
) for car in cars))
self.vao.render(instances=len(cars))
self.vbo2.write(b''.join(struct.pack(
'15f',
0.0, 0.0, 0.0,
*car['pos'],
1.0, 0.0, 0.0,
0.0, 1.0, 0.0,
0.3, 0.6, 0.0,
) for car in cars))
self.vao.render(instances=len(cars))
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 render(self, time, frame_time):
angle = time
self.ctx.clear(1.0, 1.0, 1.0)
self.ctx.enable(moderngl.DEPTH_TEST)
camera_pos = (np.cos(angle) * 20.0, np.sin(angle) * 20.0, 5.0)
proj = Matrix44.perspective_projection(45.0, self.aspect_ratio, 0.1, 1000.0)
lookat = Matrix44.look_at(
camera_pos,
(0.0, 0.0, 0.5),
(0.0, 0.0, 1.0),
)
self.mvp.write((proj * lookat).astype('f4').tobytes())
self.light.value = camera_pos
# self.vbo2.write(Matrix33.from_z_rotation(self.wnd.time).astype('f4').tobytes(), offset=24)
self.vbo2.write(b''.join(struct.pack(
'15f',
*car['color'],
*car['pos'],
1.0, 0.0, 0.0,
0.0, 1.0, 0.0,
0.0, 0.0, 1.0,
) for car in cars))
self.vao.render(instances=len(cars))
self.vbo2.write(b''.join(struct.pack(
'15f',
0.0, 0.0, 0.0,
*car['pos'],
1.0, 0.0, 0.0,
0.0, 1.0, 0.0,
0.3, 0.6, 0.0,
) for car in cars))
self.vao.render(instances=len(cars))
