def cropboard(cfg, dim=15):
'''Divided media using instancing draw and UV coords offsetting from a buffer'''
m0 = cfg.medias[0]
random.seed(0)
cfg.duration = 10
cfg.aspect_ratio = (m0.width, m0.height)
kw = kh = 1. / dim
qw = qh = 2. / dim
p = ngl.Program(vertex=cfg.get_vert('cropboard'),
fragment=cfg.get_frag('texture'))
p.update_vert_out_vars(var_tex0_coord=ngl.IOVec2(),
var_uvcoord=ngl.IOVec2())
m = ngl.Media(m0.filename)
t = ngl.Texture2D(data_src=m)
uv_offset_buffer = array.array('f')
translate_a_buffer = array.array('f')
translate_b_buffer = array.array('f')
q = ngl.Quad(corner=(0, 0, 0),
width=(qw, 0, 0),
height=(0, qh, 0),
uv_corner=(0, 0),
uv_width=(kw, 0),
uv_height=(0, kh))
for y in range(dim):
for x in range(dim):
uv_offset = [x * kw, (y + 1.) * kh - 1.]
src = [random.uniform(-2, 2), random.uniform(-2, 2)]
dst = [x * qw - 1., 1. - (y + 1.) * qh]
uv_offset_buffer.extend(uv_offset)
translate_a_buffer.extend(src)
translate_b_buffer.extend(dst)
utime_animkf = [
ngl.AnimKeyFrameFloat(0, 0),
ngl.AnimKeyFrameFloat(cfg.duration * 2 / 3., 1, 'exp_out')
]
utime = ngl.AnimatedFloat(utime_animkf)
render = ngl.Render(q, p, nb_instances=dim**2)
render.update_frag_resources(tex0=t)
render.update_vert_resources(time=utime)
render.update_instance_attributes(
uv_offset=ngl.BufferVec2(data=uv_offset_buffer),
translate_a=ngl.BufferVec2(data=translate_a_buffer),
translate_b=ngl.BufferVec2(data=translate_b_buffer),
)
return render
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 _get_cube():
# front
p0 = (-1, -1, 1)
p1 = ( 1, -1, 1)
p2 = ( 1, 1, 1)
p3 = (-1, 1, 1)
# back
p4 = (-1, -1, -1)
p5 = ( 1, -1, -1)
p6 = ( 1, 1, -1)
p7 = (-1, 1, -1)
cube_vertices_data = array.array(
'f',
p0 + p1 + p2 + p2 + p3 + p0 + # front
p1 + p5 + p6 + p6 + p2 + p1 + # right
p7 + p6 + p5 + p5 + p4 + p7 + # back
p4 + p0 + p3 + p3 + p7 + p4 + # left
p4 + p5 + p1 + p1 + p0 + p4 + # bottom
p3 + p2 + p6 + p6 + p7 + p3 # top
)
uvs = (0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1)
cube_uvs_data = array.array('f', uvs * 6)
up = (0, 1, 0)
down = (0, -1, 0)
front = (0, 0, 1)
back = (0, 0, -1)
left = (-1, 0, 0)
right = (1, 0, 0)
cube_normals_data = array.array(
'f',
front * 6 +
right * 6 +
back * 6 +
left * 6 +
down * 6 +
up * 6
)
return ngl.Geometry(
vertices=ngl.BufferVec3(data=cube_vertices_data),
uvcoords=ngl.BufferVec2(data=cube_uvs_data),
normals=ngl.BufferVec3(data=cube_normals_data),
)
def obj(cfg, n=0.5, model=None):
"""Load and display a cube object (generated with Blender)"""
if model is None:
model = op.join(op.dirname(__file__), "data", "model.obj")
with open(model) as fp:
vertices_data, uvs_data, normals_data = _load_model(fp)
vertices = ngl.BufferVec3(data=vertices_data)
texcoords = ngl.BufferVec2(data=uvs_data)
normals = ngl.BufferVec3(data=normals_data)
q = ngl.Geometry(vertices, texcoords, normals)
m = ngl.Media(cfg.medias[0].filename)
t = ngl.Texture2D(data_src=m)
p = ngl.Program(vertex=cfg.get_vert("tex-tint-normals"),
fragment=cfg.get_frag("tex-tint-normals"))
p.update_vert_out_vars(var_normal=ngl.IOVec3(),
var_uvcoord=ngl.IOVec2(),
var_tex0_coord=ngl.IOVec2())
render = ngl.Render(q, p)
render.update_frag_resources(tex0=t)
render = ngl.GraphicConfig(render, depth_test=True)
animkf = [
ngl.AnimKeyFrameFloat(0, 0),
ngl.AnimKeyFrameFloat(cfg.duration, 360 * 2)
]
rot = ngl.Rotate(render,
label="roty",
axis=(0, 1, 0),
angle=ngl.AnimatedFloat(animkf))
camera = ngl.Camera(rot)
camera.set_eye(2.0, 2.0, 2.0)
camera.set_center(0.0, 0.0, 0.0)
camera.set_up(0.0, 1.0, 0.0)
camera.set_perspective(45.0, cfg.aspect_ratio_float)
camera.set_clipping(1.0, 10.0)
return camera
def shape_geometry_with_renderother(cfg):
cfg.aspect_ratio = (1, 1)
vertices_data = array.array("f")
uvcoords_data = array.array("f")
boundaries = (
(-1, 0, 0, 1),
(0, 1, 0, 1),
(-1, 0, -1, 0),
(0, 1, -1, 0),
)
for xmin, xmax, ymin, ymax in boundaries:
x0, y0 = cfg.rng.uniform(xmin, xmax), cfg.rng.uniform(ymin, ymax)
x1, y1 = cfg.rng.uniform(xmin, xmax), cfg.rng.uniform(ymin, ymax)
vertices_data.extend((0, 0, 0, x0, y0, 0, x1, y1, 0))
uvcoords_data.extend((0, 0, x0, y0, x1, y1))
geometry = ngl.Geometry(
vertices=ngl.BufferVec3(data=vertices_data),
uvcoords=ngl.BufferVec2(data=uvcoords_data),
topology="triangle_list",
)
return ngl.RenderColor(geometry=geometry)
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 cropboard(cfg, dim_clr=3, dim_cut=9):
cfg.duration = 5.0 + 1.0
nb_kf = 2
buffers = [
get_random_color_buffer(cfg.rng, dim_clr) for _ in range(nb_kf)
]
random_animkf = []
time_scale = cfg.duration / float(nb_kf)
for i, buf in enumerate(buffers + [buffers[0]]):
random_animkf.append(ngl.AnimKeyFrameBuffer(i * time_scale, buf))
random_buffer = ngl.AnimatedBufferVec4(keyframes=random_animkf)
random_tex = ngl.Texture2D(data_src=random_buffer,
width=dim_clr,
height=dim_clr)
kw = kh = 1.0 / dim_cut
qw = qh = 2.0 / dim_cut
p = ngl.Program(vertex=cfg.get_vert("cropboard"),
fragment=cfg.get_frag("texture"))
p.update_vert_out_vars(var_tex0_coord=ngl.IOVec2())
uv_offset_buffer = array.array("f")
translate_a_buffer = array.array("f")
translate_b_buffer = array.array("f")
if set_indices:
indices = array.array("H", [0, 2, 1, 1, 3, 0])
indices_buffer = ngl.BufferUShort(data=indices)
vertices = array.array(
"f",
[
# fmt: off
0,
0,
0,
qw,
qh,
0,
qw,
0,
0,
0,
qh,
0,
# fmt: on
],
)
uvcoords = array.array(
"f",
[
# fmt: off
0,
1.0,
kw,
1.0 - kh,
kw,
1.0,
0,
1.0 - kh,
# fmt: on
],
)
vertices_buffer = ngl.BufferVec3(data=vertices)
uvcoords_buffer = ngl.BufferVec2(data=uvcoords)
q = ngl.Geometry(vertices=vertices_buffer,
uvcoords=uvcoords_buffer,
indices=indices_buffer)
else:
q = ngl.Quad(
corner=(0, 0, 0),
width=(qw, 0, 0),
height=(0, qh, 0),
uv_corner=(0, 0),
uv_width=(kw, 0),
uv_height=(0, kh),
)
for y in range(dim_cut):
for x in range(dim_cut):
uv_offset = [x * kw, (y + 1.0) * kh - 1.0]
src = [cfg.rng.uniform(-2, 2), cfg.rng.uniform(-2, 2)]
dst = [x * qw - 1.0, 1.0 - (y + 1.0) * qh]
uv_offset_buffer.extend(uv_offset)
translate_a_buffer.extend(src)
translate_b_buffer.extend(dst)
utime_animkf = [
ngl.AnimKeyFrameFloat(0, 0),
ngl.AnimKeyFrameFloat(cfg.duration - 1.0, 1)
]
utime = ngl.AnimatedFloat(utime_animkf)
render = ngl.Render(q, p, nb_instances=dim_cut**2)
render.update_frag_resources(tex0=random_tex)
render.update_vert_resources(time=utime)
render.update_instance_attributes(
uv_offset=ngl.BufferVec2(data=uv_offset_buffer),
translate_a=ngl.BufferVec2(data=translate_a_buffer),
translate_b=ngl.BufferVec2(data=translate_b_buffer),
)
return render
def cropboard(cfg, dim_clr=3, dim_cut=9):
cfg.duration = 5. + 1.
random.seed(0)
get_rand = lambda: array.array(
'f', [random.random() for i in range(dim_clr**2 * 3)])
nb_kf = 2
buffers = [get_rand() for i in range(nb_kf)]
random_animkf = []
time_scale = cfg.duration / float(nb_kf)
for i, buf in enumerate(buffers + [buffers[0]]):
random_animkf.append(ngl.AnimKeyFrameBuffer(i * time_scale, buf))
random_buffer = ngl.AnimatedBufferVec3(keyframes=random_animkf)
random_tex = ngl.Texture2D(data_src=random_buffer,
width=dim_clr,
height=dim_clr)
kw = kh = 1. / dim_cut
qw = qh = 2. / dim_cut
p = ngl.Program(vertex=cfg.get_vert('cropboard'),
fragment=cfg.get_frag('texture'))
uv_offset_buffer = array.array('f')
translate_a_buffer = array.array('f')
translate_b_buffer = array.array('f')
if set_indices:
indices = array.array('H', [0, 2, 1, 3])
indices_buffer = ngl.BufferUShort(data=indices)
vertices = array.array('f', [
0,
0,
0,
qw,
qh,
0,
qw,
0,
0,
0,
qh,
0,
])
uvcoords = array.array('f', [
0,
1.0,
kw,
1.0 - kh,
kw,
1.0,
0,
1.0 - kh,
])
vertices_buffer = ngl.BufferVec3(data=vertices)
uvcoords_buffer = ngl.BufferVec2(data=uvcoords)
q = ngl.Geometry(topology='triangle_fan',
vertices=vertices_buffer,
uvcoords=uvcoords_buffer,
indices=indices_buffer)
else:
q = ngl.Quad(corner=(0, 0, 0),
width=(qw, 0, 0),
height=(0, qh, 0),
uv_corner=(0, 0),
uv_width=(kw, 0),
uv_height=(0, kh))
for y in range(dim_cut):
for x in range(dim_cut):
uv_offset = [x * kw, (y + 1.) * kh - 1.]
src = [random.uniform(-2, 2), random.uniform(-2, 2)]
dst = [x * qw - 1., 1. - (y + 1.) * qh]
uv_offset_buffer.extend(uv_offset)
translate_a_buffer.extend(src)
translate_b_buffer.extend(dst)
utime_animkf = [
ngl.AnimKeyFrameFloat(0, 0),
ngl.AnimKeyFrameFloat(cfg.duration - 1., 1)
]
utime = ngl.AnimatedFloat(utime_animkf)
render = ngl.Render(q, p, nb_instances=dim_cut**2)
render.update_textures(tex0=random_tex)
render.update_uniforms(time=utime)
render.update_instance_attributes(
uv_offset=ngl.BufferVec2(data=uv_offset_buffer),
translate_a=ngl.BufferVec2(data=translate_a_buffer),
translate_b=ngl.BufferVec2(data=translate_b_buffer),
)
return render
keyframes=_get_anim_kf(ngl.AnimKeyFrameBuffer, data)),
animated_buffer_vec3=lambda data: ngl.AnimatedBufferVec3(
keyframes=_get_anim_kf(ngl.AnimKeyFrameBuffer, data)),
animated_buffer_vec4=lambda data: ngl.AnimatedBufferVec4(
keyframes=_get_anim_kf(ngl.AnimKeyFrameBuffer, data)),
animated_quat_mat4=lambda data: ngl.AnimatedQuat(
keyframes=_get_anim_kf(ngl.AnimKeyFrameQuat, data), as_mat4=True),
animated_quat_vec4=lambda data: ngl.AnimatedQuat(
keyframes=_get_anim_kf(ngl.AnimKeyFrameQuat, data), as_mat4=False),
array_float=lambda data: ngl.BufferFloat(data=data),
array_int=lambda data: ngl.BufferInt(data=data),
array_ivec2=lambda data: ngl.BufferIVec2(data=data),
array_ivec3=lambda data: ngl.BufferIVec3(data=data),
array_ivec4=lambda data: ngl.BufferIVec4(data=data),
array_mat4=lambda data: ngl.BufferMat4(data=data),
array_vec2=lambda data: ngl.BufferVec2(data=data),
array_vec3=lambda data: ngl.BufferVec3(data=data),
array_vec4=lambda data: ngl.BufferVec4(data=data),
single_bool=lambda data: ngl.UniformBool(data),
single_float=lambda data: ngl.UniformFloat(data),
single_int=lambda data: ngl.UniformInt(data),
single_ivec2=lambda data: ngl.UniformIVec2(data),
single_ivec3=lambda data: ngl.UniformIVec3(data),
single_ivec4=lambda data: ngl.UniformIVec4(data),
single_uint=lambda data: ngl.UniformUInt(data),
single_uvec2=lambda data: ngl.UniformUIVec2(data),
single_uvec3=lambda data: ngl.UniformUIVec3(data),
single_uvec4=lambda data: ngl.UniformUIVec4(data),
single_mat4=lambda data: ngl.UniformMat4(data),
single_quat_mat4=lambda data: ngl.UniformQuat(data, as_mat4=True),
single_quat_vec4=lambda data: ngl.UniformQuat(data, as_mat4=False),
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)
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 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)
