def __init__(self, **kwargs):
super().__init__(**kwargs)
self.camera.projection.update(near=1, far=200)
self.wnd.mouse_exclusivity = True
# Offscreen buffer
offscreen_size = 1024, 1024
self.offscreen_depth = self.ctx.depth_texture(offscreen_size)
self.offscreen_depth.compare_func = ''
self.offscreen_depth.repeat_x = False
self.offscreen_depth.repeat_y = False
self.offscreen_color = self.ctx.texture(offscreen_size, 4)
self.offscreen = self.ctx.framebuffer(
color_attachments=[self.offscreen_color],
depth_attachment=self.offscreen_depth,
)
# Scene geometry
self.floor = geometry.cube(size=(25.0, 1.0, 25.0))
self.wall = geometry.cube(size=(1.0, 5, 25), center=(-12.5, 2, 0))
self.another_blob = geometry.cube(size=(5, 5, 5), center=(-7, -10, 0))
self.sphere = geometry.sphere(radius=5.0, sectors=64, rings=32)
self.sun = geometry.sphere(radius=1.0)
# Programs
self.basic_light = self.load_program(
'programs/shadow_mapping/directional_light.glsl')
self.basic_light['shadowMap'].value = 0
self.basic_light['color'].value = 1.0, 1.0, 1.0, 1.0
self.shadowmap_program = self.load_program(
'programs/shadow_mapping/shadowmap.glsl')
self.sun_prog = self.load_program('programs/cube_simple.glsl')
self.sun_prog['color'].value = 1, 1, 0, 1
self.lightpos = 0, 0, 0
def __init__(self, ctx, color):
super().__init__(ctx, color,
"programs/shadow_mapping/directional_light.glsl")
self.meshes = [
geometry.cube(size=np.array((7, 5, 1)) / 2, center=(0, 0, -1)),
geometry.cube(size=np.array((2, 2, 1)) / 2, center=(0, 0, 1)),
]
def __init__(self, ctx, color, center_offs=(0, 0, 0)):
super().__init__(ctx, color,
"programs/shadow_mapping/directional_light.glsl")
thicc = 0.4
self.center_offs = center_offs
self.meshes = [
geometry.cube(size=(0, 0, 1), center=(0, 0, 0)),
geometry.cube(size=(0, 0, 1), center=(0, 0, 0)),
geometry.cube(size=(0, 0, 1), center=(0, 0, 0)),
]
def __init__(self, *, ctx: moderngl.Context, size: Tuple[int, int, int]):
self.ctx = ctx
self._size = size
# Create lookup texture for active blocks
# NOTE: We allocate room for 100 x 100 x 100 for now
# 100 x 100 x 100 = 1_000_000 fragments
# 1000 x 1000 = 1_000_000 fragments
# We store several 100 x 100 layers respersting one slice in voxel
self.voxel_lookup = self.ctx.texture((1000, 1000), 1, dtype='f1')
self.voxel_lookup.filter = moderngl.NEAREST, moderngl.NEAREST
self.voxel_lookup.repeat_x = False
self.voxel_lookup.repeat_y = False
# Write in some default data
for i in range(100):
self.fill_layer(i, 255)
# Construct the per-instance data for active cubes using a transform
self.instance_data = ctx.buffer(reserve=self.max_cubes * 4 * 3)
self.quad_fs = geometry.quad_fs()
self.gen_instance_vao = None
self._num_instances = 0
self._query = self.ctx.query(primitives=True)
self.cube = geometry.cube()
self.cube.buffer(self.instance_data, "3f/i", ["in_offset"])
# Filled externally
self.texture_prog = None
self.gen_instance_prog = None
self.voxel_light_prog = None
self.voxel_wireframe_prog = None
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.wnd.mouse_exclusivity = True
self.camera.projection.update(near=1, far=1000)
self.cube = geometry.cube(size=(2, 2, 2))
self.prog = self.load_program('programs/cube_simple_instanced.glsl')
self.prog['m_proj'].write(self.camera.projection.matrix)
self.prog['m_model'].write(Matrix44.identity(dtype='f4'))
# Generate per instance data represeting a grid of cubes
N = 100
self.instances = N * N
def gen_data(x_res, z_res, spacing=2.5):
"""Generates a grid of N * N poistions and random colors on the xz plane"""
for y in range(z_res):
for x in range(x_res):
yield -N * spacing / 2 + spacing * x
yield 0
yield -N * spacing / 2 + spacing * y
yield numpy.random.uniform(0, 1)
yield numpy.random.uniform(0, 1)
yield numpy.random.uniform(0, 1)
self.instance_data = self.ctx.buffer(numpy.fromiter(gen_data(N, N), 'f4', count=self.instances * 6))
self.cube.buffer(self.instance_data, '3f 3f/i', ['in_offset', 'in_color'])
def __init__(self, **kwargs):
super().__init__(**kwargs)
if self.wnd.name != 'pygame2':
raise RuntimeError(
'This example only works with --window pygame2 option')
self.pg_res = (160, 160)
# Create a 24bit (rgba) offscreen surface pygame can render to
self.pg_screen = pygame.Surface(self.pg_res, flags=pygame.SRCALPHA)
# 24 bit (rgba) moderngl texture
self.pg_texture = self.ctx.texture(self.pg_res, 4)
self.pg_texture.filter = moderngl.NEAREST, moderngl.NEAREST
# Simple geometry and shader to render
self.cube = geometry.cube(size=(2.0, 2.0, 2.0))
self.texture_prog = self.load_program(
'programs/cube_simple_texture.glsl')
self.texture_prog['m_proj'].write(
matrix44.create_perspective_projection(60,
self.wnd.aspect_ratio,
1,
100,
dtype='f4'))
self.texture_prog['m_model'].write(
matrix44.create_identity(dtype='f4'))
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.cube = geometry.cube(size=(2, 2, 2))
self.texture = self.load_texture_array('textures/array.png',
layers=10,
mipmap=True,
anisotrpy=8.0)
self.prog = self.load_program('programs/cube_texture_array.glsl')
def __init__(self, **kwargs):
super().__init__(**kwargs)
# do initialization here
self.cube = geometry.cube()
self.prog = self.load_program('programs/cube.glsl')
self.texture = self.load_texture_array(
'textures/pattern.jpg', layers=2, mipmap=True, anisotropy=8.0)
self.prog['texture0'].value = 0
self.prog['layers'].value = 10
self.rotation = self.prog['rotation']
def test_cube(self):
"""Create a cube"""
mesh = geometry.cube(size=(1.0, 1.0, 1.0), name="test_cube")
self.assertEqual(mesh.name, "test_cube")
self.assertIsInstance(mesh.get_buffer_by_name(AttributeNames.POSITION),
BufferInfo)
self.assertIsInstance(mesh.get_buffer_by_name(AttributeNames.NORMAL),
BufferInfo)
self.assertIsInstance(
mesh.get_buffer_by_name(AttributeNames.TEXCOORD_0), BufferInfo)
# Use custom buffer/attribute names
mesh = geometry.cube(size=(1.0, 1.0, 1.0),
name="test_cube",
attr_names=self.custom_attrs)
self.assertIsInstance(
mesh.get_buffer_by_name(self.custom_attrs.POSITION), BufferInfo)
self.assertIsInstance(
mesh.get_buffer_by_name(self.custom_attrs.NORMAL), BufferInfo)
self.assertIsInstance(
mesh.get_buffer_by_name(self.custom_attrs.TEXCOORD_0), BufferInfo)
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.wnd.mouse_exclusivity = True
self.num_layers = 10
self.cube = geometry.cube(size=(2, 2, 2))
self.texture = self.load_texture_array('textures/array.png',
layers=self.num_layers,
mipmap=True,
anisotrpy=8.0)
self.prog = self.load_program('programs/cube_texture_array.glsl')
self.prog['texture0'].value = 0
self.prog['num_layers'].value = 10
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 update_vel(self, vel):
vel = np.array(vel)
ident = np.eye(3)
a = (vel >= 0).astype(int)
b = -(vel < 0).astype(int)
c = a + b
sizes = c * ident * vel + ((1 - ident) / 5)
centers = ident * (-vel / 2) + self.center_offs
temp = [
geometry.cube(size=sizes[0], center=centers[0]),
geometry.cube(size=sizes[1], center=centers[1]),
geometry.cube(size=sizes[2], center=centers[2]),
]
for i in range(len(self.meshes)):
self.meshes[i].release()
self.meshes = temp
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.wnd.mouse_exclusivity = True
self.cube = geometry.cube(size=(20, 20, 20))
self.texture = self.load_texture_cube(
neg_x='textures/cubemaps/yokohama/negx.jpg',
neg_y='textures/cubemaps/yokohama/negy.jpg',
neg_z='textures/cubemaps/yokohama/negz.jpg',
pos_x='textures/cubemaps/yokohama/posx.jpg',
pos_y='textures/cubemaps/yokohama/posy.jpg',
pos_z='textures/cubemaps/yokohama/posz.jpg',
)
self.prog = self.load_program('programs/cubemap.glsl')
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.camera.projection.update(near=1, far=200)
self.wnd.mouse_exclusivity = True
# Offscreen buffer
offscreen_size = 1024, 1024
self.offscreen_depth = self.ctx.depth_texture(offscreen_size)
self.offscreen_depth.compare_func = ''
self.offscreen_depth.repeat_x = False
self.offscreen_depth.repeat_y = False
# Less ugly by default with linear. May need to be NEAREST for some techniques
self.offscreen_depth.filter = moderngl.LINEAR, moderngl.LINEAR
self.offscreen = self.ctx.framebuffer(
depth_attachment=self.offscreen_depth,
)
# Scene geometry
self.floor = geometry.cube(size=(25.0, 1.0, 25.0))
self.wall = geometry.cube(size=(1.0, 5, 25), center=(-12.5, 2, 0))
self.sphere = geometry.sphere(radius=5.0, sectors=64, rings=32)
self.sun = geometry.sphere(radius=1.0)
# Debug geometry
self.offscreen_quad = geometry.quad_2d(size=(0.5, 0.5), pos=(0.75, 0.75))
self.offscreen_quad2 = geometry.quad_2d(size=(0.5, 0.5), pos=(0.25, 0.75))
# Programs
self.raw_depth_prog = self.load_program('programs/shadow_mapping/raw_depth.glsl')
self.basic_light = self.load_program('programs/shadow_mapping/directional_light.glsl')
self.basic_light['shadowMap'].value = 0
self.basic_light['color'].value = 1.0, 1.0, 1.0, 1.0
self.shadowmap_program = self.load_program('programs/shadow_mapping/shadowmap.glsl')
self.texture_prog = self.load_program('programs/texture.glsl')
self.texture_prog['texture0'].value = 0
self.sun_prog = self.load_program('programs/cube_simple.glsl')
self.sun_prog['color'].value = 1, 1, 0, 1
self.lightpos = 0, 0, 0
def __init__(self, path, flip=False, flip_left_right=False, intensity=1.0):
super(Skybox, self).__init__()
ctx = get_context()
self.path = path
#self.smpl = ctx.sampler(compare_func='<=')
self.cube = geometry.cube(size=(1, 1, 1))
self.hide = False
self._items = dict(
intensity = intensity,
texture = load_texture_cube(
path,
flip=flip,
flip_left_right=flip_left_right
),
)
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, 1.0, 1, 100, dtype='f4'))
self.fbo = self.ctx.framebuffer(
color_attachments=self.ctx.texture((512, 512), 4),
depth_attachment=self.ctx.depth_texture((512, 512)),
)
# Ensure imgui knows about this texture
# This is the color layer in the framebuffer
self.imgui.register_texture(self.fbo.color_attachments[0])
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.cube = geometry.cube(size=(2, 2, 2))
shader_source = {
'vertex_shader':
'''
#version 330
in vec3 in_position;
in vec3 in_normal;
uniform vec3 pos_offset;
uniform Projection {
uniform mat4 matrix;
} proj;
uniform View {
uniform mat4 matrix;
} view;
out vec3 normal;
out vec3 pos;
void main() {
vec4 p = view.matrix * vec4(in_position + pos_offset, 1.0);
gl_Position = proj.matrix * p;
mat3 m_normal = transpose(inverse(mat3(view.matrix)));
normal = m_normal * in_normal;
pos = p.xyz;
}
''',
'fragment_shader':
'''
#version 330
out vec4 color;
in vec3 normal;
in vec3 pos;
void main() {
float l = dot(normalize(-pos), normalize(normal));
color = vec4(1.0) * (0.25 + abs(l) * 0.75);
}
''',
}
self.prog1 = self.ctx.program(**shader_source)
self.prog1['pos_offset'].value = (1.1, 0, 0)
self.prog2 = self.ctx.program(**shader_source)
self.prog2['pos_offset'].value = (-1.1, 0, 0)
self.vao1 = self.cube.instance(self.prog1)
self.vao2 = self.cube.instance(self.prog2)
self.m_proj = matrix44.create_perspective_projection_matrix(
75,
self.wnd.aspect_ratio, # fov, aspect
0.1,
100.0, # near, far
dtype='f4',
)
proj_uniform1 = self.prog1['Projection']
view_uniform1 = self.prog1['View']
proj_uniform2 = self.prog2['Projection']
view_uniform2 = self.prog2['View']
self.proj_buffer = self.ctx.buffer(reserve=proj_uniform1.size)
self.view_buffer = self.ctx.buffer(reserve=view_uniform1.size)
proj_uniform1.binding = 1
view_uniform1.binding = 2
proj_uniform2.binding = 1
view_uniform2.binding = 2
self.proj_buffer.write(self.m_proj.tobytes())
self.scope1 = self.ctx.scope(
self.ctx.fbo,
enable_only=moderngl.CULL_FACE | moderngl.DEPTH_TEST,
uniform_buffers=[
(self.proj_buffer, 1),
(self.view_buffer, 2),
],
)
self.scope2 = self.ctx.scope(
self.ctx.fbo,
enable_only=moderngl.CULL_FACE | moderngl.DEPTH_TEST,
uniform_buffers=[
(self.proj_buffer, 1),
(self.view_buffer, 2),
],
)
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.camera.projection.update(near=1, far=200)
self.wnd.mouse_exclusivity = True
# Offscreen buffer
offscreen_size = 1024, 1024
self.offscreen_depth = self.ctx.depth_texture(offscreen_size)
self.offscreen_depth.compare_func = ''
self.offscreen_depth.repeat_x = False
self.offscreen_depth.repeat_y = False
self.offscreen_color = self.ctx.texture(offscreen_size, 4)
self.offscreen = self.ctx.framebuffer(
color_attachments=[self.offscreen_color],
depth_attachment=self.offscreen_depth,
)
# Scene geometry
self.hmd = geometry.cube(size=np.array((7, 5, 1))/2, center=(0, 0, 0))
self.hmd2 = geometry.cube(size=np.array((2, 2, 1))/2, center=(0, 0, 2))
self.handL = geometry.cube(size=np.array((2, 2, 5))/2, center=(0, 0, 0))
self.handL2 = geometry.cube(size=np.array((1, 1, 1))/2, center=(2, 0, 0))
self.handL3 = geometry.cube(size=np.array((1, 1, 1))/2, center=(0, 0, 4))
self.handR = geometry.cube(size=np.array((2, 2, 5))/2, center=(0, 0, 0))
self.handR2 = geometry.cube(size=np.array((1, 1, 1))/2, center=(2, 0, 0))
self.handR3 = geometry.cube(size=np.array((1, 1, 1))/2, center=(0, 0, 4))
self.floor = geometry.cube(size=np.array((100, 0.3, 100)), center=(0, -16, 0))
# self.sun = geometry.sphere(radius=1.0)
# Debug geometry
self.offscreen_quad = geometry.quad_2d(size=(0.5, 0.5), pos=(0.75, 0.75))
self.offscreen_quad2 = geometry.quad_2d(size=(0.5, 0.5), pos=(0.25, 0.75))
# Programs
self.raw_depth_prog = self.load_program('programs/shadow_mapping/raw_depth.glsl')
# self.basic_light = self.load_program('programs/shadow_mapping/directional_light.glsl')
# self.basic_light['shadowMap'].value = 0
# self.basic_light['color'].value = 1.0, 1.0, 1.0, 1.0
self.shadowmap_program = self.load_program('programs/shadow_mapping/shadowmap.glsl')
self.basic_lightL = self.load_program('programs/shadow_mapping/directional_light.glsl')
self.basic_lightL['shadowMap'].value = 0
self.basic_lightL['color'].value = 0.0, 1.0, 0.0, 1.0
self.basic_lightR = self.load_program('programs/shadow_mapping/directional_light.glsl')
self.basic_lightR['shadowMap'].value = 0
self.basic_lightR['color'].value = 0.0, 0.0, 1.0, 1.0
self.basic_lightHmd = self.load_program('programs/shadow_mapping/directional_light.glsl')
self.basic_lightHmd['shadowMap'].value = 0
self.basic_lightHmd['color'].value = 1.0, 0.0, 0.0, 1
self.basic_lightFloor = self.load_program('programs/shadow_mapping/directional_light.glsl')
self.basic_lightFloor['shadowMap'].value = 0
self.basic_lightFloor['color'].value = 1.0, 1.0, 1.0, 1
self.texture_prog = self.load_program('programs/texture.glsl')
self.texture_prog['texture0'].value = 0
self.sun_prog = self.load_program('programs/cube_simple.glsl')
self.sun_prog['color'].value = 1, 1, 0, 1
self.lightpos = 0, 0, 0
time = 2
self.lightpos = Vector3((math.sin(time) * 20, 5, math.cos(time) * 20), dtype='f4')
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.wnd.mouse_exclusivity = True
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
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.camera.projection.update(near=1, far=200)
self.wnd.mouse_exclusivity = True
# Offscreen buffer
offscreen_size = 1024, 1024
self.offscreen_depth = self.ctx.depth_texture(offscreen_size)
self.offscreen_depth.compare_func = ""
self.offscreen_depth.repeat_x = False
self.offscreen_depth.repeat_y = False
self.offscreen_color = self.ctx.texture(offscreen_size, 4)
self.offscreen = self.ctx.framebuffer(
color_attachments=[self.offscreen_color],
depth_attachment=self.offscreen_depth,
)
# Scene geometry
self.floor = geometry.cube(size=np.array((100, 0.3, 100)),
center=(0, -16, 0))
# self.sun = geometry.sphere(radius=1.0)
# Debug geometry
self.offscreen_quad = geometry.quad_2d(size=(0.5, 0.5),
pos=(0.75, 0.75))
self.offscreen_quad2 = geometry.quad_2d(size=(0.5, 0.5),
pos=(0.25, 0.75))
# Programs
self.raw_depth_prog = self.load_program(
"programs/shadow_mapping/raw_depth.glsl")
# self.basic_light = self.load_program('programs/shadow_mapping/directional_light.glsl')
# self.basic_light['shadowMap'].value = 0
# self.basic_light['color'].value = 1.0, 1.0, 1.0, 1.0
self.shadowmap_program = self.load_program(
"programs/shadow_mapping/shadowmap.glsl")
self.basic_lightFloor = self.load_program(
"programs/shadow_mapping/directional_light.glsl")
self.basic_lightFloor["shadowMap"].value = 0
self.basic_lightFloor["color"].value = 1.0, 1.0, 1.0, 1
self.texture_prog = self.load_program("programs/texture.glsl")
self.texture_prog["texture0"].value = 0
self.sun_prog = self.load_program("programs/cube_simple.glsl")
self.sun_prog["color"].value = 1, 1, 0, 1
self.lightpos = 0, 0, 0
time = 2
self.lightpos = Vector3((math.sin(time) * 20, 5, math.cos(time) * 20),
dtype="f4")
self.device_list = []
np.random.seed(69)
for i in myDriver.device_order:
if i == "h":
self.device_list.append(
(Device_hmd(
self.ctx,
tuple(np.random.randint(100, size=(4, )) / 100)),
Velocity_vector(self.ctx, (1, 0, 0, 1))))
elif i == "c":
self.device_list.append(
(Device_cntrlr(
self.ctx,
tuple(np.random.randint(100, size=(4, )) / 100)),
Velocity_vector(self.ctx, (1, 0, 0, 1),
(-0.75, 0, -1.75))))
elif i == "t":
self.device_list.append(
(Device_trkr(
self.ctx,
tuple(np.random.randint(100, size=(4, )) / 100)),
Velocity_vector(self.ctx, (1, 0, 0, 1))))
def __init__(self, pos=(0, 0, 0), size=(1, 1, 1)):
super().__init__()
self._cube = geometry.cube(size=size, center=pos)
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.cube = geometry.cube(size=(2, 2, 2))
self.prog = self.load_program('programs/cube_simple.glsl')
self.prog['m_proj'].write(self.camera.projection.tobytes())
self.prog['color'].value = (1.0, 1.0, 1.0, 1.0)
