self.texture = self.ctx.texture(self.wood.size, 3, self.wood.tobytes())
self.texture.build_mipmaps()
self.vbo = self.ctx.buffer(self.obj.pack('vx vy vz nx ny nz tx ty'))
self.vao = self.ctx.simple_vertex_array(self.prog, self.vbo, 'in_vert',
'in_norm', 'in_text')
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()
if __name__ == '__main__':
run_example(LoadingOBJ)
float d = raymarch(o, r, c);
// pixel color
vec3 color = vec3(0);
if (d < FAR)
{
vec3 p = o + r * d;
vec3 n = norm(p);
float lambert = dot(n, l);
lambert = clamp(lambert, 0.1, 1.0);
#define SPEC_COLOR vec3(0.85, 0.75, 0.5)
vec3 h = normalize(o + l);
float ndh = clamp(dot(n, h), 0.0, 1.0);
float ndv = clamp(dot(n, -o), 0.0, 1.0);
float spec = pow((ndh + ndv) + 0.01, 64.0) * 0.25;
color = c * lambert + SPEC_COLOR * spec;
}
// add simple fog
color = mix(FOG_COLOR, color, clamp(pow(FOG_DIST / abs(d), FOG_DENSITY), 0.0, 1.0));
out_color = vec4(color, 1.0);
}
'''
if __name__ == '__main__':
run_example(Raymarching)
def key_event(self, key, action):
if action == self.wnd.keys.ACTION_PRESS:
self.shoot()
def render(self, time, frame_time):
width, height = self.wnd.size
self.ctx.clear(1.0, 1.0, 1.0)
self.ctx.enable(moderngl.BLEND)
for i in range(10):
self.space.step(1 / 60 / 10)
self.prog['Camera'].value = (200, 300, width / 2, height / 2)
bodies = np.array([(b.position.x, b.position.y, b.angle, 10, 10, 1, 1, 1, 0) for b in self.bodies], dtype='f4')
self.vbo2.write(bodies.tobytes())
self.prog['Texture'].value = 0
self.vao.render(moderngl.TRIANGLE_STRIP, instances=len(self.bodies))
self.vbo2.orphan()
balls = np.array([(b.position.x, b.position.y, b.angle, 15, 15, 1, 1, 1, 0) for b in self.balls], dtype='f4')
self.vbo2.write(balls.tobytes())
self.prog['Texture'].value = 1
self.vao.render(moderngl.TRIANGLE_STRIP, instances=len(self.balls))
if __name__ == '__main__':
run_example(PymunkExample)
0.0,
0.0,
0.5,
-0.5,
0.86,
0.0,
1.0,
0.0,
0.5,
-0.5,
-0.86,
0.0,
0.0,
1.0,
0.5,
])
self.vbo = self.ctx.buffer(vertices.astype('f4').tobytes())
self.vao = self.ctx.simple_vertex_array(self.prog, self.vbo, 'vert',
'vert_color')
def render(self, time: float, frame_time: float):
self.ctx.clear(1.0, 1.0, 1.0)
self.ctx.enable(moderngl.BLEND)
self.rotation.value = time
self.vao.render(instances=10)
if __name__ == '__main__':
run_example(AlphaBlending)
self.camera.rotate_right()
if self.states.get(self.wnd.keys.Z):
self.camera.zoom_in()
if self.states.get(self.wnd.keys.X):
self.camera.zoom_out()
def key_event(self, key, action):
if key not in self.states:
print(key, action)
return
if action == self.wnd.keys.ACTION_PRESS:
self.states[key] = True
else:
self.states[key] = False
def render(self, time, frame_time):
self.move_camera()
self.ctx.clear(1.0, 1.0, 1.0)
self.ctx.enable(moderngl.DEPTH_TEST)
self.mvp.write((self.camera.mat_projection * self.camera.mat_lookat).astype('f4').tobytes())
self.vao.render(moderngl.LINES)
if __name__ == '__main__':
run_example(PerspectiveProjection)
// pixel color
vec3 color = vec3(0);
if (d < FAR)
{
vec3 p = o + r * d;
vec3 n = norm(p);
float lambert = dot(n, l);
lambert = clamp(lambert, 0.1, 1.0);
#define SPEC_COLOR vec3(0.85, 0.75, 0.5)
vec3 h = normalize(o + l);
float ndh = clamp(dot(n, h), 0.0, 1.0);
float ndv = clamp(dot(n, -o), 0.0, 1.0);
float spec = pow((ndh + ndv) + 0.01, 64.0) * 0.25;
color = c * lambert + SPEC_COLOR * spec;
}
// add simple fog
color = mix(FOG_COLOR, color, clamp(pow(FOG_DIST / abs(d), FOG_DENSITY), 0.0, 1.0));
out_color = vec4(color, 1.0);
}
'''
if __name__ == '__main__':
run_example(Raymarching)
import os
from PIL import Image
import moderngl.next as mgl
from sampler_basic_example import SamplerBasicExample
from window import run_example
class SamplerLinearFilter(SamplerBasicExample):
gl_version = (3, 3)
aspect_ratio = 1.0
title = "Sampler Linear Filter"
img = Image.frombytes('RGB', (8, 8), os.urandom(192))
def __init__(self, **kwargs):
super().__init__(**kwargs)
# self.sampler.filter = (mgl.LINEAR, mgl.LINEAR)
self.sampler.filter = mgl.LINEAR
self.sampler.wrap = mgl.REPEAT_X | mgl.REPEAT_Y
if __name__ == '__main__':
run_example(SamplerLinearFilter)
0.0,
0.8,
1.0,
0.0,
0.0,
-0.6,
-0.8,
0.0,
1.0,
0.0,
0.6,
-0.8,
0.0,
0.0,
1.0,
])
self.vbo = self.ctx.buffer(vertices.astype('f4').tobytes())
# We control the 'in_vert' and `in_color' variables
self.vao = self.ctx.simple_vertex_array(self.prog, self.vbo, 'in_vert',
'in_color')
def render(self, time: float, frame_time: float):
self.ctx.clear(1.0, 1.0, 1.0)
self.vao.render()
if __name__ == '__main__':
run_example(SimpleColorTriangle)
self.ctx.clear(1.0, 1.0, 1.0)
self.ctx.enable(moderngl.BLEND)
for i in range(10):
self.space.step(1 / 60 / 10)
self.prog['Camera'].value = (200, 300, width / 2, height / 2)
bodies = np.array(
[(b.position.x, b.position.y, b.angle, 10, 10, 1, 1, 1, 0)
for b in self.bodies],
dtype='f4')
self.vbo2.write(bodies.tobytes())
self.prog['Texture'].value = 0
self.vao.render(moderngl.TRIANGLE_STRIP, instances=len(self.bodies))
self.vbo2.orphan()
balls = np.array(
[(b.position.x, b.position.y, b.angle, 15, 15, 1, 1, 1, 0)
for b in self.balls],
dtype='f4')
self.vbo2.write(balls.tobytes())
self.prog['Texture'].value = 1
self.vao.render(moderngl.TRIANGLE_STRIP, instances=len(self.balls))
if __name__ == '__main__':
run_example(PymunkExample)
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()
if __name__ == '__main__':
run_example(RenderTextureCompute)
f_color = v_color;
}
''',
)
self.scale = self.prog['Scale']
self.rotation = self.prog['Rotation']
vertices = np.array([
# x, y, red, green, blue, alpha
1.0, 0.0, 1.0, 0.0, 0.0, 0.5,
-0.5, 0.86, 0.0, 1.0, 0.0, 0.5,
-0.5, -0.86, 0.0, 0.0, 1.0, 0.5,
])
self.vbo = self.ctx.buffer(vertices.astype('f4').tobytes())
self.vao = self.ctx.simple_vertex_array(self.prog, self.vbo, 'in_vert', 'in_color')
def render(self, time, frame_time):
width, height = self.wnd.size
self.ctx.clear(1.0, 1.0, 1.0)
self.ctx.enable(moderngl.BLEND)
self.scale.value = (0.5, self.aspect_ratio * 0.5)
self.rotation.value = time
self.vao.render(instances=10)
if __name__ == '__main__':
run_example(InstancedRendering)
(0.9, 0.9),
], dtype='f4')
left, bottom, right, top = self.texrect
self.texcoords = np.array([
(left, bottom),
(left, top),
(right, bottom),
(right, top),
], dtype='f4')
self.texture = self.ctx.texture(self.img.transpose(Image.FLIP_TOP_BOTTOM).convert('RGB'))
self.sampler = self.ctx.sampler(self.texture)
def render(self, time: float, frame_time: float):
# clear screen
self.ctx.clear(1.0, 1.0, 1.0)
# render texture
self.sampler.use()
self.renderer.render(mgl.TRIANGLE_STRIP, vertices=self.vertices, texcoords=self.texcoords)
# render grid
self.renderer.render(mgl.LINES, vertices=np.array([
(i * 0.18, -0.9, i * 0.18, 0.9, -0.9, i * 0.18, 0.9, i * 0.18) for i in range(-5, 7, 2)
], 'f4').reshape(-1, 2), texture=False, color=(0.0, 0.0, 0.0, 1.0))
if __name__ == '__main__':
run_example(SamplerBasicExample)
self.color = self.prog['Color']
self.mvp = self.prog['Mvp']
self.texture = self.ctx.texture(self.wood.size, 3, self.wood.tobytes())
self.texture.build_mipmaps()
self.vbo = self.ctx.buffer(self.obj.pack('vx vy vz nx ny nz tx ty'))
self.vao = self.ctx.simple_vertex_array(self.prog, self.vbo, 'in_vert', 'in_norm', 'in_text')
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()
if __name__ == '__main__':
run_example(LoadingOBJ)
tex0.use(0)
tex1.use(1)
tex2.use(2)
tex3.use(3)
tex4.use(4)
self.prog['Heightmap'].value = 0
self.prog['Color1'].value = 1
self.prog['Color2'].value = 2
self.prog['Cracks'].value = 3
self.prog['Darken'].value = 4
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)
if __name__ == '__main__':
run_example(MultiTextireTerrain)
(self.vbo, '2f', 'in_vert'),
]
self.vao = self.ctx.vertex_array(self.prog, vao_content, self.ibo)
self.img = Image.open(data.find('noise.jpg')).convert('L')
texture = self.ctx.texture(self.img.size, 1, self.img.tobytes())
texture.use()
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)
self.ctx.wireframe = True
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)
if __name__ == '__main__':
run_example(WireframeTerrain)
(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()
if __name__ == '__main__':
run_example(ColorsAndTexture)
''',
varyings=['out_vert']
)
self.transform['Width'].value = width
self.transform['Height'].value = height
self.texture = self.ctx.texture((width, height), 1, pixels.tobytes(), dtype='f4')
self.texture.filter = (moderngl.NEAREST, moderngl.NEAREST)
self.texture.swizzle = 'RRR1'
self.texture.use()
self.vbo = self.ctx.buffer(canvas.tobytes())
self.vao = self.ctx.simple_vertex_array(self.prog, self.vbo, 'in_vert')
self.text = self.ctx.buffer(grid.tobytes())
self.tao = self.ctx.simple_vertex_array(self.transform, self.text, 'in_text')
self.pbo = self.ctx.buffer(reserve=pixels.nbytes)
def render(self, time, frame_time):
self.ctx.clear(1.0, 1.0, 1.0)
self.tao.transform(self.pbo)
self.texture.write(self.pbo)
self.vao.render(moderngl.TRIANGLE_STRIP)
if __name__ == '__main__':
run_example(Conway)
(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()
if __name__ == '__main__':
run_example(MatplotlibTexture)
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()
if __name__ == '__main__':
run_example(RenderToTexture)
(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))
if __name__ == '__main__':
run_example(ToyCars)
self.vbo1 = self.ctx.buffer(b''.join(particle() for i in range(1024)))
self.vbo2 = self.ctx.buffer(reserve=self.vbo1.size)
self.vao1 = self.ctx.simple_vertex_array(self.transform, self.vbo1,
'in_pos', 'in_prev')
self.vao2 = self.ctx.simple_vertex_array(self.transform, self.vbo2,
'in_pos', 'in_prev')
self.render_vao = self.ctx.vertex_array(self.prog, [
(self.vbo1, '2f 2x4', 'in_vert'),
])
self.idx = 0
def render(self, time, frame_time):
self.ctx.clear(1.0, 1.0, 1.0)
self.ctx.point_size = 2.0
for i in range(8):
self.vbo1.write(particle(), offset=self.idx * 16)
self.idx = (self.idx + 1) % 1024
self.render_vao.render(moderngl.POINTS, 1024)
self.vao1.transform(self.vbo2, moderngl.POINTS, 1024)
self.ctx.copy_buffer(self.vbo1, self.vbo2)
if __name__ == '__main__':
run_example(Particles)
fragment_shader='''
#version 400 core
out vec4 frag_color;
void main() { frag_color = vec4(1.0); }
'''
)
# four vertices define a cubic Bézier curve; has to match the shaders
self.ctx.patch_vertices = 4
self.ctx.line_width = 5.0
vertices = np.array([
[-1.0, 0.0],
[-0.5, 1.0],
[0.5, -1.0],
[1.0, 0.0],
])
vbo = self.ctx.buffer(vertices.astype('f4').tobytes())
self.vao = self.ctx.simple_vertex_array(self.prog, vbo, 'in_pos')
def render(self, time, frame_time):
self.ctx.clear(0.2, 0.4, 0.7)
self.vao.render(mode=moderngl.PATCHES)
if __name__ == '__main__':
run_example(Tessellation)
self.transform['Width'] = width
self.transform['Height'] = height
self.texture = self.ctx.texture((width, height),
1,
pixels.tobytes(),
dtype='f4')
self.texture.swizzle = 'RRR1'
self.sampler = self.ctx.sampler(self.texture)
# self.sampler.filter = (mgl.NEAREST, mgl.NEAREST)
self.sampler.use()
self.vbo = self.ctx.buffer(canvas.tobytes())
self.vao = self.ctx.simple_vertex_array(self.prog, self.vbo, 'in_vert')
self.text = self.ctx.buffer(grid.tobytes())
self.tao = self.ctx.simple_vertex_array(self.transform, self.text,
'in_text')
self.pbo = self.ctx.buffer(reserve=pixels.nbytes)
def render(self, time, frame_time):
self.ctx.clear(1.0, 1.0, 1.0)
self.tao.transform(self.pbo)
self.texture.write(self.pbo)
self.vao.render(mgl.TRIANGLE_STRIP)
run_example(Conway)
(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()
if __name__ == '__main__':
run_example(MatplotlibTexture)
tex1.use(1)
tex2.use(2)
tex3.use(3)
tex4.use(4)
self.prog['Heightmap'].value = 0
self.prog['Color1'].value = 1
self.prog['Color2'].value = 2
self.prog['Cracks'].value = 3
self.prog['Darken'].value = 4
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)
if __name__ == '__main__':
run_example(MultiTextireTerrain)
''',
fragment_shader='''
#version 400 core
out vec4 frag_color;
void main() { frag_color = vec4(1.0); }
''')
# four vertices define a cubic Bézier curve; has to match the shaders
self.ctx.patch_vertices = 4
self.ctx.line_width = 5.0
vertices = np.array([
[-1.0, 0.0],
[-0.5, 1.0],
[0.5, -1.0],
[1.0, 0.0],
])
vbo = self.ctx.buffer(vertices.astype('f4').tobytes())
self.vao = self.ctx.simple_vertex_array(self.prog, vbo, 'in_pos')
def render(self, time, frame_time):
self.ctx.clear(0.2, 0.4, 0.7)
self.vao.render(mode=moderngl.PATCHES)
if __name__ == '__main__':
run_example(Tessellation)
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))
if __name__ == '__main__':
run_example(ToyCars)
rect(0.5, -0.5, 0.9, 0.9, 2.0),
rect(0.5, 0.5, 0.9, 0.9, 3.0),
])
img1 = Image.new('RGB', (200, 200), '#fee')
img2 = Image.new('RGB', (200, 200), '#efe')
img3 = Image.new('RGB', (200, 200), '#eef')
img4 = Image.new('RGB', (200, 200), '#ffe')
ImageDraw.ImageDraw(img1).text((10, 10), 'img 1', '#000', ImageFont.truetype('arial', 32))
ImageDraw.ImageDraw(img2).text((10, 10), 'img 2', '#000', ImageFont.truetype('arial', 32))
ImageDraw.ImageDraw(img3).text((10, 10), 'img 3', '#000', ImageFont.truetype('arial', 32))
ImageDraw.ImageDraw(img4).text((10, 10), 'img 4', '#000', ImageFont.truetype('arial', 32))
def join(*images):
return b''.join(img.tobytes('raw', 'RGB', 0, -1) for img in images)
self.texture = self.ctx.texture_array((200, 200, 4), 3, join(img1, img2, img3, img4))
self.sampler = self.ctx.sampler(self.texture)
self.sampler.use()
self.vbo = self.ctx.buffer(vertices.astype('f4').tobytes())
self.vao = self.ctx.simple_vertex_array(self.prog, self.vbo, 'in_vert', 'in_text')
def render(self, time: float, frame_time: float):
self.ctx.clear(1.0, 1.0, 1.0)
self.vao.render()
run_example(HelloWorld)
out vec4 f_color;
void main() {
f_color = vec4(0.1, 0.1, 0.1, 1.0);
}
''',
)
self.mvp = self.prog['Mvp']
self.vbo = self.ctx.buffer(grid(15, 10).astype('f4').tobytes())
self.vao = self.ctx.simple_vertex_array(self.prog, self.vbo, 'in_vert')
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)
if __name__ == '__main__':
run_example(SimpleGrid)
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()
if __name__ == '__main__':
run_example(RenderToTexture)
join(img1, img2, img3, img4, img5,
img6))
self.sampler = self.ctx.sampler(self.texture)
self.sampler.filter = mgl.LINEAR
self.sampler.use()
obj = Obj.open(data.find('sitting_dummy.obj'))
self.vbo = self.ctx.buffer(obj.pack('vx vy vz nx ny nz'))
self.vao = self.ctx.simple_vertex_array(self.prog, self.vbo, 'in_vert',
'in_norm')
self.scope = self.ctx.scope(mgl.DEPTH_TEST)
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()
run_example(HelloWorld)
vao_content = [
(self.vbo, '2f', 'in_vert'),
]
self.vao = self.ctx.vertex_array(self.prog, vao_content, self.ibo)
self.img = Image.open(data.find('noise.jpg')).convert('L')
texture = self.ctx.texture(self.img.size, 1, self.img.tobytes())
texture.use()
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)
self.ctx.wireframe = True
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)
if __name__ == '__main__':
run_example(WireframeTerrain)
''',
)
self.scale = self.prog['scale']
self.rotation = self.prog['rotation']
self.scale.value = (self.wnd.width / self.wnd.height * 0.75, 0.25)
vertices = np.array([
1.0, 0.0,
-0.5, 0.86,
-0.5, -0.86,
])
self.vbo = self.ctx.buffer(vertices.astype('f4').tobytes())
self.vao = self.ctx.simple_vertex_array(self.prog, self.vbo, 'vert')
def render(self, time: float, frame_time: float):
sin_scale = np.sin(np.deg2rad(time * 60))
self.ctx.clear(1.0, 1.0, 1.0)
self.vao.render()
self.rotation.value = time
# Change the scale of the triangle sin-ly
self.scale.value = (sin_scale * 0.75, 0.75)
if __name__ == '__main__':
run_example(UniformsAndAttributes)
(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()
if __name__ == '__main__':
run_example(ColorsAndTexture)
if self.states.get(self.wnd.keys.Z):
self.camera.zoom_in()
if self.states.get(self.wnd.keys.X):
self.camera.zoom_out()
def key_event(self, key, action):
if key not in self.states:
print(key, action)
return
if action == self.wnd.keys.ACTION_PRESS:
self.states[key] = True
else:
self.states[key] = False
def render(self, time, frame_time):
self.move_camera()
self.ctx.clear(1.0, 1.0, 1.0)
self.ctx.enable(moderngl.DEPTH_TEST)
self.mvp.write((self.camera.mat_projection *
self.camera.mat_lookat).astype('f4').tobytes())
self.vao.render(moderngl.LINES)
if __name__ == '__main__':
run_example(PerspectiveProjection)
print("Space was pressed")
if action == self.wnd.keys.ACTION_RELEASE:
if key == self.wnd.keys.SPACE:
print("Space was released")
def mouse_position_event(self, x, y):
"""
Mouse position reported in pixel position
with the upper left corner as the origin
"""
print("Mouse pos", x, y)
def mouse_press_event(self, x, y, button):
"""Reports left and right mouse button presses + position"""
if button == 1:
print("Left mouse button pressed @", x, y)
if button == 2:
print("Right mouse button pressed @", x, y)
def mouse_release_event(self, x, y, button):
"""Reports left and right mouse button releases + position"""
if button == 1:
print("Left mouse button released @", x, y)
if button == 2:
print("Right mouse button released @", x, y)
if __name__ == '__main__':
run_example(EmptyWindow)
-0.6,
-0.8,
0.6,
-0.8,
0.6,
0.8,
-0.6,
0.8,
])
# Indecies are given to specify the order of drawing
indecies = np.array([0, 1, 2, 0, 3, 4])
self.vbo = self.ctx.buffer(vertices.astype('f4').tobytes())
self.ibo = self.ctx.buffer(indecies.astype('i4').tobytes())
vao_content = [
# 2 floats are assigned to the 'in' variable named 'in_vert' in the shader code
(self.vbo, '2f', 'in_vert')
]
self.vao = self.ctx.vertex_array(self.prog, vao_content, self.ibo)
def render(self, time: float, frame_time: float):
self.ctx.clear(1.0, 1.0, 1.0)
self.vao.render()
if __name__ == '__main__':
run_example(IndexBuffer)
# Index buffer (also called element buffer)
# There are 2 trianges to render
#
# A, B, C
# B, C, D
render_indicies = np.array([0, 1, 2, 1, 2, 3])
self.index_buffer = self.ctx.buffer(
render_indicies.astype('i4').tobytes())
# The vao_content is a list of 3-tuples (buffer, format, attribs)
# the format can have an empty or '/v', '/i', '/r' ending.
# '/v' attributes are the default
# '/i` attributes are per instance attributes
# '/r' attributes are default values for the attributes (per render attributes)
vao_content = [
(self.position_vertex_buffer, '2f', 'in_vert'),
(self.color_buffer, '3f', 'in_color'),
(self.pos_scale_buffer, '2f 1f/i', 'in_pos', 'in_scale'),
]
self.vao = self.ctx.vertex_array(self.prog, vao_content,
self.index_buffer)
def render(self, time: float, frame_time: float):
self.ctx.clear(1.0, 1.0, 1.0)
self.vao.render(instances=8)
if __name__ == '__main__':
run_example(InstancedRendering)
(4, 4), 3, np.random.randint(128, 255, (4, 4, 3), 'u1'))
self.sampler = self.ctx.sampler(self.texture,
wrap=mgl.REPEAT_X | mgl.REPEAT_Y)
self.vbo = self.ctx.buffer(obj.pack('vx vy vz nx ny nz tx ty'))
self.vao = self.ctx.simple_vertex_array(self.prog, self.vbo, 'in_vert',
'in_norm', 'in_text')
self.vao.scope = self.ctx.scope(mgl.DEPTH_TEST,
samplers=[(self.sampler, 0)])
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()
run_example(CrateExample)
self.crate_x += np.random.uniform(-0.2, 0.2, 32 * 32)
self.crate_y += np.random.uniform(-0.2, 0.2, 32 * 32)
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)
if __name__ == '__main__':
run_example(InstancedCrates)
import os
from PIL import Image
import moderngl.next as mgl
from sampler_basic_example import SamplerBasicExample
from window import run_example
class ClampToEdgeAndBorder(SamplerBasicExample):
gl_version = (3, 3)
aspect_ratio = 1.0
title = "Clamp to Edge and Border"
def __init__(self, **kwargs):
super().__init__(**kwargs)
# self.sampler.border = 0.3
# self.sampler.border = (0.0, 0.5, 1.0, 1.0)
self.sampler.border = (0.0, 0.5, 1.0)
self.sampler.wrap = mgl.CLAMP_TO_EDGE_X | mgl.CLAMP_TO_BORDER_Y
if __name__ == '__main__':
run_example(ClampToEdgeAndBorder)
])
self.sticker_vbo = self.ctx.buffer(sticker_vertices.T.astype('f4').tobytes())
self.sticker_vao = self.ctx.simple_vertex_array(self.prog, self.sticker_vbo, 'in_vert', 'in_norm', 'in_text')
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)
if __name__ == '__main__':
run_example(MugExample)
self.crate_y = (np.repeat(np.arange(32), 32) - 16) * 1.5
self.crate_x += np.random.uniform(-0.2, 0.2, 32 * 32)
self.crate_y += np.random.uniform(-0.2, 0.2, 32 * 32)
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)
if __name__ == '__main__':
run_example(InstancedCrates)
float cm = fract((i == Iter ? 0.0 : float(i)) * 10 / Iter);
f_color = vec4(
fract(cm + 0.0 / 3.0),
fract(cm + 1.0 / 3.0),
fract(cm + 2.0 / 3.0),
1.0
);
}
''',
)
self.center = self.prog['Center']
self.iter = self.prog['Iter']
vertices = np.array([-1.0, -1.0, -1.0, 1.0, 1.0, -1.0, 1.0, 1.0])
self.vbo = self.ctx.buffer(vertices.astype('f4').tobytes())
self.vao = self.ctx.simple_vertex_array(self.prog, self.vbo, 'in_vert')
def render(self, time, frame_time):
self.ctx.clear(1.0, 1.0, 1.0)
self.center.value = (0.49, 0.32)
self.iter.value = 100
self.vao.render(moderngl.TRIANGLE_STRIP)
if __name__ == '__main__':
run_example(Fractal)
(right, top),
],
dtype='f4')
self.texture = self.ctx.texture(
self.img.transpose(Image.FLIP_TOP_BOTTOM).convert('RGB'))
self.sampler = self.ctx.sampler(self.texture)
def render(self, time: float, frame_time: float):
# clear screen
self.ctx.clear(1.0, 1.0, 1.0)
# render texture
self.sampler.use()
self.renderer.render(mgl.TRIANGLE_STRIP,
vertices=self.vertices,
texcoords=self.texcoords)
# render grid
self.renderer.render(mgl.LINES,
vertices=np.array([(i * 0.18, -0.9, i * 0.18, 0.9,
-0.9, i * 0.18, 0.9, i * 0.18)
for i in range(-5, 7, 2)],
'f4').reshape(-1, 2),
texture=False,
color=(0.0, 0.0, 0.0, 1.0))
if __name__ == '__main__':
run_example(SamplerBasicExample)
from PIL import Image
import moderngl.next as mgl
from sampler_basic_example import SamplerBasicExample
from window import run_example
class SamplerWrapModes(SamplerBasicExample):
gl_version = (3, 3)
aspect_ratio = 1.0
title = "Sampler Wrap Modes"
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.sampler.wrap = mgl.REPEAT_X | mgl.MIRROR_CLAMP_TO_EDGE_Y
if __name__ == '__main__':
run_example(SamplerWrapModes)
''',
)
obj = Obj.open(data.find('texture-test-cube.obj'))
self.texture = self.ctx.texture((2, 2, 2), 3, np.random.randint(128, 255, (2, 2, 2, 3), 'u1'))
self.sampler = self.ctx.sampler(self.texture, wrap=mgl.REPEAT_X | mgl.REPEAT_Y | mgl.REPEAT_Z)
self.vbo = self.ctx.buffer(obj.pack('vx vy vz nx ny nz tx ty tz'))
self.vao = self.ctx.simple_vertex_array(self.prog, self.vbo, 'in_vert', 'in_norm', 'in_text')
self.vao.scope = self.ctx.scope(mgl.DEPTH_TEST, samplers=[(self.sampler, 0)])
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()
run_example(CrateExample)
in vec3 v_color;
out vec4 f_color;
void main() {
// We're not interested in changing the alpha value
f_color = vec4(v_color, 1.0);
}
''',
)
# Point coordinates are put followed by the vec3 color values
vertices = np.array([
# x, y, red, green, blue
0.0, 0.8, 1.0, 0.0, 0.0,
-0.6, -0.8, 0.0, 1.0, 0.0,
0.6, -0.8, 0.0, 0.0, 1.0,
])
self.vbo = self.ctx.buffer(vertices.astype('f4').tobytes())
# We control the 'in_vert' and `in_color' variables
self.vao = self.ctx.simple_vertex_array(self.prog, self.vbo, 'in_vert', 'in_color')
def render(self, time: float, frame_time: float):
self.ctx.clear(1.0, 1.0, 1.0)
self.vao.render()
if __name__ == '__main__':
run_example(SimpleColorTriangle)
vertices = np.array([
0.0, 0.0,
-0.6, -0.8,
0.6, -0.8,
0.6, 0.8,
-0.6, 0.8,
])
# Indecies are given to specify the order of drawing
indecies = np.array([0, 1, 2, 0, 3, 4])
self.vbo = self.ctx.buffer(vertices.astype('f4').tobytes())
self.ibo = self.ctx.buffer(indecies.astype('i4').tobytes())
vao_content = [
# 2 floats are assigned to the 'in' variable named 'in_vert' in the shader code
(self.vbo, '2f', 'in_vert')
]
self.vao = self.ctx.vertex_array(self.prog, vao_content, self.ibo)
def render(self, time: float, frame_time: float):
self.ctx.clear(1.0, 1.0, 1.0)
self.vao.render()
if __name__ == '__main__':
run_example(IndexBuffer)
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()
if __name__ == '__main__':
run_example(RenderTextureCompute)
