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))