def render(self, time, frame_time):
proj = Matrix44.perspective_projection(90.0, 1.0, 0.1, 1000.0)
x, y, z = 0.0, 0.0, 1.0
lookats = [
Matrix44.look_at((x, y, z), (x - 1.0, y, z), (0.0, 1.0, 0.0)),
Matrix44.look_at((x, y, z), (x + 1.0, y, z), (0.0, 1.0, 0.0)),
Matrix44.look_at((x, y, z), (x, y - 1.0, z), (0.0, 0.0, 1.0)),
Matrix44.look_at((x, y, z), (x, y + 1.0, z), (0.0, 0.0, -1.0)),
Matrix44.look_at((x, y, z), (x, y, z + 1.0), (0.0, 1.0, 0.0)),
Matrix44.look_at((x, y, z), (x, y, z - 1.0), (0.0, 1.0, 0.0)),
]
self.prog2['Mvp'] = b''.join((proj * lookat).astype('f4').tobytes() for lookat in lookats)
self.prog2['Light'] = (0.0, 0.0, 1.0)
self.fbo1.clear(0, (1.0, 1.0, 1.0))
self.fbo1.clear(-1, 1.0)
self.vao2.render()
camera_pos = (np.cos(time) * 5.0, np.sin(time) * 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.prog1['Mvp'] = (proj * lookat).astype('f4').tobytes()
self.prog1['Light'] = camera_pos
self.ctx.screen.use()
self.ctx.screen.clear(0, (1.0, 1.0, 1.0))
self.ctx.screen.clear(-1, 1.0)
self.vao1.render()
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 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 adjust_angle_of_view(self, angle_of_view):
self.angle_of_view = angle_of_view
self.TAN_ANGLE = np.tan(np.radians(self.angle_of_view / 2))
perspective = Matrix44.perspective_projection(
self.angle_of_view, RATIO, 0.1, 1000.0
)
self.PROG["VP"].write((perspective * LOOK_AT).astype("f4").tobytes())
def on_resize(self, width, height):
"""Set up viewport and projection"""
ratio = arcade.get_scaling_factor(self)
self.ctx.viewport = 0, 0, int(width * ratio), int(height * ratio)
aspect_ratio = width / height
self.program['projection'] = Matrix44.perspective_projection(
60, aspect_ratio, 0.1, 100).flatten()
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 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 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 resize(self, width, height):
self.ctx.viewport = 0, 0, width, height
self.projection = Matrix44.perspective_projection(45,
width / height,
1,
50,
dtype='f4')
def reset(self, width, height, color):
glEnable(GL_DEPTH_TEST)
glDepthFunc(GL_LESS)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glClearDepth(1.0)
glClear(GL_DEPTH_BUFFER_BIT)
glClearColor(color.r, color.g, color.b, color.a)
glClear(GL_COLOR_BUFFER_BIT)
glViewport(0, 0, width, height)
# Determine current znear, zfar
bbox = self.scene.bounding_box
mat = self.matrix
c = -1 * (mat * bbox.center)
znear = max(1.0, c.z - bbox.diameter / 2.0)
zfar = c.z + bbox.diameter
self.raycaster.near = znear
self.raycaster.far = zfar
self.box_select.width = width
self.box_select.height = height
self.poly_select.width = width
self.poly_select.height = height
self.proj_matrix = Matrix44.perspective_projection(
80.0, width / height, znear, zfar)
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 __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 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 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 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 update(
self,
aspect_ratio: float = None,
fov: float = None,
near: float = None,
far: float = None,
) -> None:
"""Update the projection matrix
Keyword Args:
aspect_ratio (float): Aspect ratio
fov (float): Field of view
near (float): Near plane value
far (float): Far plane value
"""
self._aspect_ratio = aspect_ratio or self._aspect_ratio
self._fov = fov or self._fov
self._near = near or self._near
self._far = far or self._far
self._matrix = Matrix44.perspective_projection(
self._fov,
self._aspect_ratio,
self._near,
self._far,
dtype="f4",
)
self._matrix_bytes = self._matrix.tobytes()
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 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 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 __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 resize(self, width: int, height: int):
self.prog['m_proj'].write(
Matrix44.perspective_projection(75,
self.wnd.aspect_ratio,
1,
100,
dtype='f4'))
self.imgui.resize(width, height)
def __init__(self, keys, radius=None, target=None, **kws):
self.default_radius = 10 if radius is None else radius
self.default_target = vec3.O() if target is None else target
self.keys = keys
self.reset_view()
self.projection = Matrix44.perspective_projection(
45.0, self.aspect_ratio, 0.1, 100.0)
def build_proj_matrix(self):
"""Builds and stores the perspective matrix internally
Automatically builds the MVP matrix as well"""
self.p = Matrix44.perspective_projection(self.fov,
self.width / self.height,
self.near_plane,
self.far_plane)
self.mvp = numpy.array(self.p * self.m).astype("f4")
def __init__(self, boundlesspath, basedir, ctx, args):
# Path to a boundless installation
self.boundlesspath = boundlesspath
self.basedir = basedir
self.args = args
with open(self.boundlesspath + '/assets/archetypes/compiledcolorpalettelists.msgpack', 'rb') as palettefile:
self.palette_json = utils.convert_msgpackfile(palettefile)
self.lookat = Matrix44.look_at((10, 10, 0.0), (10, 10, -5), (0, 1, 0))
self.perspective = Matrix44.perspective_projection(FOV, 1.0, 0.01, 1000.0)
self.projection_mat = self.perspective * self.lookat
self.model_mat = Matrix44.identity()
# Parsed shaders
self.shaders = parse_shaders.get_shaders()
with open(self.boundlesspath + "/assets/archetypes/compiledspecialmaterials.msgpack", 'rb') as specialsfile:
self.specials_json = utils.convert_msgpackfile(specialsfile)
self.specials_names = list(map(lambda a: a["name"], self.specials_json))
# A map of all the textures we use which are constant
# Key is the uniform name, value is the texture object
self.local_tex_path = os.path.join(self.basedir, 'assets/textures')
self.const_tex = {}
# Dynamic textures
self.dyn_tex = {}
self.ctx = ctx
# Necessary to stop memory leaks
self.ctx.gc_mode = "auto"
# Note: this is the dimensions of the image. Certain items/blocks/props won't fill
# this canvas.
self.target_size = (int(args["resolution"]), int(args["resolution"]))
self.render_size = (
int(self.target_size[0] // 0.9),
int(self.target_size[1] // 0.9)
) if args["anti_alias"] else self.target_size
# Initialise properly later, just allocating the field
self.prog = {}
self.cbo = self.ctx.renderbuffer(self.render_size)
self.dbo = self.ctx.depth_texture(self.render_size, alignment=1)
self.fbo = self.ctx.framebuffer(color_attachments=(self.cbo), depth_attachment=self.dbo)
self.fbo.use()
# Initialise all of the constant textures
self.init_constant_tex2ds()
self.init_constant_texcubes()
self.buffer_cache = []
# Grab uniforms
with open(os.path.join(self.basedir, 'assets/shader_dump.json')) as uniformsfile:
self.uniforms_json = json.load(uniformsfile)
def __init__(self, **kwargs):
super().__init__(**kwargs)
# Create a custom attribute name spec
# so attribute names are not forced to follow gltf standard
attr_names = AttributeNames(position='in_vert', texcoord_0='in_tex', normal='in_norm')
# Programs
self.canvas_prog = self.load_program('mug_mockup/programs/canvas.glsl')
self.sticker_prog = self.load_program('mug_mockup/programs/sticker.glsl')
self.mug_prog = self.load_program('mug_mockup/programs/mug.glsl')
# textures
self.bg_texture = self.load_texture_2d('mug_mockup/textures/mug-background.jpg')
self.sticker_texture = self.load_texture_2d('mug_mockup/textures/mug-pymet-logo.png')
self.canvas_vao = geometry.quad_fs(attr_names=attr_names).instance(self.canvas_prog)
obj = self.load_scene('mug_mockup/scenes/mug.obj', attr_names=attr_names)
self.mug_vao = obj.root_nodes[0].mesh.vao.instance(self.mug_prog)
# Create sticker geometry
segs = 32
radius = 29.94
bottom = 6.601
top = 57.856
left = -163.12 * np.pi / 180.0
right = 11.25 * np.pi / 180.0
lin = np.linspace(left, right, segs)
sticker_vertices = np.array([
np.repeat(np.cos(lin) * radius, 2),
np.repeat(np.sin(lin) * radius, 2),
np.tile([bottom, top], segs),
np.repeat(np.cos(lin), 2),
np.repeat(np.sin(lin), 2),
np.tile([0.0, 0.0], segs),
np.repeat(np.linspace(0.0, 1.0, segs), 2),
np.tile([0.0, 1.0], segs),
])
self.sticker_vbo = self.ctx.buffer(sticker_vertices.T.astype('f4').tobytes())
self.sticker_vao = self.ctx.simple_vertex_array(self.sticker_prog, self.sticker_vbo, 'in_vert', 'in_norm', 'in_text')
# Pre-fill uniforms. These currently do not change during rendering
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),
)
mvp = (proj * lookat).astype('f4')
light = (-143.438, -159.072, 213.268)
self.mug_prog['Mvp'].write(mvp)
self.mug_prog['Light'].value = light
self.sticker_prog['Mvp'].write(mvp)
self.sticker_prog['Light'].value = light
def get_view_model(self):
proj = Matrix44.perspective_projection(self.fov,
self.width / self.height,
self.near, self.far)
lookat = Matrix44.look_at(
self.eye, # eye / camera position
self.lookat, # lookat
self.up, # camera up vector
)
return proj, lookat
def project_and_render(view, zoom, resolution):
fovy, aspect, near, far = 60.0, resolution[0] / resolution[1], 0.001, 1000
projection = Matrix44.perspective_projection(fovy, aspect, near, far)
view = Matrix44(view)
scale = Matrix44.from_scale([zoom, zoom, zoom])
MVP = projection * view * scale
MVP = cuda.to_device(MVP)
apply_projection[bpg, maxThreadsPerBlock](MVP, embedding, result)
return render(result, resolution)
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 display():
ctx.viewport = (0, 0, width, height)
ctx.clear(0.9, 0.9, 0.9)
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):
angle = self.wnd.time
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) * 20.0, np.sin(angle) * 20.0, 5.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
# 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 paintGL(self):
width, height = self.width(), self.height()
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 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):
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 __init__(self, **kwargs):
super().__init__(**kwargs)
imgui.create_context()
self.wnd.ctx.error
self.imgui = ModernglWindowRenderer(self.wnd)
self.cube = geometry.cube(size=(2, 2, 2))
self.prog = self.load_program('programs/cube_simple.glsl')
self.prog['color'].value = (1.0, 1.0, 1.0, 1.0)
self.prog['m_camera'].write(Matrix44.identity(dtype='f4'))
self.prog['m_proj'].write(Matrix44.perspective_projection(75, self.wnd.aspect_ratio, 1, 100, dtype='f4'))
self.slider_value = 88
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 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, 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 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 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):
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 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):
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 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, 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 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):
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, 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))
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 build_projection(self):
self.mat_projection = Matrix44.perspective_projection(
self._field_of_view_degrees,
self._ratio,
self._z_near,
self._z_far)
'''),
])
mvp = prog.uniforms['Mvp']
grid = bytearray()
for i in range(0, 32 + 1):
grid += struct.pack('6f', i - 16.0, -16.0, 0.0, 0.0, 0.0, 0.0)
grid += struct.pack('6f', i - 16.0, 16.0, 0.0, 0.0, 0.0, 0.0)
grid += struct.pack('6f', -16.0, i - 16.0, 0.0, 0.0, 0.0, 0.0)
grid += struct.pack('6f', 16.0, i - 16.0, 0.0, 0.0, 0.0, 0.0)
vbo = ctx.buffer(grid)
vao = ctx.simple_vertex_array(prog, vbo, ['in_vert', 'in_color'])
while wnd.update():
ctx.viewport = wnd.viewport
ctx.clear(0.9, 0.9, 0.9)
ctx.enable(ModernGL.DEPTH_TEST)
proj = Matrix44.perspective_projection(45.0, wnd.ratio, 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),
)
mvp.write((proj * lookat).astype('float32').tobytes())
vao.render(ModernGL.LINES)
def window_did_resize(self, application, width, height):
aspect = width / height
proj_matrix = Matrix44.perspective_projection(
50.0, aspect, 0.1, 100.0,
dtype='f4')
self._uniform_block.proj_matrix[:] = proj_matrix.reshape(16)
def SetPerspective(self, width, height): screenRatio = (1.0 * width) / (1.0 * height) self.perspectiveMatrix = Matrix44.perspective_projection(CAMERA_FOV, screenRatio, CAMERA_NEAR, CAMERA_FAR)
grid += struct.pack('6f', i - 16.0, -16.0, 0.0, 0.0, 0.0, 0.0)
grid += struct.pack('6f', i - 16.0, 16.0, 0.0, 0.0, 0.0, 0.0)
grid += struct.pack('6f', -16.0, i - 16.0, 0.0, 0.0, 0.0, 0.0)
grid += struct.pack('6f', 16.0, i - 16.0, 0.0, 0.0, 0.0, 0.0)
vbo = ctx.buffer(grid)
vao = ctx.simple_vertex_array(prog, vbo, ['in_vert', 'in_color'])
running = True
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
ctx.viewport = (0, 0, width, height)
ctx.clear(0.9, 0.9, 0.9)
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),
)
mvp.write((proj * lookat).astype('float32').tobytes())
vao.render(ModernGL.LINES)
pygame.display.flip()
pygame.time.wait(10)
def onsc(yof):
"""Wheels. """
global whel, projectmatrix
sz = window.get_size()
whel = clip(whel - yof, 1, 180)
projectmatrix = matrix.perspective_projection(whel, sz[0] / sz[1], 0.01, 100)
