def _compute_animation(cfg, animate_pre_render=True): cfg.duration = 5 cfg.aspect_ratio = (1, 1) local_size = 2 vertices_data = array.array( "f", [ # fmt: off -0.5, -0.5, 0.0, 0.5, -0.5, 0.0, -0.5, 0.5, 0.0, 0.5, 0.5, 0.0, # fmt: on ], ) nb_vertices = 4 input_vertices = ngl.BufferVec3(data=vertices_data, label="vertices") output_vertices = ngl.BufferVec3(data=vertices_data, label="vertices") input_block = ngl.Block(fields=[input_vertices], layout="std140") output_block = ngl.Block(fields=[output_vertices], layout="std140") rotate_animkf = [ ngl.AnimKeyFrameFloat(0, 0), ngl.AnimKeyFrameFloat(cfg.duration, 360) ] rotate = ngl.Rotate(ngl.Identity(), axis=(0, 0, 1), angle=ngl.AnimatedFloat(rotate_animkf)) transform = ngl.UniformMat4(transform=rotate) program = ngl.ComputeProgram(_ANIMATION_COMPUTE, workgroup_size=(local_size, local_size, 1)) program.update_properties(dst=ngl.ResourceProps(writable=True)) compute = ngl.Compute(workgroup_count=(nb_vertices / (local_size**2), 1, 1), program=program) compute.update_resources(transform=transform, src=input_block, dst=output_block) quad_buffer = ngl.BufferVec3(block=output_block, block_field=0) geometry = ngl.Geometry(quad_buffer, topology="triangle_strip") program = ngl.Program(vertex=cfg.get_vert("color"), fragment=cfg.get_frag("color")) render = ngl.Render(geometry, program) render.update_frag_resources(color=ngl.UniformVec3(value=COLORS.sgreen), opacity=ngl.UniformFloat(1)) children = (compute, render) if animate_pre_render else (render, compute) return ngl.Group(children=children)
def compute_particules(cfg): random.seed(0) cfg.duration = 10 local_size = 4 nb_particules = 128 shader_version = '310 es' if cfg.backend == 'gles' else '430' shader_data = dict( version=shader_version, local_size=local_size, nb_particules=nb_particules, ) compute_shader = _PARTICULES_COMPUTE % shader_data vertex_shader = _PARTICULES_VERT % shader_data fragment_shader = _PARTICULES_FRAG % shader_data positions = array.array('f') velocities = array.array('f') for i in range(nb_particules): positions.extend([ random.uniform(-2.0, 1.0), random.uniform(-1.0, 1.0), 0.0, ]) velocities.extend([ random.uniform(1.0, 2.0), random.uniform(0.5, 1.5), ]) ipositions = ngl.Block( fields=[ ngl.BufferVec3(data=positions), ngl.BufferVec2(data=velocities), ], layout='std430', ) opositions = ngl.Block(fields=[ngl.BufferVec3(count=nb_particules)], layout='std430') animkf = [ ngl.AnimKeyFrameFloat(0, 0), ngl.AnimKeyFrameFloat(cfg.duration, 1.0), ] time = ngl.AnimatedFloat(animkf) duration = ngl.UniformFloat(cfg.duration) group_size = nb_particules / local_size program = ngl.ComputeProgram(compute_shader) compute = ngl.Compute(nb_particules, 1, 1, program) compute.update_uniforms(time=time, duration=duration) compute.update_blocks(ipositions_buffer=ipositions, opositions_buffer=opositions) circle = ngl.Circle(radius=0.05) program = ngl.Program(vertex=vertex_shader, fragment=fragment_shader) render = ngl.Render(circle, program, nb_instances=nb_particules) render.update_uniforms(color=ngl.UniformVec4(value=COLORS['sgreen'])) render.update_blocks(positions_buffer=opositions) group = ngl.Group() group.add_children(compute, render) return group
def compute_particles(cfg): cfg.duration = 10 workgroups = (2, 1, 4) local_size = (4, 4, 1) nb_particles = workgroups[0] * workgroups[1] * workgroups[2] * local_size[ 0] * local_size[1] * local_size[2] positions = array.array("f") velocities = array.array("f") for i in range(nb_particles): positions.extend([ cfg.rng.uniform(-2.0, 1.0), cfg.rng.uniform(-1.0, 1.0), 0.0, ]) velocities.extend([ cfg.rng.uniform(1.0, 2.0), cfg.rng.uniform(0.5, 1.5), ]) ipositions = ngl.Block( fields=[ ngl.BufferVec3(data=positions, label="positions"), ngl.BufferVec2(data=velocities, label="velocities"), ], layout="std430", ) opositions = ngl.Block( fields=[ngl.BufferVec3(count=nb_particles, label="positions")], layout="std140") animkf = [ ngl.AnimKeyFrameFloat(0, 0), ngl.AnimKeyFrameFloat(cfg.duration, 1.0), ] time = ngl.AnimatedFloat(animkf) duration = ngl.UniformFloat(cfg.duration) program = ngl.ComputeProgram(_PARTICULES_COMPUTE, workgroup_size=local_size) program.update_properties(odata=ngl.ResourceProps(writable=True)) compute = ngl.Compute(workgroups, program) compute.update_resources(time=time, duration=duration, idata=ipositions, odata=opositions) circle = ngl.Circle(radius=0.05) program = ngl.Program(vertex=_PARTICULES_VERT, fragment=cfg.get_frag("color")) render = ngl.Render(circle, program, nb_instances=nb_particles) render.update_frag_resources(color=ngl.UniformVec3(value=COLORS.sgreen), opacity=ngl.UniformFloat(1)) render.update_vert_resources(data=opositions) group = ngl.Group() group.add_children(compute, render) return group
def compute_particules(cfg): random.seed(0) cfg.duration = 10 local_size = 4 nb_particules = 128 positions = array.array('f') velocities = array.array('f') for i in range(nb_particules): positions.extend([ random.uniform(-2.0, 1.0), random.uniform(-1.0, 1.0), 0.0, ]) velocities.extend([ random.uniform(1.0, 2.0), random.uniform(0.5, 1.5), ]) ipositions = ngl.Block( fields=[ ngl.BufferVec3(data=positions, label='positions'), ngl.BufferVec2(data=velocities, label='velocities'), ], layout='std430', ) opositions = ngl.Block( fields=[ngl.BufferVec3(count=nb_particules, label='positions')], layout='std430') animkf = [ ngl.AnimKeyFrameFloat(0, 0), ngl.AnimKeyFrameFloat(cfg.duration, 1.0), ] time = ngl.AnimatedFloat(animkf) duration = ngl.UniformFloat(cfg.duration) group_size = nb_particules / local_size program = ngl.ComputeProgram(_PARTICULES_COMPUTE % dict(local_size=local_size)) compute = ngl.Compute(nb_particules, 1, 1, program) compute.update_resources(time=time, duration=duration, idata=ipositions, odata=opositions) circle = ngl.Circle(radius=0.05) program = ngl.Program(vertex=_PARTICULES_VERT, fragment=cfg.get_frag('color')) render = ngl.Render(circle, program, nb_instances=nb_particules) render.update_frag_resources(color=ngl.UniformVec4(value=COLORS['sgreen'])) render.update_vert_resources(data=opositions) group = ngl.Group() group.add_children(compute, render) return group
def compute_animation(cfg): cfg.duration = 5 cfg.aspect_ratio = (1, 1) local_size = 2 vertices_data = array.array('f', [ -0.5, -0.5, 0.0, 0.5, -0.5, 0.0, -0.5, 0.5, 0.0, 0.5, 0.5, 0.0, ]) nb_vertices = 4 input_vertices = ngl.BufferVec3(data=vertices_data, label='vertices') output_vertices = ngl.BufferVec3(data=vertices_data, label='vertices') input_block = ngl.Block(fields=[input_vertices], layout='std140') output_block = ngl.Block(fields=[output_vertices], layout='std140') rotate_animkf = [ ngl.AnimKeyFrameFloat(0, 0), ngl.AnimKeyFrameFloat(cfg.duration, 360) ] rotate = ngl.Rotate(ngl.Identity(), axis=(0, 0, 1), anim=ngl.AnimatedFloat(rotate_animkf)) transform = ngl.UniformMat4(transform=rotate) program = ngl.ComputeProgram(_ANIMATION_COMPUTE, workgroup_size=(local_size, local_size, 1)) program.update_properties(dst=ngl.ResourceProps(writable=True)) compute = ngl.Compute(workgroup_count=(nb_vertices / (local_size**2), 1, 1), program=program) compute.update_resources(transform=transform, src=input_block, dst=output_block) quad_buffer = ngl.BufferVec3(block=output_block, block_field=0) geometry = ngl.Geometry(quad_buffer, topology='triangle_strip') program = ngl.Program(vertex=cfg.get_vert('color'), fragment=cfg.get_frag('color')) render = ngl.Render(geometry, program) render.update_frag_resources(color=ngl.UniformVec4(value=COLORS['sgreen'])) return ngl.Group(children=(compute, render))
def get_random_block_info(spec, seed=0, layout=LAYOUTS[0], color_tint=True): # Seed only defines the random for the position of the fields random.seed(seed) fields_pos = random.sample(range(len(spec)), len(spec)) # Always the same colors whatever the user seed random.seed(0) fields_info = [] max_id_len = 0 for i, field_info in enumerate(spec): node = field_info['func'](field_info.get('data')) node.set_label(field_info['name']) field_info['node'] = node field_info['decl'] = _get_field_decl(layout, field_info) field_info['pos'] = fields_pos.index(i) max_id_len = max(len(field_info['decl']), max_id_len) if color_tint: hue = random.uniform(0, 1) field_info['color'] = colorsys.hls_to_rgb(hue, 0.6, 1.0) else: field_info['color'] = (1, 1, 1) fields_info.append(field_info) shuf_fields = [fields_info[pos] for pos in fields_pos] color_fields = [(f['name'], ngl.UniformVec3(f['color'], label=f['name'])) for f in fields_info] block_fields = [(f['name'], f['node']) for f in shuf_fields] if layout == 'uniform': color_fields = dict(color_fields) block_fields = dict(block_fields) else: color_fields = ngl.Block(fields=[f for n, f in color_fields], layout=layout, label='colors_block') block_fields = ngl.Block(fields=[f for n, f in block_fields], layout=layout, label='fields_block') pad = lambda s: (max_id_len - len(s)) * ' ' block_definition = '\n'.join('%s;%s // #%02d' % (f['decl'], pad(f['decl']), i) for i, f in enumerate(shuf_fields)) color_prefix = 'color_' if layout == 'uniform' else '' color_u = 'uniform ' if layout == 'uniform' else '' color_definition = '\n'.join( color_u + 'vec3 %s;' % (color_prefix + f['name']) for f in fields_info) return fields_info, block_fields, color_fields, block_definition, color_definition
def _get_live_shared_uniform_with_block_scene(cfg, color, layout, debug_positions): vertex = ''' void main() { ngl_out_pos = ngl_projection_matrix * ngl_modelview_matrix * ngl_position; } ''' fragment = ''' void main() { ngl_out_color = data.color; } ''' program = ngl.Program(vertex=vertex, fragment=fragment) group = ngl.Group() for i in range(2): block = ngl.Block(fields=[color], layout=layout) quad = ngl.Quad((-1 + i, -1 + i, 0), (1, 0, 0), (0, 1, 0)) render = ngl.Render(quad, program) render.update_frag_resources(data=block) group.add_children(render) if debug_positions: group.add_children(get_debug_points(cfg, _SHARED_UNIFORM_CUEPOINTS)) return group
def histogram(cfg): """Histogram using compute shaders""" m0 = cfg.medias[0] cfg.duration = m0.duration cfg.aspect_ratio = (m0.width, m0.height) g = ngl.Group() m = ngl.Media(cfg.medias[0].filename) t = ngl.Texture2D(data_src=m) h = ngl.Block(label="histogram_block", layout="std430") h.add_fields( ngl.BufferUInt(256, label="r"), ngl.BufferUInt(256, label="g"), ngl.BufferUInt(256, label="b"), ngl.UniformUInt(label="maximum"), ) r = ngl.RenderTexture(t) proxy_size = 128 proxy = ngl.Texture2D(width=proxy_size, height=proxy_size) rtt = ngl.RenderToTexture(r) rtt.add_color_textures(proxy) g.add_children(rtt) compute_program = ngl.ComputeProgram(cfg.get_comp("histogram-clear"), workgroup_size=(1, 1, 1)) compute_program.update_properties(hist=ngl.ResourceProps(writable=True)) compute = ngl.Compute(workgroup_count=(256, 1, 1), program=compute_program, label="histogram-clear") compute.update_resources(hist=h) g.add_children(compute) local_size = 8 group_size = proxy_size / local_size compute_program = ngl.ComputeProgram(cfg.get_comp("histogram-exec"), workgroup_size=(local_size, local_size, 1)) compute = ngl.Compute(workgroup_count=(group_size, group_size, 1), program=compute_program, label="histogram-exec") compute.update_resources(hist=h, source=proxy) compute_program.update_properties(hist=ngl.ResourceProps(writable=True)) compute_program.update_properties(source=ngl.ResourceProps(as_image=True)) g.add_children(compute) q = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0)) p = ngl.Program(vertex=cfg.get_vert("histogram-display"), fragment=cfg.get_frag("histogram-display")) p.update_vert_out_vars(var_uvcoord=ngl.IOVec2(), var_tex0_coord=ngl.IOVec2()) render = ngl.Render(q, p) render.update_frag_resources(tex0=t, hist=h) g.add_children(render) return g
def compute_animation(cfg): cfg.duration = 5 cfg.aspect_ratio = (1, 1) local_size = 2 shader_version = '310 es' if cfg.backend == 'gles' else '430' shader_data = dict( version=shader_version, local_size=local_size, ) compute_shader = _ANIMATION_COMPUTE % shader_data vertex_shader = _ANIMATION_VERT % shader_data fragment_shader = _ANIMATION_FRAG % shader_data vertices_data = array.array('f', [ -0.5, -0.5, 0.0, 0.5, -0.5, 0.0, 0.5, 0.5, 0.0, -0.5, 0.5, 0.0, ]) nb_vertices = 4 input_vertices = ngl.BufferVec3(data=vertices_data) output_vertices = ngl.BufferVec3(data=vertices_data) input_block = ngl.Block(fields=[input_vertices], layout='std140') output_block = ngl.Block(fields=[output_vertices], layout='std430') rotate_animkf = [ngl.AnimKeyFrameFloat(0, 0), ngl.AnimKeyFrameFloat(cfg.duration, 360)] rotate = ngl.Rotate(ngl.Identity(), axis=(0, 0, 1), anim=ngl.AnimatedFloat(rotate_animkf)) transform = ngl.UniformMat4(transform=rotate) program = ngl.ComputeProgram(compute_shader) compute = ngl.Compute(nb_vertices / (local_size ** 2), 1, 1, program) compute.update_uniforms(transform=transform) compute.update_blocks(input_block=input_block, output_block=output_block) quad_buffer = ngl.BufferVec3(block=output_block, block_field=0) geometry = ngl.Geometry(quad_buffer, topology='triangle_fan') program = ngl.Program(vertex=vertex_shader, fragment=fragment_shader) render = ngl.Render(geometry, program) render.update_uniforms(color=ngl.UniformVec4(value=COLORS['sgreen'])) return ngl.Group(children=(compute, render))
def _data_vertex_and_fragment_blocks(cfg, layout): """ This test ensures that the block bindings are properly set by pgcraft when UBOs or SSBOs are bound to different stages. """ cfg.aspect_ratio = (1, 1) src = ngl.Block( fields=[ ngl.UniformVec3(value=COLORS.red, label="color"), ngl.UniformFloat(value=0.5, label="opacity"), ], layout="std140", ) dst = ngl.Block( fields=[ ngl.UniformVec3(value=COLORS.white, label="color"), ], layout=layout, ) vert = textwrap.dedent("""\ void main() { ngl_out_pos = ngl_projection_matrix * ngl_modelview_matrix * vec4(ngl_position, 1.0); var_src = vec4(src.color, 1.0) * src.opacity; } """) frag = textwrap.dedent("""\ void main() { vec3 color = var_src.rgb + (1.0 - var_src.a) * dst.color; ngl_out_color = vec4(color, 1.0); } """) program = ngl.Program(vertex=vert, fragment=frag) program.update_vert_out_vars(var_src=ngl.IOVec4(), ) geometry = ngl.Quad(corner=(-1, -1, 0), width=(2, 0, 0), height=(0, 2, 0)) render = ngl.Render(geometry, program) render.update_vert_resources(src=src) render.update_frag_resources(dst=dst) return render
def histogram(cfg): '''Histogram using compute shaders''' m0 = cfg.medias[0] cfg.duration = m0.duration cfg.aspect_ratio = (m0.width, m0.height) g = ngl.Group() m = ngl.Media(cfg.medias[0].filename) t = ngl.Texture2D(data_src=m) h = ngl.Block(label='histogram_block', layout='std430') h.add_fields( ngl.BufferUInt(256, label='r'), ngl.BufferUInt(256, label='g'), ngl.BufferUInt(256, label='b'), ngl.UniformInt(label='maximum'), ) q = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0)) r = ngl.Render(q) r.update_textures(tex0=t) proxy_size = 128 proxy = ngl.Texture2D(width=proxy_size, height=proxy_size) rtt = ngl.RenderToTexture(r) rtt.add_color_textures(proxy) g.add_children(rtt) shader_version = '310 es' if cfg.backend == 'gles' else '430' shader_header = '#version %s\n' % shader_version if cfg.backend == 'gles' and cfg.system == 'Android': shader_header += '#extension GL_ANDROID_extension_pack_es31a: require\n' compute_program = ngl.ComputeProgram(shader_header + cfg.get_comp('histogram-clear')) compute = ngl.Compute(256, 1, 1, compute_program, label='histogram-clear') compute.update_blocks(histogram_buffer=h) g.add_children(compute) local_size = 8 group_size = proxy_size / local_size compute_shader = cfg.get_comp('histogram-exec') % {'local_size': local_size} compute_program = ngl.ComputeProgram(shader_header + compute_shader) compute = ngl.Compute(group_size, group_size, 1, compute_program, label='histogram-exec') compute.update_blocks(histogram_buffer=h) compute.update_textures(source=proxy) g.add_children(compute) q = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0)) p = ngl.Program(vertex=shader_header + cfg.get_vert('histogram-display'), fragment=shader_header + cfg.get_frag('histogram-display')) render = ngl.Render(q, p) render.update_textures(tex0=t) render.update_blocks(histogram_buffer=h) g.add_children(render) return g
def _get_data_streamed_buffer_vec4_scene(cfg, scale, show_dbg_points): duration = _N cfg.duration = duration * scale cfg.aspect_ratio = (1, 1) size, data_size, = _N, _N * _N time_anim = None if scale != 1: kfs = [ ngl.AnimKeyFrameFloat(0, 0), ngl.AnimKeyFrameFloat(cfg.duration, duration), ] time_anim = ngl.AnimatedTime(kfs) pts_data = array.array('q') assert pts_data.itemsize == 8 for i in range(duration): offset = 10000 if i == 0 else 0 pts_data.extend([i * 1000000 + offset]) vec4_data = array.array('f') for i in range(duration): for j in range(data_size): v = i / float(duration) + j / float(data_size * duration) vec4_data.extend([v, v, v, v]) pts_buffer = ngl.BufferInt64(data=pts_data) vec4_buffer = ngl.BufferVec4(data=vec4_data) streamed_buffer = ngl.StreamedBufferVec4(data_size, pts_buffer, vec4_buffer, time_anim=time_anim, label='data') streamed_block = ngl.Block(layout='std140', label='streamed_block', fields=(streamed_buffer, )) shader_params = dict(data_size=data_size, size=size) quad = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0)) program = ngl.Program( vertex=_RENDER_STREAMEDBUFFER_VERT, fragment=_RENDER_STREAMEDBUFFER_FRAG % shader_params, ) program.update_vert_out_vars(var_uvcoord=ngl.IOVec2()) render = ngl.Render(quad, program) render.update_frag_resources(streamed=streamed_block) group = ngl.Group(children=(render, )) if show_dbg_points: cuepoints = _get_data_streamed_buffer_cuepoints() group.add_children(get_debug_points(cfg, cuepoints)) return group
def compute_image_load_store(cfg, show_dbg_points=False): size = _N texture_data = ngl.BufferFloat( data=array.array("f", [x / (size**2) for x in range(size**2)])) texture_r = ngl.Texture2D(format="r32_sfloat", width=size, height=size, data_src=texture_data) texture_g = ngl.Texture2D(format="r32_sfloat", width=size, height=size, data_src=texture_data) texture_b = ngl.Texture2D(format="r32_sfloat", width=size, height=size, data_src=texture_data) scale = ngl.Block( fields=[ngl.UniformVec2(value=(-1.0, 1.0), label="factors")], layout="std140", ) texture_rgba = ngl.Texture2D(width=size, height=size) program = ngl.ComputeProgram(_IMAGE_LOAD_STORE_COMPUTE, workgroup_size=(size, size, 1)) program.update_properties( texture_r=ngl.ResourceProps(as_image=True), texture_g=ngl.ResourceProps(as_image=True), texture_b=ngl.ResourceProps(as_image=True), texture_rgba=ngl.ResourceProps(as_image=True, writable=True), ) compute = ngl.Compute(workgroup_count=(1, 1, 1), program=program) compute.update_resources(texture_r=texture_r, texture_g=texture_g, texture_b=texture_b, scale=scale, texture_rgba=texture_rgba) render = ngl.RenderTexture(texture_rgba) group = ngl.Group(children=(compute, render)) if show_dbg_points: cuepoints = _get_compute_histogram_cuepoints() group.add_children(get_debug_points(cfg, cuepoints)) return group
def particles(cfg, particles=32): """Particules demo using compute shaders and instancing""" compute_shader = cfg.get_comp("particles") vertex_shader = cfg.get_vert("particles") fragment_shader = cfg.get_frag("color") cfg.duration = 6 x = 64 p = x * particles positions = array.array("f") velocities = array.array("f") for i in range(p): positions.extend([ cfg.rng.uniform(-1.0, 1.0), cfg.rng.uniform(0.0, 1.0), 0.0, ]) velocities.extend([ cfg.rng.uniform(-0.01, 0.01), cfg.rng.uniform(-0.05, 0.05), ]) ipositions = ngl.Block( fields=[ngl.BufferVec3(data=positions, label="data")], layout="std430") ivelocities = ngl.Block( fields=[ngl.BufferVec2(data=velocities, label="data")], layout="std430") opositions = ngl.Block(fields=[ngl.BufferVec3(count=p, label="data")], layout="std430") animkf = [ ngl.AnimKeyFrameFloat(0, 0), ngl.AnimKeyFrameFloat(cfg.duration, 1) ] utime = ngl.AnimatedFloat(animkf) uduration = ngl.UniformFloat(cfg.duration) cp = ngl.ComputeProgram(compute_shader, workgroup_size=(1, 1, 1)) cp.update_properties(opositions=ngl.ResourceProps(writable=True)) c = ngl.Compute(workgroup_count=(x, particles, 1), program=cp) c.update_resources( time=utime, duration=uduration, ipositions=ipositions, ivelocities=ivelocities, opositions=opositions, ) quad_width = 0.01 quad = ngl.Quad(corner=(-quad_width / 2, -quad_width / 2, 0), width=(quad_width, 0, 0), height=(0, quad_width, 0)) p = ngl.Program( vertex=vertex_shader, fragment=fragment_shader, ) p.update_vert_out_vars(var_uvcoord=ngl.IOVec2(), var_tex0_coord=ngl.IOVec2()) r = ngl.Render(quad, p, nb_instances=particles, blending="src_over") r.update_frag_resources(color=ngl.UniformVec3(value=(0, 0.6, 0.8)), opacity=ngl.UniformFloat(0.9)) r.update_vert_resources(positions=opositions) g = ngl.Group() g.add_children(c, r) return ngl.Camera(g)
def compute_histogram(cfg, show_dbg_points=False): cfg.duration = 10 cfg.aspect_ratio = (1, 1) hsize, size, local_size = _N * _N, _N, _N // 2 data = array.array("f") for i in range(size * size): data.extend(( cfg.rng.uniform(0.0, 0.5), cfg.rng.uniform(0.25, 0.75), cfg.rng.uniform(0.5, 1.0), 1.0, )) texture_buffer = ngl.BufferVec4(data=data) texture = ngl.Texture2D(width=size, height=size, data_src=texture_buffer) texture.set_format("r32g32b32a32_sfloat") histogram_block = ngl.Block(layout="std140", label="histogram") histogram_block.add_fields( ngl.BufferUInt(hsize, label="r"), ngl.BufferUInt(hsize, label="g"), ngl.BufferUInt(hsize, label="b"), ngl.UniformUIVec3(label="max"), ) shader_params = dict(hsize=hsize, size=size, local_size=local_size) group_size = hsize // local_size clear_histogram_shader = _COMPUTE_HISTOGRAM_CLEAR % shader_params clear_histogram_program = ngl.ComputeProgram(clear_histogram_shader, workgroup_size=(local_size, 1, 1)) clear_histogram_program.update_properties(hist=ngl.ResourceProps( writable=True)) clear_histogram = ngl.Compute( workgroup_count=(group_size, 1, 1), program=clear_histogram_program, label="clear_histogram", ) clear_histogram.update_resources(hist=histogram_block) group_size = size // local_size exec_histogram_shader = _COMPUTE_HISTOGRAM_EXEC % shader_params exec_histogram_program = ngl.ComputeProgram(exec_histogram_shader, workgroup_size=(local_size, local_size, 1)) exec_histogram_program.update_properties(hist=ngl.ResourceProps( writable=True)) exec_histogram = ngl.Compute(workgroup_count=(group_size, group_size, 1), program=exec_histogram_program, label="compute_histogram") exec_histogram.update_resources(hist=histogram_block, source=texture) exec_histogram_program.update_properties(source=ngl.ResourceProps( as_image=True)) quad = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0)) program = ngl.Program( vertex=_RENDER_HISTOGRAM_VERT, fragment=_RENDER_HISTOGRAM_FRAG % shader_params, ) program.update_vert_out_vars(var_uvcoord=ngl.IOVec2()) render = ngl.Render(quad, program, label="render_histogram") render.update_frag_resources(hist=histogram_block) group = ngl.Group(children=(clear_histogram, exec_histogram, render)) if show_dbg_points: cuepoints = _get_compute_histogram_cuepoints() group.add_children(get_debug_points(cfg, cuepoints)) return group
def get_field_scene(cfg, spec, category, field_type, seed, debug_positions, layout, color_tint): """ Build a scene testing that a given data has been properly uploaded to the GPU memory. - `spec` contains all the fields that should also be declared (either in a block or as uniforms). All the fields are shuffled such that the field we are testing is always in a random position. This makes sure that we get the data alignment right. - `category` and `field_type` are filters in the spec to select the field(s) from which we want to read the data - `seed` is used to control the fields shuffling - `debug_positions` controls whether there are debug circles in the scene in order to make sure we are reading back the data colors at the appropriate position - `layout` controls the block layout or whether we are working with uniforms - `color_tint` is a debug helper to give a different color for each field (because if they have the same data, it is hard to indiscriminate them). """ cfg.aspect_ratio = (1, 1) # Seed only defines the random for the position of the fields fields_pos = random.Random(seed).sample(range(len(spec)), len(spec)) # Always the same colors whatever the user seed clr_rng = random.Random(0) fields_info = [] for i, field_info in enumerate(spec): create_func = field_info.get("func") if create_func is None: create_func = _FUNCS["{category}_{type}".format(**field_info)] node = create_func(field_info.get("data")) node.set_label(field_info["name"]) field_info["node"] = node if color_tint: hue = clr_rng.uniform(0, 1) field_info["color"] = colorsys.hls_to_rgb(hue, 0.6, 1.0) else: field_info["color"] = (1, 1, 1) fields_info.append(field_info) shuf_fields = [fields_info[pos] for pos in fields_pos] color_fields = [(f["name"], ngl.UniformVec3(f["color"], label=f["name"])) for f in fields_info] block_fields = [(f["name"], f["node"]) for f in shuf_fields] if layout == "uniform": color_fields = dict(color_fields) block_fields = dict(block_fields) else: color_fields = ngl.Block(fields=[f for n, f in color_fields], layout=layout, label="colors_block") block_fields = ngl.Block(fields=[f for n, f in block_fields], layout=layout, label="fields_block") fields = match_fields(fields_info, category, field_type) func_calls = [] func_definitions = [] for i, field in enumerate(fields): field_len = field.get("len") func_calls.append("get_color_{}(w, h, 0.0, {:f} * h)".format( field["name"], i)) func_definitions.append( _get_display_glsl_func(layout, field["name"], field["type"], field_len=field_len)) frag_data = dict( func_definitions="\n".join(func_definitions), func_calls=" + ".join(func_calls), ) fragment = _FIELDS_FRAG % frag_data vertex = _FIELDS_VERT program = ngl.Program(vertex=vertex, fragment=fragment) program.update_vert_out_vars(var_uvcoord=ngl.IOVec2()) quad = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0)) render = ngl.Render(quad, program) if isinstance(color_fields, dict): assert isinstance(block_fields, dict) field_names = {f["name"] for f in fields} d = {} d.update(("color_" + n, u) for (n, u) in color_fields.items() if n in field_names) d.update(("field_" + n, u) for (n, u) in block_fields.items() if n in field_names) render.update_frag_resources(**d) else: render.update_frag_resources(fields=block_fields, colors=color_fields) render.update_frag_resources(nb_fields=ngl.UniformInt(len(fields))) if debug_positions: debug_points = get_data_debug_positions(fields) dbg_circles = get_debug_points(cfg, debug_points, text_size=(0.2, 0.1)) g = ngl.Group(children=(render, dbg_circles)) return g return render
def particles(cfg, particles=32): '''Particules demo using compute shaders and instancing''' random.seed(0) compute_shader = cfg.get_comp('particles') vertex_shader = cfg.get_vert('particles') fragment_shader = cfg.get_frag('color') cfg.duration = 6 x = 64 p = x * particles positions = array.array('f') velocities = array.array('f') for i in range(p): positions.extend([ random.uniform(-1.0, 1.0), random.uniform(0.0, 1.0), 0.0, ]) velocities.extend([ random.uniform(-0.01, 0.01), random.uniform(-0.05, 0.05), ]) ipositions = ngl.Block(fields=[ngl.BufferVec3(data=positions, label='data')], layout='std430') ivelocities = ngl.Block(fields=[ngl.BufferVec2(data=velocities, label='data')], layout='std430') opositions = ngl.Block(fields=[ngl.BufferVec3(count=p, label='data')], layout='std430') animkf = [ngl.AnimKeyFrameFloat(0, 0), ngl.AnimKeyFrameFloat(cfg.duration, 1)] utime = ngl.AnimatedFloat(animkf) uduration = ngl.UniformFloat(cfg.duration) cp = ngl.ComputeProgram(compute_shader, workgroup_size=(1, 1, 1)) cp.update_properties(opositions=ngl.ResourceProps(writable=True)) c = ngl.Compute(workgroup_count=(x, particles, 1), program=cp) c.update_resources( time=utime, duration=uduration, ipositions=ipositions, ivelocities=ivelocities, opositions=opositions, ) quad_width = 0.01 quad = ngl.Quad( corner=(-quad_width/2, -quad_width/2, 0), width=(quad_width, 0, 0), height=(0, quad_width, 0) ) p = ngl.Program( vertex=vertex_shader, fragment=fragment_shader, ) p.update_vert_out_vars(var_uvcoord=ngl.IOVec2(), var_tex0_coord=ngl.IOVec2()) r = ngl.Render(quad, p, nb_instances=particles) r.update_frag_resources(color=ngl.UniformVec4(value=(0, .6, .8, .9))) r.update_vert_resources(positions=opositions) r = ngl.GraphicConfig(r, blend=True, blend_src_factor='src_alpha', blend_dst_factor='one_minus_src_alpha', blend_src_factor_a='zero', blend_dst_factor_a='one') g = ngl.Group() g.add_children(c, r) return ngl.Camera(g)
def histogram(cfg): '''Histogram using compute shaders''' m0 = cfg.medias[0] cfg.duration = m0.duration cfg.aspect_ratio = (m0.width, m0.height) g = ngl.Group() m = ngl.Media(cfg.medias[0].filename) t = ngl.Texture2D(data_src=m) h = ngl.Block(label='histogram_block', layout='std430') h.add_fields( ngl.BufferUInt(256, label='r'), ngl.BufferUInt(256, label='g'), ngl.BufferUInt(256, label='b'), ngl.UniformUInt(label='maximum'), ) q = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0)) p = ngl.Program(vertex=cfg.get_vert('texture'), fragment=cfg.get_frag('texture')) p.update_vert_out_vars(var_uvcoord=ngl.IOVec2(), var_tex0_coord=ngl.IOVec2()) r = ngl.Render(q, p) r.update_frag_resources(tex0=t) proxy_size = 128 proxy = ngl.Texture2D(width=proxy_size, height=proxy_size) rtt = ngl.RenderToTexture(r) rtt.add_color_textures(proxy) g.add_children(rtt) compute_program = ngl.ComputeProgram(cfg.get_comp('histogram-clear')) compute = ngl.Compute(256, 1, 1, compute_program, label='histogram-clear') compute.update_resources(hist=h) g.add_children(compute) local_size = 8 group_size = proxy_size / local_size compute_shader = cfg.get_comp('histogram-exec') % { 'local_size': local_size } compute_program = ngl.ComputeProgram(compute_shader) compute = ngl.Compute(group_size, group_size, 1, compute_program, label='histogram-exec') compute.update_resources(hist=h, source=proxy) compute_program.update_properties(source=ngl.ResourceProps(as_image=True)) g.add_children(compute) q = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0)) p = ngl.Program(vertex=cfg.get_vert('histogram-display'), fragment=cfg.get_frag('histogram-display')) p.update_vert_out_vars(var_uvcoord=ngl.IOVec2(), var_tex0_coord=ngl.IOVec2()) render = ngl.Render(q, p) render.update_frag_resources(tex0=t, hist=h) g.add_children(render) return g
def compute_histogram(cfg, show_dbg_points=False): random.seed(0) cfg.duration = 10 cfg.aspect_ratio = (1, 1) hsize, size, local_size = _N * _N, _N, _N // 2 data = array.array('f') for i in range(size * size): data.extend(( random.uniform(0.0, 0.5), random.uniform(0.25, 0.75), random.uniform(0.5, 1.0), 1.0, )) texture_buffer = ngl.BufferVec4(data=data) texture = ngl.Texture2D(width=size, height=size, data_src=texture_buffer) histogram_block = ngl.Block(layout='std430', label='histogram') histogram_block.add_fields( ngl.BufferUInt(hsize), ngl.BufferUInt(hsize), ngl.BufferUInt(hsize), ngl.UniformUIVec3(), ) shader_version = '310 es' if cfg.backend == 'gles' else '430' shader_header = '#version %s\n' % shader_version if cfg.backend == 'gles' and cfg.system == 'Android': shader_header += '#extension GL_ANDROID_extension_pack_es31a: require\n' shader_params = dict(hsize=hsize, size=size, local_size=local_size) group_size = hsize // local_size clear_histogram_shader = _COMPUTE_HISTOGRAM_CLEAR % shader_params clear_histogram_program = ngl.ComputeProgram(shader_header + clear_histogram_shader) clear_histogram = ngl.Compute( group_size, 1, 1, clear_histogram_program, label='clear_histogram', ) clear_histogram.update_blocks(histogram=histogram_block) group_size = size // local_size exec_histogram_shader = _COMPUTE_HISTOGRAM_EXEC % shader_params exec_histogram_program = ngl.ComputeProgram(shader_header + exec_histogram_shader) exec_histogram = ngl.Compute( group_size, group_size, 1, exec_histogram_program, label='compute_histogram' ) exec_histogram.update_blocks(histogram=histogram_block) exec_histogram.update_textures(source=texture) quad = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0)) program = ngl.Program( vertex=shader_header + _RENDER_HISTOGRAM_VERT, fragment=shader_header + _RENDER_HISTOGRAM_FRAG % shader_params, ) render = ngl.Render(quad, program, label='render_histogram') render.update_blocks(histogram=histogram_block) group = ngl.Group(children=(clear_histogram, exec_histogram, render,)) if show_dbg_points: cuepoints = _get_compute_histogram_cuepoints() group.add_children(get_debug_points(cfg, cuepoints)) return group
def _get_random_compute(cfg, rng, t0, t1): count = 10 fragment_shader = cfg.get_frag("texture") vertex_shader = textwrap.dedent( """ void main() { vec4 position = vec4(ngl_position, 1.0) + vec4(pos.data[ngl_instance_index], 0.0, 0.0); ngl_out_pos = ngl_projection_matrix * ngl_modelview_matrix * position; var_tex0_coord = (tex0_coord_matrix * vec4(ngl_uvcoord, 0.0, 1.0)).xy; } """ ) funcs = ("snake", "circle", "spread") compute_shader = textwrap.dedent( """ #define TAU (2.0 * 3.14159265358979323846) vec2 snake(float i) { return vec2(i * 2.0 - 1.0, sin((time + i) * TAU)); } vec2 circle(float i) { float angle = (time + i) * TAU; return vec2(sin(angle), cos(angle)); } vec2 spread(float i) { float angle = i * TAU; return vec2(sin(angle), cos(angle)) * (time + i); } void main() { uint wg = gl_WorkGroupID.x; float i = float(wg) / float(gl_NumWorkGroups.x - 1U); pos.data[wg] = FUNC(i); } """.replace( "FUNC", rng.choice(funcs) ) ) pos = ngl.Block(fields=[ngl.BufferVec2(count=count, label="data")]) time_animkf = [ngl.AnimKeyFrameFloat(t0, 0), ngl.AnimKeyFrameFloat(t1, 1)] compute_prog = ngl.ComputeProgram(compute_shader, workgroup_size=(1, 1, 1)) compute_prog.update_properties(pos=ngl.ResourceProps(writable=True)) compute = ngl.Compute(workgroup_count=(count, 1, 1), program=compute_prog) compute.update_resources(time=ngl.AnimatedFloat(time_animkf), pos=pos) geometry = _get_random_geometry(rng) program = ngl.Program(vertex=vertex_shader, fragment=cfg.get_frag("texture")) program.update_vert_out_vars(var_tex0_coord=ngl.IOVec2()) render = ngl.Render(geometry, program, nb_instances=count, blending="src_over") render.update_frag_resources(tex0=_get_random_texture(cfg, rng)) render.update_vert_resources(pos=pos) render = ngl.Scale(render, factors=(0.5, 0.5, 0)) return ngl.Group(children=(compute, render))
def particules(cfg, particules=32): '''Particules demo using compute shaders and instancing''' random.seed(0) shader_version = '310 es' if cfg.backend == 'gles' else '430' shader_header = '#version %s\n' % shader_version compute_shader = shader_header + cfg.get_comp('particules') vertex_shader = shader_header + cfg.get_vert('particules') fragment_shader = shader_header + cfg.get_frag('particules') cfg.duration = 6 x = 64 p = x * particules positions = array.array('f') velocities = array.array('f') for i in range(p): positions.extend([ random.uniform(-1.0, 1.0), random.uniform(0.0, 1.0), 0.0, ]) velocities.extend([ random.uniform(-0.01, 0.01), random.uniform(-0.05, 0.05), ]) ipositions = ngl.Block(fields=[ngl.BufferVec3(data=positions)], layout='std430') ivelocities = ngl.Block(fields=[ngl.BufferVec2(data=velocities)], layout='std430') opositions = ngl.Block(fields=[ngl.BufferVec3(count=p)], layout='std430') animkf = [ngl.AnimKeyFrameFloat(0, 0), ngl.AnimKeyFrameFloat(cfg.duration, 1)] utime = ngl.AnimatedFloat(animkf) uduration = ngl.UniformFloat(cfg.duration) cp = ngl.ComputeProgram(compute_shader) c = ngl.Compute(x, particules, 1, cp) c.update_uniforms( time=utime, duration=uduration, ) c.update_blocks( ipositions_buffer=ipositions, ivelocities_buffer=ivelocities, opositions_buffer=opositions, ) quad_width = 0.01 quad = ngl.Quad( corner=(-quad_width/2, -quad_width/2, 0), width=(quad_width, 0, 0), height=(0, quad_width, 0) ) p = ngl.Program( vertex=vertex_shader, fragment=fragment_shader, ) r = ngl.Render(quad, p, nb_instances=particules) r.update_uniforms(color=ngl.UniformVec4(value=(0, .6, .8, .9))) r.update_blocks(positions_buffer=opositions) r = ngl.GraphicConfig(r, blend=True, blend_src_factor='src_alpha', blend_dst_factor='one_minus_src_alpha', blend_src_factor_a='zero', blend_dst_factor_a='one') g = ngl.Group() g.add_children(c, r) return ngl.Camera(g)