def __init__(self, **kwargs):
super().__init__(**kwargs)
self.texture = self.render_cairo_to_texture(512, 512)
self.quad_fs = geometry.quad_fs()
self.prog = self.ctx.program(
vertex_shader="""
#version 330
in vec3 in_position;
in vec2 in_texcoord_0;
out vec2 uv;
void main() {
gl_Position = vec4(in_position, 1.0);
uv = in_texcoord_0;
}
""",
fragment_shader="""
#version 330
uniform sampler2D texture0;
in vec2 uv;
out vec4 outColor;
void main() {
outColor = texture(texture0, uv);
}
""",
)
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 = False
self.bpm = 242 # Hardcode bpm from info.dat
self.camera = KeyboardCamera(self.wnd.keys,
fov=60,
near=1.0,
far=1000.0)
self.camera.velocity = 50
self.camera_enabled = False
meta = self.load_json('megalovania_remix/info.dat')
self.map = BSScene(
self.load_scene('bs_map3.glb'),
self.camera,
BSTrack('megalovania_remix/Expert.dat', meta['_beatsPerMinute']),
)
self.quad_fs = geometry.quad_fs()
# Postprocess programs
self.copy_prog = self.load_program('programs/copy.glsl')
self.copy_greyscale_prog = self.load_program(
'programs/copy_greyscale.glsl')
self.blur_h_prog = self.load_program('programs/blur_h.glsl')
self.blur_v_prog = self.load_program('programs/blur_v.glsl')
self.combine = self.load_program('programs/combine.glsl')
self.combine['texture1'] = 1
# blur stuff
self.offscreen_texture = self.ctx.texture(
(self.wnd.buffer_width, self.wnd.buffer_height), 4)
self.offscreen_depth = self.ctx.depth_texture(
(self.wnd.buffer_width, self.wnd.buffer_height))
self.offscreen = self.ctx.framebuffer(
color_attachments=[self.offscreen_texture],
depth_attachment=self.offscreen_depth,
)
bd = 1
self.blur_h_texture = self.ctx.texture(
(self.wnd.buffer_width // bd, self.wnd.buffer_height // bd), 4)
self.blur_h_texture.repeat_x = False
self.blur_h_texture.repeat_y = False
self.blur_h = self.ctx.framebuffer(
color_attachments=[self.blur_h_texture])
self.blur_v_texture = self.ctx.texture(
(self.wnd.buffer_width // bd, self.wnd.buffer_height // bd), 4)
self.blur_v_texture.repeat_x = False
self.blur_v_texture.repeat_y = False
self.blur_v = self.ctx.framebuffer(
color_attachments=[self.blur_v_texture])
self.music_player = Player()
self.music_source = StaticSource(
load(RESOURCE_DIR / 'megalovania_remix/song.wav'))
self.music_player.queue(self.music_source)
self.music_player.play()
# self.music_player.seek(60.0 * 4 + 50)
self.music_player.volume = 1.0
def __init__(self, **kwargs):
super().__init__(**kwargs)
# Finetune camera
self.wnd.mouse_exclusivity = True
self.camera.projection.update(near=.01, far=100)
self.camera.mouse_sensitivity = .5
self.camera.velocity = 2.5
self.camera.projection.update(fov=60)
# Scene states
self.with_blending = False
self.line_color = (0.0, 0.0, 0.0)
self.mesh_color = (0.0, 0.8, 0.0)
self.threshold = 0.5
# For rendering background
self.quad_fs = geometry.quad_fs()
# (172575,) | 57,525 vertices
vertices = np.load(self.resource_dir /
'data/tetrahedral_mesh/mesh_nodes.npy')
vertices = np.concatenate(vertices)
# (259490, 4) (1037960,) indices
indices = np.load(self.resource_dir /
'data/tetrahedral_mesh/element_nodes.npy')
indices = np.concatenate(indices) - 1
# Probability of a tetrahedron is still alive
w, h = 8192, int(np.ceil(indices.shape[0] / 8192))
self.alive_data = np.random.random_sample(w * h)
self.alive_texture = self.ctx.texture((w, h), 1, dtype='f2')
self.alive_texture.write(self.alive_data.astype('f2'))
# Original geometry with indices
self.geometry = VAO(name='geometry_indices')
self.geometry.buffer(vertices, '3f', 'in_position')
self.geometry.index_buffer(indices, index_element_size=4)
self.prog_background = self.load_program(
'programs/tetrahedral_mesh/bg.glsl')
self.prog_gen_tetra = self.load_program(
vertex_shader='programs/tetrahedral_mesh/gen_tetra_vert.glsl',
geometry_shader='programs/tetrahedral_mesh/gen_tetra_geo.glsl',
fragment_shader='programs/tetrahedral_mesh/gen_tetra_frag.glsl',
)
self.prog_gen_tetra_lines = self.load_program(
vertex_shader='programs/tetrahedral_mesh/gen_tetra_vert.glsl',
geometry_shader='programs/tetrahedral_mesh/gen_tetra_geo.glsl',
fragment_shader='programs/tetrahedral_mesh/lines_frag.glsl',
)
# Query object for measuring the rendering call in OpenGL
# It delivers the GPU time it took to process commands
self.query = self.ctx.query(samples=True,
any_samples=True,
time=True,
primitives=True)
self.total_elapsed = 0
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.compute_shader = self.load_compute_shader(
'programs/compute/render_to_texture.glsl')
self.compute_shader['destTex'] = 0
self.texture_program = self.load_program('programs/texture.glsl')
self.quad_fs = geometry.quad_fs()
self.texture = self.ctx.texture((256, 256), 4)
self.texture.filter = mgl.NEAREST, mgl.NEAREST
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 __init__(self, *args, **kwargs) -> None:
super().__init__(*args, **kwargs)
self.quad_fs = geometry.quad_fs()
self.hsv_program = self.load_program("hsv_picker_shader.glsl")
self.hsv_program["wnd_size"].value = self.wnd.buffer_size
# change this if you want it to go faster/slower
self.hsv_program["speed"].value = 0.25
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.quad_fs = geometry.quad_fs()
self.gradient_program = self.load_program('my_shader.glsl')
self.gradient_program['wnd_size'].value = self.wnd.buffer_size
# change this if you want it to go faster/slower
self.gradient_program['speed'].value = 7.5
def test_quad_fs(self):
"""Create a fullscreen quad"""
mesh = geometry.quad_fs(name="test_quad_fs")
self.assertEqual(mesh.name, "test_quad_fs")
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.quad_fs(name="test_quad_fs",
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)
# Create a 24bit (rgba) offscreen surface pygame can render to
self.pg_screen = pygame.Surface(self.window_size, flags=pygame.SRCALPHA)
# 24 bit (rgba) moderngl texture
self.pg_texture = self.ctx.texture(self.window_size, 4)
self.pg_texture.filter = moderngl.NEAREST, moderngl.NEAREST
self.texture_program = self.load_program('programs/texture.glsl')
self.quad_texture = self.load_texture_2d('textures/python-bg.png')
self.quad_fs = geometry.quad_fs()
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.player = Player(
self.ctx, self.resource_dir / 'videos/Lightning - 33049.mp4')
print("duration :", self.player.duration)
print("fps :", self.player.fps)
print("video_size :", self.player.video_size)
print("frames :", self.player.frames)
print("step :", self.player._decoder.frame_step)
self.quad = geometry.quad_fs()
self.program = self.load_program('programs/texture_flipped.glsl')
def test_render(self):
"""Render something simple to the framebuffer"""
self.window.use()
self.window.clear()
prog = resources.programs.load(
ProgramDescription(path="programs/white.glsl"))
quad = geometry.quad_fs()
quad.render(prog)
# Ensure all fragments (rgba) values are white
data = self.window.fbo.read(components=4)
self.assertEqual(
data, b'\xff' * (self.window_size[0] * self.window_size[1] * 4))
def __init__(self, **kwargs):
super().__init__(**kwargs)
# reference compute shader: http://wili.cc/blog/opengl-cs.html
self.compute = self.ctx.compute_shader(COMPUTE_SHADER)
self.compute['destTex'] = 0
# For rendering a simple textured quad
self.quad_program = self.ctx.program(vertex_shader=vertex_shader, fragment_shader=fragment_shader)
# RGB_8 texture
self.texture = self.ctx.texture((256, 256), 4)
self.texture.filter = mgl.NEAREST, mgl.NEAREST
self.quad_fs = geometry.quad_fs()
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._main_program_mtime = 0
self._main_program_path = FilesystemFinder().find(
Path(self.main_program))
self._main_program = None
self.load_main_program()
self._quad_fs = geometry.quad_fs()
self._fallback_program = self.load_program(
'shadertoy/programs/fallback.glsl')
self._error_state = False
self._mouse_pos = 0, 0
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.quad_fs = quad_fs()
self.fractal_program = self.load_program('my_shader.glsl')
self.fractal_program['wnd_size'].value = self.wnd.buffer_size
self.fractal_program['c'].value = (-0.7269, 0.1889)
self.fractal_program['iter'].value = 1000
self.fractal_program['R'].value = 2
self.zoom = 1
self.center = (0, 0)
def __init__(self, **kwargs):
super().__init__(**kwargs)
# reference compute shader: http://wili.cc/blog/opengl-cs.html
self.compute = self.ctx.compute_shader('''
#version 430
layout (local_size_x = 16, local_size_y = 16) in;
layout(rg32f, location=0) writeonly uniform image2D destTex;
uniform float time;
void main() {
ivec2 ij = ivec2(gl_GlobalInvocationID.xy);
float localCoef = length(vec2(ivec2(gl_LocalInvocationID.xy) - 8) / 8.0);
float globalCoef = sin(float(gl_WorkGroupID.x+gl_WorkGroupID.y) * 0.1 + time) * 0.5;
imageStore(destTex, ij, vec4(1.0 - globalCoef * localCoef, 0.0, 0.0, 0.0));
}
''')
self.compute['destTex'] = 0
# For rendering a simple textured quad
self.quad_program = self.ctx.program(
vertex_shader="""
#version 330
in vec3 in_position;
in vec2 in_texcoord_0;
out vec2 uv;
void main() {
gl_Position = vec4(in_position, 1.0);
uv = in_texcoord_0;
}
""",
fragment_shader="""
#version 330
uniform sampler2D texture0;
out vec4 fragColor;
in vec2 uv;
void main() {
fragColor = texture(texture0, uv);
}
""",
)
# GL_R32F texture
self.texture = self.ctx.texture((256, 256), 1, dtype='f4')
self.texture.filter = mgl.LINEAR, mgl.LINEAR
self.quad_fs = geometry.quad_fs()
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.quad = geometry.quad_fs()
#
self.texture = self.load_texture_2d('textures/grid.png')
# self.texture.filter = moderngl.NEAREST, moderngl.NEAREST
self.texture.filter = moderngl.NEAREST, moderngl.LINEAR
self.texture.repeat_x = False
self.texture.repeat_y = False
#
self.texture.build_mipmaps(max_level=5)
# TODO: bug, can't set nearest with mipmap !
# self.texture.filter = moderngl.NEAREST_MIPMAP_NEAREST, moderngl.NEAREST_MIPMAP_NEAREST
self.texture.filter = moderngl.LINEAR_MIPMAP_LINEAR, moderngl.LINEAR_MIPMAP_LINEAR
self.prog = self.load_program('programs/interpolation.glsl')
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 = (320, 180)
# 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
self.texture_program = self.load_program('programs/texture.glsl')
self.quad_fs = geometry.quad_fs()
def initGL(self):
self.vertexShaderFile = 'dbray/shaders/vertex.glsl'
self.fragmentShaderFile = 'dbray/shaders/fragment.glsl'
self.FSProgram = resources.programs.load(
ProgramDescription(
vertex_shader=self.vertexShaderFile,
fragment_shader=self.fragmentShaderFile,
))
self.cameraPositionUniform = self.FSProgram['cameraPosition']
self.cameraOrthoForwardUniform = self.FSProgram['cameraForward']
self.cameraOrthoRightUniform = self.FSProgram['cameraRight']
self.cameraOrthoUpUniform = self.FSProgram['cameraUp']
self.cameraPositionUniform.value = tuple(self.camera.location)
self.cameraOrthoForwardUniform.value = tuple(self.camera.orthoForward)
self.cameraOrthoRightUniform.value = tuple(self.camera.orthoRight)
self.cameraOrthoUpUniform.value = tuple(self.camera.orthoUp)
self.FSProgram['numObjects'] = self.scene.getNumObjects()
self.FSProgram['lightPosition'].value = (0.0, 120.0, 200.0)
self.FSProgram['projScale'].value = 1.5
self.FSProgram['aspectRatio'] = self.width / self.height
ysampInc = 1.0 / self.height
xsampInc = 1.0 / self.width
samples = []
numSamples = 4
numSample1 = int(math.sqrt(numSamples) + 0.1)
for x in range(numSample1):
for y in range(numSample1):
samples.append(
((x / numSample1) * xsampInc, (y / numSample1) * ysampInc))
self.FSProgram['samples'].value = samples
self.texture = self.ctx.texture(
[self.sceneArray.shape[1], self.sceneArray.shape[0]],
3,
self.sceneArray.tobytes(),
dtype='f4')
self.texture.filter = (mgl.NEAREST, mgl.NEAREST)
self.quad_fs = geometry.quad_fs()
def __init__(self, **kwargs):
super().__init__(**kwargs)
# self.wnd.mouse_exclusivity = True
self.camera.mouse_sensitivity = 0.1
self.camera.velocity = 100.0
self.camera.projection.update(near=0.01, far=1000)
self.camera_enabled = False
# Framebuffers & Postprocessing stuff
self.screen_quad = geometry.quad_fs()
self.screen_quad_prog = self.load_program('programs/screen_quad.glsl')
self.offscreen = self.ctx.framebuffer(
color_attachments=[self.ctx.texture(self.wnd.size, 4)],
depth_attachment=self.ctx.depth_texture(self.wnd.size),
)
# --- Global resources
avatar_size = 256
avatar_count = 22
data = self.load_binary('avatars.bin')
self.avatar_texture = self.ctx.texture_array(
(avatar_size, avatar_size, avatar_count), 4, data=data)
self.avatar_texture.build_mipmaps()
# --- Initialize effects
self.router = EffecRouter(self)
# --- All timer and track related here
self.track_cam_x = tracks.get('camera:pos_x')
self.track_cam_y = tracks.get('camera:pos_y')
self.track_cam_z = tracks.get('camera:pos_z')
self.track_cam_rot_x = tracks.get('camera:rot_x')
self.track_cam_rot_z = tracks.get('camera:rot_y')
self.track_cam_rot_tilt = tracks.get('camera:tilt')
self.track_fade = tracks.get('camera:fade')
# self.timer = RocketTimer()
self.timer = RocketMusicTimer()
self.timer.start()
self.frame_time = 60.0 / 1000.0
self.prev_time = 0
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.quad_fs = geometry.quad_fs()
self.n = 512
self.voronoi_program = self.load_program('my_shader.glsl')
self.voronoi_program['iResolution'].value = (self.wnd.buffer_size[0],
self.wnd.buffer_size[1])
self.seeds = np.random.random_sample((self.n, 2))
self.seeds_buffer = self.ctx.buffer(
data=self.seeds.astype('f4').tobytes())
colors = np.random.random_sample((self.n, 3))
self.color_buffer = self.ctx.buffer(data=colors.astype('f4').tobytes())
self.velocities = (np.random.random_sample((self.n, 2)) - .5) / 250
self.voronoi_program['Seeds'].binding = 0
self.voronoi_program['Colors'].binding = 1
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.fs_quad = quad_fs(normals=False)
self.display_program = self.load_program("display.glsl")
self.display_program["texture0"] = 2
self.cs = self.load_compute_shader(
"compute.glsl",
{
"LX": self.local_size[0],
"LY": self.local_size[1],
"W": self.world_size[0],
"H": self.world_size[1],
},
)
empty = np.zeros((*self.world_size, 4), dtype="u1")
self.world_a = self.ctx.texture(self.world_size,
4,
data=empty,
dtype="u1")
self.world_b = self.ctx.texture(self.world_size,
4,
data=empty,
dtype="u1")
self.world_a.filter = mgl.NEAREST, mgl.NEAREST
self.world_b.filter = mgl.NEAREST, mgl.NEAREST
# draw a line of sand vertically
self.world_a.write(
np.array(np.random.random(size=(1500, 4)) + 0.5).astype("u1"),
viewport=(100, 100, 100, 15),
)
self.fbo_a = self.ctx.framebuffer(color_attachments=(self.world_a, ))
self.fbo_b = self.ctx.framebuffer(color_attachments=(self.world_b, ))
# toggle to switch between textures
self.toggle = False
def __init__(self, **kwargs) -> None:
super().__init__(**kwargs)
# load programs
self.compute_shader = self.load_compute("compute_shader.glsl",
self.consts)
self.program = self.load_program("render_world.glsl")
self.world_generation_program = self.load_program(
"generate_world.glsl")
self.quad_fs = quad_fs()
self.program["texture0"] = 0
self.zoom = 0.15
self.program["scale"] = self.zoom
self.zoom_center = (0.5, 0.5)
self.program["scaleCenter"].value = self.zoom_center
# create the two textures
load_image = False
if load_image:
self.texture01 = self.load_texture_2d("acorn.png")
self.texture02 = self.load_texture_2d("acorn.png")
else:
self.texture01 = self.ctx.texture(self.DIM, 4, dtype="f1")
self.texture02 = self.ctx.texture(self.DIM, 4, dtype="f1")
self.generate_world()
self.texture01.filter = moderngl.NEAREST, moderngl.NEAREST
self.texture01.repeat_x, self.texture01.repeat_y = False, False
self.texture02.filter = moderngl.NEAREST, moderngl.NEAREST
self.texture02.repeat_x, self.texture02.repeat_y = False, False
self.toggle = False
self.paused = False
self._paused_last = time.time()
self._pause_cool_down = 0.1
self.last_frame = -10
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.buffer_size = 320, 256
# Textures
self.background_texture = self.load_texture_array(
'textures/animated_sprites/giphy.gif')
self.background_texture.repeat_x = False
self.background_texture.repeat_y = False
self.caveman_texture = self.load_texture_array(
'textures/animated_sprites/player_2.gif', layers=35)
self.caveman_texture.repeat_x = False
self.caveman_texture.repeat_y = False
self.caveman_texture.filter = moderngl.NEAREST, moderngl.NEAREST
# Geometry
# One pixel quad 0, 0 -> 1.0, 1.0
self.sprite_geometry = geometry.quad_2d(size=(1.0, 1.0),
pos=(0.5, 0.5))
self.quad_fs = geometry.quad_fs()
# Programs
self.sprite_program = self.load_program(
'programs/animated_sprites/sprite_array.glsl')
self.texture_program = self.load_program('programs/texture.glsl')
# Offscreen buffer
self.offscreen_texture = self.ctx.texture(self.buffer_size, 4)
self.offscreen_texture.filter = moderngl.NEAREST, moderngl.NEAREST
self.offscreen = self.ctx.framebuffer(
color_attachments=[self.offscreen_texture])
self.projection = Matrix44.orthogonal_projection(0,
320,
0,
256,
-1.0,
1.0,
dtype='f4')
self.sprite_program['projection'].write(self.projection)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
imgui.create_context()
self.wnd.ctx.error
self.imgui = ModernglWindowRenderer(self.wnd)
self.world_texture01 = self.ctx.texture(self.map_size, 1, dtype="f1")
self.world_texture01.repeat_x, self.world_texture01.repeat_y = False, False
self.world_texture01.filter = mgl.NEAREST, mgl.NEAREST
self.world_texture02 = self.ctx.texture(self.map_size, 1, dtype="f1")
self.world_texture02.repeat_x, self.world_texture02.repeat_y = False, False
self.world_texture02.filter = mgl.NEAREST, mgl.NEAREST
data = gen_data(SlimeConfig.N, self.map_size).astype("f4")
self.slimes = self.ctx.buffer(data) # each slime has a position and angle
self.load_programs()
self.update_uniforms()
self.quad_fs = quad_fs(normals=False)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.size = self.wnd.buffer_size
self.viewport = (0, 0, self.size[0], self.size[1])
self.quad_fs = geometry.quad_fs()
self.sprite = geometry.quad_2d(size=(9 / self.wnd.size[0], 9 / self.wnd.size[1]))
self.texture_1 = self.ctx.texture(self.size, components=3)
self.texture_2 = self.ctx.texture(self.size, components=3)
self.fbo_1 = self.ctx.framebuffer(color_attachments=[self.texture_1])
self.fbo_1.viewport = self.viewport
self.fbo_2 = self.ctx.framebuffer(color_attachments=[self.texture_2])
self.fbo_2.viewport = self.viewport
drop = np.array([[0.0, 0.0, 1/6, 1/5, 1/4, 1/5, 1/6, 0.0, 0.0],
[0.0, 1/6, 1/5, 1/4, 1/3, 1/4, 1/5, 1/6, 0.0],
[1/6, 1/5, 1/4, 1/3, 1/2, 1/3, 1/4, 1/5, 1/6],
[1/5, 1/4, 1/3, 1/2, 1.0, 1/2, 1/3, 1/4, 1/5],
[1/4, 1/3, 1/2, 1.0, 1.0, 1.0, 1/2, 1/3, 1/4],
[1/5, 1/4, 1/3, 1/2, 1.0, 1/2, 1/3, 1/4, 1/5],
[1/6, 1/5, 1/4, 1/3, 1/2, 1/3, 1/4, 1/5, 1/6],
[0.0, 1/6, 1/5, 1/4, 1/3, 1/4, 1/5, 1/6, 0.0],
[0.0, 0.0, 1/6, 1/5, 1/4, 1/5, 1/6, 0.0, 0.0]])
self.drops_texture = self.ctx.texture((9, 9), components=1, dtype='f4')
self.drops_texture.write(drop.astype('f4').tobytes())
# programs
self.drop_program = self.load_program('programs/water/drop.glsl')
self.wave_program = self.load_program('programs/water/wave.glsl')
self.texture_program = self.load_program('programs/water/texture.glsl')
self.wave_program['texture0'].value = 0
self.wave_program['texture1'].value = 1
self.mouse_pos = 0, 0
self.wnd.fbo.viewport = self.viewport
def __init__(self, **kwargs):
super().__init__(**kwargs)
# Offscreen buffers
self.texture_1 = self.ctx.texture(self.wnd.buffer_size, 4, dtype='f4')
self.texture_2 = self.ctx.texture(self.wnd.buffer_size, 4, dtype='f4')
self.fbo_1 = self.ctx.framebuffer(color_attachments=[self.texture_1])
self.fbo_2 = self.ctx.framebuffer(color_attachments=[self.texture_1])
# VAOs
self.quad_fs = geometry.quad_fs()
N = 1000
def gen_boids(n):
for i in range(n):
yield random.uniform(-1, 1)
yield random.uniform(-1, 1)
yield random.uniform(-1, 1)
yield random.uniform(-1, 1)
data = np.fromiter(gen_boids(N), dtype='f4', count=N * 4)
self.boids_buffer_1 = self.ctx.buffer(data=data)
self.boids_buffer_2 = self.ctx.buffer(reserve=data.nbytes)
self.boids_vao_1 = VAO(name='boids_1')
self.boids_vao_1.buffer(self.boids_buffer_1, '2f 2f',
['in_position', 'in_velocity'])
self.boids_vao_2 = VAO(name='boids_2')
self.boids_vao_2.buffer(self.boids_buffer_2, '2f 2f',
['in_position', 'in_velocity'])
# Programs
self.tex_prog = self.load_program('programs/texture.glsl')
self.tex_prog['texture0'].value = 0
self.boid_points = self.load_program(
'programs/boids2/boid_points.glsl')
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.quad = geometry.quad_fs()
self.texture = self.load_texture_2d('textures/python-bg.png')
self.prog = self.load_program('programs/texture.glsl')
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.program = self.load_program('programs/blend_include.glsl')
self.texture_0 = self.load_texture_2d('textures/cubemaps/yokohama/negx.jpg')
self.texture_1 = self.load_texture_2d('textures/cubemaps/yokohama/negz.jpg')
self.quad_fs = geometry.quad_fs()
def __init__(self, **kwargs):
super().__init__(**kwargs)
print("window buffer size:", self.wnd.buffer_size)
self.marker_file = Path('markers.bin')
# Object rotation
self.x_rot = 0
self.y_rot = 0
# Object position
self.zoom = 0
# Load scene cached to speed up loading!
self.scene = self.load_scene('scenes/fragment_picking/centered.obj',
cache=True)
# Grab the raw mesh/vertexarray
self.mesh = self.scene.root_nodes[0].mesh.vao
self.mesh_texture = self.scene.root_nodes[
0].mesh.material.mat_texture.texture
self.projection = Projection3D(
fov=60,
aspect_ratio=self.wnd.aspect_ratio,
near=1.0,
far=100.0,
)
# --- Offscreen render target
# RGBA color/diffuse layer
self.offscreen_diffuse = self.ctx.texture(self.wnd.buffer_size, 4)
# Textures for storing normals (16 bit floats)
self.offscreen_normals = self.ctx.texture(self.wnd.buffer_size,
4,
dtype='f2')
# Texture for storing the view positions rendered to framebuffer
self.offscreen_viewpos = self.ctx.texture(self.wnd.buffer_size,
4,
dtype='f4')
# Texture for storing depth values
self.offscreen_depth = self.ctx.depth_texture(self.wnd.buffer_size)
# Create a framebuffer we can render to
self.offscreen = self.ctx.framebuffer(
color_attachments=[
self.offscreen_diffuse,
self.offscreen_normals,
self.offscreen_viewpos,
],
depth_attachment=self.offscreen_depth,
)
# This is just for temp changing depth texture parameters
# temporary so we can use it as a normal texture
self.depth_sampler = self.ctx.sampler(
filter=(moderngl.LINEAR, moderngl.LINEAR),
compare_func='',
)
# A fullscreen quad just for rendering offscreen textures to the window
self.quad_fs = geometry.quad_fs()
# --- Shaders
# Simple program just rendering texture
self.texture_program = self.load_program(
'programs/fragment_picking/texture.glsl')
self.texture_program['texture0'].value = 0
# Geomtry shader writing to two offscreen layers (color, normal) + depth
self.geometry_program = self.load_program(
'programs/fragment_picking/geometry.glsl')
self.geometry_program['texture0'].value = 0 # use texture channel 0
# Shader for linearizing depth (debug visualization)
self.linearize_depth_program = self.load_program(
'programs/linearize_depth.glsl')
self.linearize_depth_program['texture0'].value = 0
self.linearize_depth_program['near'].value = self.projection.near
self.linearize_depth_program['far'].value = self.projection.far
# Shader for picking the world position of a fragment
self.fragment_picker_program = self.load_program(
'programs/fragment_picking/picker.glsl')
self.fragment_picker_program[
'position_texture'].value = 0 # Read from texture channel 0
self.fragment_picker_program[
'normal_texture'].value = 1 # Read from texture channel 1
self.fragment_picker_program[
'diffuse_texture'].value = 2 # Read from texture channel 2
# Picker geometry
self.marker_byte_size = 7 * 4 # position + normal + temperature (7 x 32bit floats)
self.picker_output = self.ctx.buffer(reserve=self.marker_byte_size)
self.picker_vao = VAO(mode=moderngl.POINTS)
# Shader for rendering markers
self.marker_program = self.load_program(
'programs/fragment_picking/markers.glsl')
self.marker_program['color'].value = 1.0, 0.0, 0.0, 1.0
# Marker geometry
self.marker_buffer = self.ctx.buffer(
reserve=self.marker_byte_size *
1000) # Resever room for 1000 points
self.marker_vao = VAO(name="markers", mode=moderngl.POINTS)
self.marker_vao.buffer(self.marker_buffer, '3f 3f 1f',
['in_position', 'in_normal', 'temperature'])
self.num_markers = 0
# Debug geometry
self.quad_normals = geometry.quad_2d(size=(0.25, 0.25),
pos=(0.75, 0.875))
self.quad_depth = geometry.quad_2d(size=(0.25, 0.25), pos=(0.5, 0.875))
self.quad_positions = geometry.quad_2d(size=(0.25, 0.25),
pos=(0.25, 0.875))
