def parallel_playback(cfg,
fast=True,
segment_time=2.0,
constrained_timeranges=False):
"""
Parallel media playback, flipping between the two sources.
The fast version makes sure the textures continue to be updated even though
they are not displayed. On the other hand, the slow version will update the
textures only when needed to be displayed, causing potential seek in the
underlying media, and thus undesired delays.
"""
m1 = ngl.Media(cfg.medias[0].filename, label="media #1")
m2 = ngl.Media(cfg.medias[0].filename, label="media #2")
t1 = ngl.Texture2D(data_src=m1, label="texture #1")
t2 = ngl.Texture2D(data_src=m2, label="texture #2")
render1 = ngl.RenderTexture(t1)
render2 = ngl.RenderTexture(t2)
text_settings = {
"box_corner": (-1, 1 - 0.2, 0),
"box_height": (0, 0.2, 0),
"aspect_ratio": cfg.aspect_ratio,
}
render1 = ngl.Group(children=(render1,
ngl.Text("media #1", **text_settings)))
render2 = ngl.Group(children=(render2,
ngl.Text("media #2", **text_settings)))
rf1 = ngl.TimeRangeFilter(render1)
rf2 = ngl.TimeRangeFilter(render2)
if constrained_timeranges:
rf1.set_prefetch_time(segment_time / 3.0)
rf2.set_prefetch_time(segment_time / 3.0)
rf1.set_max_idle_time(segment_time / 2.0)
rf2.set_max_idle_time(segment_time / 2.0)
t = 0
rr1 = []
rr2 = []
while t < cfg.duration:
rr1.append(ngl.TimeRangeModeCont(t))
rr1.append(ngl.TimeRangeModeNoop(t + segment_time))
rr2.append(ngl.TimeRangeModeNoop(t))
rr2.append(ngl.TimeRangeModeCont(t + segment_time))
t += 2 * segment_time
rf1.add_ranges(*rr1)
rf2.add_ranges(*rr2)
g = ngl.Group()
g.add_children(rf1, rf2)
if fast:
g.add_children(t1, t2)
return g
def _get_render_with_legend(cfg, fields, area, title, block_definition, color_definition, block_fields, color_fields, layout):
title_h = 1 / 10.
ax, ay, aw, ah = area
title_node = ngl.Text(
title,
box_corner=(ax, ay + ah - title_h, 0),
box_width=(aw, 0, 0),
box_height=(0, title_h, 0),
fg_color=(0, 0, 0, 1),
bg_color=(1, 1, 1, 1),
aspect_ratio=cfg.aspect_ratio,
)
text_group = ngl.Group()
nb_fields = len(fields)
field_h = (ah - title_h) / float(nb_fields)
for i, field in enumerate(fields):
field_hpos = nb_fields - i - 1
text_node = ngl.Text('#%02d %s' % (field['pos'], field['name']),
box_corner=(ax, ay + field_hpos * field_h, 0),
box_width=(aw / 2., 0, 0),
box_height=(0, field_h, 0),
fg_color=list(field['color']) + [1],
halign='left',
aspect_ratio=cfg.aspect_ratio)
text_group.add_children(text_node)
quad = ngl.Quad((ax + aw / 2., ay, 0), (aw / 2., 0, 0), (0, ah - title_h, 0))
render = get_render(cfg, quad, fields, block_definition, color_definition, block_fields, color_fields, layout)
return ngl.Group(children=(title_node, text_group, render))
def rtt_clear_attachment_with_timeranges(cfg):
cfg.aspect_ratio = (1, 1)
# Time-disabled full screen white quad
render = ngl.RenderColor(COLORS.white)
time_range_filter = ngl.TimeRangeFilter(render)
time_range_filter.add_ranges(ngl.TimeRangeModeNoop(0))
# Intermediate no-op RTT to force the use of a different render pass internally
texture = ngl.Texture2D(width=32, height=32)
rtt_noop = ngl.RenderToTexture(ngl.Identity(), [texture])
# Centered rotating quad
quad = ngl.Quad((-0.5, -0.5, 0), (1, 0, 0), (0, 1, 0))
render = ngl.RenderColor(COLORS.orange, geometry=quad)
animkf = [ngl.AnimKeyFrameFloat(0, 0), ngl.AnimKeyFrameFloat(cfg.duration, -360)]
render = ngl.Rotate(render, angle=ngl.AnimatedFloat(animkf))
group = ngl.Group(children=(time_range_filter, rtt_noop, render))
# Root RTT
texture = ngl.Texture2D(width=512, height=512)
rtt = ngl.RenderToTexture(group, [texture])
# Full screen render of the root RTT result
render = ngl.RenderTexture(texture)
return ngl.Group(children=(rtt, render))
def get_debug_points(cfg,
points,
radius=0.025,
color=COLORS['green'],
text_size=(0.1, 0.1)):
prog = ngl.Program(vertex=cfg.get_vert('color'),
fragment=cfg.get_frag('color'))
g = ngl.Group()
circle = ngl.Circle(radius=radius)
circle_render = ngl.Render(circle, prog)
circle_render.update_uniforms(color=ngl.UniformVec4(value=color))
box_w = (text_size[0], 0, 0)
box_h = (0, text_size[1], 0)
for pos_name, position in points.items():
text = ngl.Text(pos_name,
box_width=box_w,
box_height=box_h,
bg_color=(0, 0, 0, 0),
valign='top')
text = ngl.Translate(text, (1 + radius, 1 - radius - text_size[1], 0))
point = ngl.Group(children=(circle_render, text))
point = ngl.Translate(point, list(position) + [0])
g.add_children(point)
return ngl.GraphicConfig(g,
blend=True,
blend_src_factor='src_alpha',
blend_dst_factor='one_minus_src_alpha',
blend_src_factor_a='zero',
blend_dst_factor_a='one',
label='Debug circles')
def _get_scene(cfg, seed=0, enable_computes=True):
cfg.duration = 30
cfg.aspect_ratio = (16, 9)
rng = cfg.rng
rng.seed(seed)
cfg.texture_cache = {}
t0, t1 = 0, cfg.duration
# Some discrete abstract background
bg = ngl.RenderGradient4(
color_tl=_get_random_animated_color(rng, t0, t1),
color_tr=_get_random_animated_color(rng, t0, t1),
color_br=_get_random_animated_color(rng, t0, t1),
color_bl=_get_random_animated_color(rng, t0, t1),
filters=[ngl.FilterExposure(-1.5)],
)
# Always update all the textures to avoid time jumps
textures = list(cfg.texture_cache.values())
# The main overlay
root = _get_random_layer(cfg, rng, t0, t1, enable_computes)
group = ngl.Group(children=textures + [root])
camera = ngl.Camera(group)
camera.set_eye(0.0, 0.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 ngl.Group(children=(bg, camera))
def _get_random_layer(cfg, rng, t0, t1, enable_computes, layer=4):
nb_elems = rng.randint(2, 5)
children = []
sub_layers = rng.sample(range(nb_elems), 2)
for i in range(nb_elems):
if i in sub_layers and layer != 0:
# Recursively create another layer
child = _get_random_layer(cfg,
rng,
t0,
t1,
enable_computes,
layer=layer - 1)
child = _get_random_transform(rng, t0, t1, child)
child.set_label(f"layer={layer}")
# Create a (small) RTT of the children
rtt_tex = ngl.Texture2D(
width=rng.randint(50, 90),
height=rng.randint(15, 70),
)
rtt = ngl.RenderToTexture(
child,
clear_color=_get_random_color(rng) + (1, ),
)
rtt.add_color_textures(rtt_tex)
rtt_render = ngl.RenderTexture(
rtt_tex,
geometry=_get_random_geometry(rng),
blending="src_over",
)
rtt_render = _get_random_transform(rng, t0, t1, rtt_render)
t_start, t_end = _get_random_time_range(rng, t0, t1)
rtt_group = ngl.Group(children=(rtt, rtt_render))
t_filter = ngl.TimeRangeFilter(rtt_group)
t_filter.add_ranges(
ngl.TimeRangeModeNoop(0),
ngl.TimeRangeModeCont(t_start),
ngl.TimeRangeModeNoop(t_end),
)
# Draw both the children and the rendered texture
child = ngl.Group(children=(t_filter, child))
else:
# We are at a leaf (last layer) so we create a random render
t_start, t_end = _get_random_time_range(rng, t0, t1)
child = _get_random_render(cfg, rng, t_start, t_end,
enable_computes)
if rng.random() < 1 / 3:
child = _get_random_transform(rng, t_start, t_end, child)
child = ngl.TimeRangeFilter(child)
child.add_ranges(
ngl.TimeRangeModeNoop(0),
ngl.TimeRangeModeCont(t_start),
ngl.TimeRangeModeNoop(t_end),
)
children.append(child)
return ngl.Group(children=children)
def cube(cfg, display_depth_buffer=False):
'''
Cube with a common media Texture but a different color tainting on each side.
Also includes a depth map visualization.
'''
cube = ngl.Group(label='cube')
frag_data = cfg.get_frag('tex-tint')
program = ngl.Program(fragment=frag_data)
texture = ngl.Texture2D(data_src=ngl.Media(cfg.medias[0].filename))
children = [_get_cube_side(texture, program, qi[0], qi[1], qi[2], qi[3]) for qi in _get_cube_quads()]
cube.add_children(*children)
for i in range(3):
rot_animkf = ngl.AnimatedFloat([ngl.AnimKeyFrameFloat(0, 0),
ngl.AnimKeyFrameFloat(cfg.duration, 360 * (i + 1))])
axis = [int(i == x) for x in range(3)]
cube = ngl.Rotate(cube, axis=axis, anim=rot_animkf)
config = ngl.GraphicConfig(cube, depth_test=True)
camera = ngl.Camera(config)
camera.set_eye(0.0, 0.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)
if not display_depth_buffer:
return camera
else:
group = ngl.Group()
depth_texture = ngl.Texture2D()
depth_texture.set_format('d16_unorm')
depth_texture.set_width(640)
depth_texture.set_height(480)
texture = ngl.Texture2D()
texture.set_width(640)
texture.set_height(480)
rtt = ngl.RenderToTexture(camera)
rtt.add_color_textures(texture)
rtt.set_depth_texture(depth_texture)
quad = ngl.Quad((-1.0, -1.0, 0), (1, 0, 0), (0, 1, 0))
program = ngl.Program()
render = ngl.Render(quad, program)
render.update_textures(tex0=texture)
group.add_children(rtt, render)
quad = ngl.Quad((0.0, 0.0, 0), (1, 0, 0), (0, 1, 0))
program = ngl.Program()
render = ngl.Render(quad, program)
render.update_textures(tex0=depth_texture)
group.add_children(rtt, render)
return group
def _debug_overlay(cfg,
scene,
grid_names,
show_dbg_points=False,
show_labels=False):
if not show_dbg_points and not show_labels:
return scene
assert grid_names is not None
text_height = 0.25
overlay = ngl.Group()
if show_labels:
text_group = ngl.Group()
ag = AutoGrid(grid_names)
for grid_name, _, col, row in ag:
text = ngl.Text(
grid_name,
fg_color=COLORS.white,
bg_opacity=1,
valign="top",
box_width=(2.0, 0, 0),
box_height=(0, text_height, 0),
box_corner=(-1, 1.0 - text_height, 0),
)
text = ag.place_node(text, (col, row))
text_group.add_children(text)
scene = ngl.Translate(scene, (0, -text_height / 2.0 * ag.scale, 0),
label="text offsetting")
overlay.add_children(scene, text_group)
else:
overlay.add_children(scene)
if show_dbg_points:
nb = len(grid_names)
dbg_positions = _get_dbg_positions(nb)
if show_labels:
dbg_positions = {
name: (p[0], p[1] - text_height / 2.0 * ag.scale)
for name, p in dbg_positions.items()
}
dbg_points = get_debug_points(cfg,
dbg_positions,
radius=0.01,
text_size=(0.08, 0.08))
overlay.add_children(dbg_points)
return overlay
def media_timeranges_rtt(cfg):
m0 = cfg.medias[0]
cfg.duration = d = 10
cfg.aspect_ratio = (m0.width, m0.height)
# Use a media/texture as leaf to exercise its prefetch/release mechanism
media = ngl.Media(m0.filename)
texture = ngl.Texture2D(data_src=media)
# Diamond tree on the same media texture
render0 = ngl.RenderTexture(texture, label="leaf 0")
render1 = ngl.RenderTexture(texture, label="leaf 1")
# Create intermediate RTT "proxy" to exercise prefetch/release at this
# level as well
dst_tex0 = ngl.Texture2D(width=m0.width, height=m0.height)
dst_tex1 = ngl.Texture2D(width=m0.width, height=m0.height)
rtt0 = ngl.RenderToTexture(render0, [dst_tex0])
rtt1 = ngl.RenderToTexture(render1, [dst_tex1])
# Render the 2 RTTs vertically split (one half content each)
quad0 = ngl.Quad((-1, -1, 0), (1, 0, 0), (0, 2, 0), uv_corner=(0, 0), uv_width=(0.5, 0))
quad1 = ngl.Quad((0, -1, 0), (1, 0, 0), (0, 2, 0), uv_corner=(0.5, 0), uv_width=(0.5, 0))
rtt_render0 = ngl.RenderTexture(dst_tex0, geometry=quad0, label="render RTT 0")
rtt_render1 = ngl.RenderTexture(dst_tex1, geometry=quad1, label="render RTT 1")
proxy0 = ngl.Group(children=(rtt0, rtt_render0), label="proxy 0")
proxy1 = ngl.Group(children=(rtt1, rtt_render1), label="proxy 1")
# We want to make sure the idle times are enough to exercise the
# prefetch/release mechanism
prefetch_time = 1
assert prefetch_time < d / 5
# Split the presentation in 5 segments such that there are inactive times,
# prefetch times and both overlapping and non-overlapping times for the
# RTTs
ranges0 = (
ngl.TimeRangeModeNoop(0),
ngl.TimeRangeModeCont(1 / 5 * d),
ngl.TimeRangeModeNoop(3 / 5 * d),
)
ranges1 = (
ngl.TimeRangeModeNoop(0),
ngl.TimeRangeModeCont(2 / 5 * d),
ngl.TimeRangeModeNoop(4 / 5 * d),
)
trange0 = ngl.TimeRangeFilter(proxy0, ranges=ranges0, prefetch_time=prefetch_time, label="left")
trange1 = ngl.TimeRangeFilter(proxy1, ranges=ranges1, prefetch_time=prefetch_time, label="right")
return ngl.Group(children=(trange0, trange1))
def rtt_clear_attachment_with_timeranges(cfg):
cfg.aspect_ratio = (1, 1)
# Time-disabled full screen white quad
quad = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0))
program = ngl.Program(vertex=cfg.get_vert('color'),
fragment=cfg.get_frag('color'))
program.update_vert_out_vars(var_tex0_coord=ngl.IOVec2(),
var_uvcoord=ngl.IOVec2())
render = ngl.Render(quad, program)
render.update_frag_resources(color=ngl.UniformVec4(value=COLORS['white']))
time_range_filter = ngl.TimeRangeFilter(render)
time_range_filter.add_ranges(ngl.TimeRangeModeNoop(0))
# Intermediate no-op RTT to force the use of a different render pass internally
texture = ngl.Texture2D(width=32, height=32)
rtt_noop = ngl.RenderToTexture(ngl.Identity(), [texture])
# Centered rotating quad
quad = ngl.Quad((-0.5, -0.5, 0), (1, 0, 0), (0, 1, 0))
program = ngl.Program(vertex=cfg.get_vert('color'),
fragment=cfg.get_frag('color'))
program.update_vert_out_vars(var_tex0_coord=ngl.IOVec2(),
var_uvcoord=ngl.IOVec2())
render = ngl.Render(quad, program)
render.update_frag_resources(color=ngl.UniformVec4(value=COLORS['orange']))
animkf = [
ngl.AnimKeyFrameFloat(0, 0),
ngl.AnimKeyFrameFloat(cfg.duration, -360)
]
render = ngl.Rotate(render, anim=ngl.AnimatedFloat(animkf))
group = ngl.Group(children=(time_range_filter, rtt_noop, render))
# Root RTT
texture = ngl.Texture2D(width=512, height=512)
rtt = ngl.RenderToTexture(group, [texture])
# Full screen render of the root RTT result
quad = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0))
program = ngl.Program(vertex=cfg.get_vert('texture'),
fragment=cfg.get_frag('texture'))
program.update_vert_out_vars(var_tex0_coord=ngl.IOVec2(),
var_uvcoord=ngl.IOVec2())
render = ngl.Render(quad, program)
render.update_frag_resources(tex0=texture)
return ngl.Group(children=(rtt, render))
def _rtt_load_attachment(cfg):
quad = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0))
program = ngl.Program(vertex=cfg.get_vert('color'), fragment=cfg.get_frag('color'))
program.update_vert_out_vars(var_tex0_coord=ngl.IOVec2(), var_uvcoord=ngl.IOVec2())
background = ngl.Render(quad, program)
background.update_frag_resources(color=ngl.UniformVec4(value=COLORS['white']))
program = ngl.Program(vertex=cfg.get_vert('color'), fragment=cfg.get_frag('color'))
program.update_vert_out_vars(var_tex0_coord=ngl.IOVec2(), var_uvcoord=ngl.IOVec2())
render = ngl.Render(quad, program)
render.update_frag_resources(color=ngl.UniformVec4(value=COLORS['orange']))
texture = ngl.Texture2D(width=16, height=16)
rtt = ngl.RenderToTexture(render, [texture])
texture_noop = ngl.Texture2D(width=16, height=16)
rtt_noop = ngl.RenderToTexture(render, [texture_noop])
quad = ngl.Quad((0, 0, 0), (1, 0, 0), (0, 1, 0))
program = ngl.Program(vertex=cfg.get_vert('texture'), fragment=cfg.get_frag('texture'))
program.update_vert_out_vars(var_tex0_coord=ngl.IOVec2(), var_uvcoord=ngl.IOVec2())
foreground = ngl.Render(quad, program)
foreground.update_frag_resources(tex0=texture)
return ngl.Group(children=(background, rtt, rtt_noop, foreground))
def depth_stencil_depth(_):
group = ngl.Group()
count = 4
for i in range(count):
depth = (i + 1) / count
corner = (-1 + (count - 1 - i) * 2 / count, -1, depth)
render = _render_quad(corner=corner, color=(depth, depth, depth))
graphicconfig = ngl.GraphicConfig(
render,
depth_test=True,
depth_func="lequal",
)
group.add_children(graphicconfig)
for i, depth in enumerate((0.4, 0.6)):
corner = (-1, -0.5 + 0.25 * i, depth)
height = (0, 1 - 0.25 * i * 2, 0)
render = _render_quad(corner=corner, height=height, color=COLORS.red, opacity=0.5)
graphicconfig = ngl.GraphicConfig(
render,
depth_test=True,
depth_func="less",
depth_write_mask=False,
)
group.add_children(graphicconfig)
return group
def depth_stencil_stencil(_):
group = ngl.Group()
count = 4
for i in range(count):
render = _render_quad(corner=(-1 + (i * 2) / count, -1, 0), color=COLORS.black)
graphicconfig = ngl.GraphicConfig(
render,
color_write_mask="",
stencil_test=True,
stencil_write_mask=0xFF,
stencil_func="always",
stencil_ref=1,
stencil_read_mask=0xFF,
stencil_fail="incr",
stencil_depth_fail="incr",
stencil_depth_pass="******",
)
group.add_children(graphicconfig)
render = _render_quad(color=COLORS.white)
graphicconfig = ngl.GraphicConfig(
render,
stencil_test=True,
stencil_write_mask=0x0,
stencil_func="equal",
stencil_ref=1,
stencil_read_mask=0x1,
stencil_fail="keep",
stencil_depth_fail="keep",
stencil_depth_pass="******",
)
group.add_children(graphicconfig)
return group
def texture_mipmap(cfg, show_dbg_points=False):
cfg.aspect_ratio = (1, 1)
cuepoints = _get_texture_mipmap_cuepoints()
black = (0, 0, 0, 255)
white = (255, 255, 255, 255)
p = _N // 2
cb_data = array.array(
'B',
((black + white) * p + (white + black) * p) * p,
)
cb_buffer = ngl.BufferUBVec4(data=cb_data)
texture = ngl.Texture2D(
width=_N,
height=_N,
min_filter='nearest',
mipmap_filter='linear',
data_src=cb_buffer,
)
program = ngl.Program(vertex=_RENDER_TEXTURE_LOD_VERT,
fragment=_RENDER_TEXTURE_LOD_FRAG)
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)
render.update_frag_resources(tex0=texture)
group = ngl.Group(children=(render, ))
if show_dbg_points:
group.add_children(get_debug_points(cfg, cuepoints))
return group
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 _shape_geometry_rtt(cfg, depth=False, samples=0):
w, h = 640, 480
scene = _shape_geometry(cfg, set_normals=True)
if depth:
scene = ngl.GraphicConfig(scene, depth_test=True)
texture = ngl.Texture2D()
texture.set_width(w)
texture.set_height(h)
rtt = ngl.RenderToTexture(scene)
rtt.add_color_textures(texture)
if depth:
texture = ngl.Texture2D()
texture.set_format('d16_unorm')
texture.set_width(w)
texture.set_height(h)
rtt.set_depth_texture(texture)
else:
rtt.set_clear_color(*COLORS['cgreen'])
if samples:
rtt.set_samples(samples)
quad = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0))
program = ngl.Program(vertex=cfg.get_vert('texture'),
fragment=cfg.get_frag('texture'))
render = ngl.Render(quad, program)
render.update_textures(tex0=texture)
return ngl.Group(children=(rtt, render))
def velocity_triangle_rotate(cfg):
cfg.duration = 5.0
cfg.aspect_ratio = (1, 1)
anim_kf = [
ngl.AnimKeyFrameFloat(0, 0),
ngl.AnimKeyFrameFloat(cfg.duration, 360 * 3, "circular_in_out"),
]
anim = ngl.AnimatedFloat(anim_kf)
velocity = ngl.VelocityFloat(anim)
frag = textwrap.dedent("""\
void main()
{
float v = clamp(velocity / 3000., 0.0, 1.0);
ngl_out_color = vec4(v, v / 2.0, 0.0, 1.0);
}
""")
p0, p1, p2 = equilateral_triangle_coords(2.0)
triangle = ngl.RenderColor(COLORS.white, geometry=ngl.Triangle(p0, p1, p2))
triangle = ngl.Rotate(triangle, angle=anim)
prog_c = ngl.Program(vertex=cfg.get_vert("color"), fragment=frag)
circle = ngl.Render(ngl.Circle(radius=1.0, npoints=128), prog_c)
circle.update_frag_resources(velocity=velocity)
return ngl.Group(children=(circle, triangle))
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 easings(cfg, easing_id="*"):
"""Display all the easings (primitive for animation / motion design) at once"""
cfg.duration = 2.0
vert_data = cfg.get_vert("color")
frag_data = cfg.get_frag("color")
color_program = ngl.Program(vertex=vert_data,
fragment=frag_data,
label="color")
color_program.update_vert_out_vars(var_uvcoord=ngl.IOVec2())
full_block = _block(2, 2, (0.3, 0.3, 0.3))
group = ngl.Group()
group.add_children(full_block)
if easing_id == "*":
for easing_node in _get_easing_nodes(cfg, color_program):
group.add_children(easing_node)
else:
cfg.aspect_ratio = (1, 1)
easing_index = _easing_names.index(easing_id)
cfg.rng.seed(easing_index)
easing, zoom = _easing_list[easing_index]
easing_node = _get_easing_node(cfg, easing, zoom, color_program)
group.add_children(easing_node)
return group
def py_bindings_wrong_param():
try:
ngl.Group(dont="exist")
except Exception:
pass
else:
assert False
def queued_medias(cfg, overlap_time=1., dim=3):
'''Queue of medias, mainly used as a demonstration for the prefetch/release mechanism'''
qw = qh = 2. / dim
nb_videos = dim * dim
tqs = []
p = ngl.Program()
for y in range(dim):
for x in range(dim):
video_id = y * dim + x
start = video_id * cfg.duration / nb_videos
animkf = [ngl.AnimKeyFrameFloat(start, 0)]
m = ngl.Media(cfg.medias[video_id % len(cfg.medias)].filename,
time_anim=ngl.AnimatedTime(animkf))
m.set_label('media #%d' % video_id)
corner = (-1. + x * qw, 1. - (y + 1) * qh, 0)
q = ngl.Quad(corner, (qw, 0, 0), (0, qh, 0))
t = ngl.Texture2D(data_src=m)
render = ngl.Render(q, p)
render.set_label('render #%d' % video_id)
render.update_textures(tex0=t)
rf = ngl.TimeRangeFilter(render)
if start:
rf.add_ranges(ngl.TimeRangeModeNoop(0))
rf.add_ranges(
ngl.TimeRangeModeCont(start),
ngl.TimeRangeModeNoop(start + cfg.duration / nb_videos +
overlap_time))
tqs.append(rf)
return ngl.Group(children=tqs)
def queued_medias(cfg, overlap_time=1.0, dim=3):
"""Queue of medias, mainly used as a demonstration for the prefetch/release mechanism"""
nb_videos = dim * dim
tqs = []
ag = AutoGrid(range(nb_videos))
for video_id, _, col, pos in ag:
start = video_id * cfg.duration / nb_videos
animkf = [
ngl.AnimKeyFrameFloat(start, 0),
ngl.AnimKeyFrameFloat(start + cfg.duration, cfg.duration),
]
m = ngl.Media(cfg.medias[video_id % len(cfg.medias)].filename,
time_anim=ngl.AnimatedTime(animkf))
m.set_label("media #%d" % video_id)
t = ngl.Texture2D(data_src=m)
render = ngl.RenderTexture(t)
render.set_label("render #%d" % video_id)
render = ag.place_node(render, (col, pos))
rf = ngl.TimeRangeFilter(render)
if start:
rf.add_ranges(ngl.TimeRangeModeNoop(0))
rf.add_ranges(
ngl.TimeRangeModeCont(start),
ngl.TimeRangeModeNoop(start + cfg.duration / nb_videos +
overlap_time))
tqs.append(rf)
return ngl.Group(children=tqs)
def _get_texture_cubemap_from_mrt_scene_2_pass(cfg, samples=0):
group = ngl.Group()
quad = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0))
cube = ngl.TextureCube(size=64, min_filter="linear", mag_filter="linear")
layer_base = 0
for layer_count, fragment in ((2, _RENDER_TO_CUBEMAP_1_FRAG),
(4, _RENDER_TO_CUBEMAP_2_FRAG)):
program = ngl.Program(vertex=_RENDER_TO_CUBEMAP_VERT,
fragment=fragment,
nb_frag_output=layer_count)
program.update_vert_out_vars(var_uvcoord=ngl.IOVec3())
render = ngl.Render(quad, program)
color_textures = [
ngl.TextureView(cube, layer)
for layer in range(layer_base, layer_base + layer_count)
]
rtt = ngl.RenderToTexture(render, color_textures, samples=samples)
group.add_children(rtt)
layer_base += layer_count
program = ngl.Program(vertex=_RENDER_CUBEMAP_VERT,
fragment=_RENDER_CUBEMAP_FRAG)
program.update_vert_out_vars(var_uvcoord=ngl.IOVec3())
render = ngl.Render(quad, program)
render.update_frag_resources(tex0=cube)
group.add_children(render)
return group
def easings(cfg, easing_id='*'):
'''Display all the easings (primitive for animation / motion design) at once'''
random.seed(0)
cfg.duration = 2.
vert_data = cfg.get_vert('color')
frag_data = cfg.get_frag('color')
color_program = ngl.Program(vertex=vert_data,
fragment=frag_data,
label='color')
full_block = _block(2,
2,
color_program,
color=ngl.UniformVec4(value=(.3, .3, .3, 1)))
group = ngl.Group()
group.add_children(full_block)
if easing_id == '*':
for easing_node in _get_easing_nodes(cfg, color_program):
group.add_children(easing_node)
else:
cfg.aspect_ratio = (1, 1)
easing_index = _easing_names.index(easing_id)
random.seed(easing_index)
easing, zoom = _easing_list[easing_index]
easing_node = _get_easing_node(cfg, easing, zoom, color_program)
group.add_children(easing_node)
return ngl.GraphicConfig(group,
blend=True,
blend_src_factor='src_alpha',
blend_dst_factor='one_minus_src_alpha',
blend_src_factor_a='zero',
blend_dst_factor_a='one')
def _get_rtt_scene(cfg, features='depth', texture_ds_format=None, samples=0, mipmap_filter='none', sample_depth=False):
cfg.duration = 10
cfg.aspect_ratio = (1, 1)
cube = _get_cube()
program = ngl.Program(vertex=_RENDER_CUBE_VERT, fragment=_RENDER_CUBE_FRAG)
program.update_vert_out_vars(var_normal=ngl.IOVec3())
render = ngl.Render(cube, program)
render = ngl.Scale(render, (0.5, 0.5, 0.5))
for i in range(3):
rot_animkf = ngl.AnimatedFloat([
ngl.AnimKeyFrameFloat(0, 0),
ngl.AnimKeyFrameFloat(cfg.duration, 360 * (i + 1))
])
axis = [int(i == x) for x in range(3)]
render = ngl.Rotate(render, axis=axis, anim=rot_animkf)
config = ngl.GraphicConfig(render, depth_test=True)
camera = ngl.Camera(
config,
eye=(0.0, 0.0, 3.0),
center=(0.0, 0.0, 0.0),
up=(0.0, 1.0, 0.0),
perspective=(45.0, cfg.aspect_ratio_float),
clipping=(1.0, 10.0),
)
size = 1024
texture_depth = None
if texture_ds_format:
texture_depth = ngl.Texture2D(width=size, height=size, format=texture_ds_format)
texture = ngl.Texture2D(
width=size,
height=size,
min_filter='linear',
mipmap_filter=mipmap_filter,
)
rtt = ngl.RenderToTexture(
camera,
[texture],
features=features,
depth_texture=texture_depth,
samples=samples,
clear_color=(0, 0, 0, 1),
)
quad = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0))
if sample_depth:
program = ngl.Program(vertex=cfg.get_vert('texture'), fragment=_RENDER_DEPTH)
program.update_vert_out_vars(var_tex0_coord=ngl.IOVec2(), var_uvcoord=ngl.IOVec2())
render = ngl.Render(quad, program)
render.update_frag_resources(tex0=texture_depth)
else:
program = ngl.Program(vertex=cfg.get_vert('texture'), fragment=cfg.get_frag('texture'))
program.update_vert_out_vars(var_tex0_coord=ngl.IOVec2(), var_uvcoord=ngl.IOVec2())
render = ngl.Render(quad, program)
render.update_frag_resources(tex0=texture)
return ngl.Group(children=(rtt, render))
def _get_background_circles(circle, positions, bcolor):
blend_bg = ngl.Group()
render = ngl.RenderColor(bcolor, geometry=circle)
for position in positions:
trender = ngl.Translate(render, position + (0.0, ))
blend_bg.add_children(trender)
return blend_bg
def api_media_sharing_failure():
ctx = ngl.Context()
ret = ctx.configure(offscreen=1, width=16, height=16, backend=_backend)
assert ret == 0
m = ngl.Media("/dev/null")
scene = ngl.Group(children=(ngl.Texture2D(data_src=m), ngl.Texture2D(data_src=m)))
assert _ret_to_fourcc(ctx.set_scene(scene)) == "Eusg" # Usage error
def autogrid_simple(scenes):
ag = AutoGrid(scenes)
g = ngl.Group()
for scene, scene_id, col, row in ag:
scene = ag.place_node(scene, (col, row))
g.add_children(scene)
return g
def debug_block(cfg, seed=0, layout=LAYOUTS[0], color_tint=True):
cfg.duration = ANIM_DURATION
cfg.aspect_ratio = (1, 1)
spec = _get_data_spec(layout)
fields_info, block_fields, color_fields, block_definition, color_definition = get_random_block_info(spec, seed, layout, color_tint=color_tint)
fields_single = [f for f in fields_info if f['category'] == 'single']
fields_array = [f for f in fields_info if f['category'] == 'array']
fields_animated = [f for f in fields_info if f['category'].startswith('animated')]
field_specs = (
(fields_single, (-1/3., -1, 2/3., 2.), 'Single fields'),
(fields_array, ( 1/3., 0, 2/3., 1.), 'Arrays'),
(fields_animated, ( 1/3., -1, 2/3., 1.), 'Animated'),
)
g = ngl.Group()
block_def_text = ngl.Text(
f'{layout}:\n\n{block_definition}',
valign='top',
box_corner=(-1, -1, 0),
box_width=(2/3., 0, 0),
box_height=(0, 2, 0),
aspect_ratio=cfg.aspect_ratio,
)
g.add_children(block_def_text)
for cat_fields, area, title in field_specs:
visual_fields = _get_render_with_legend(cfg, cat_fields, area, title, block_definition, color_definition, block_fields, color_fields, layout)
g.add_children(visual_fields)
return g
def queued_medias(cfg, overlap_time=1., dim=3):
'''Queue of medias, mainly used as a demonstration for the prefetch/release mechanism'''
nb_videos = dim * dim
tqs = []
q = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0))
ag = AutoGrid(range(nb_videos))
for video_id, _, col, pos in ag:
start = video_id * cfg.duration / nb_videos
animkf = [ngl.AnimKeyFrameFloat(start, 0)]
m = ngl.Media(cfg.medias[video_id % len(cfg.medias)].filename, time_anim=ngl.AnimatedTime(animkf))
m.set_label('media #%d' % video_id)
t = ngl.Texture2D(data_src=m)
program = ngl.Program(vertex=cfg.get_vert('texture'), fragment=cfg.get_frag('texture'))
program.update_vert_out_vars(var_uvcoord=ngl.IOVec2(), var_tex0_coord=ngl.IOVec2())
render = ngl.Render(q, program)
render.set_label('render #%d' % video_id)
render.update_frag_resources(tex0=t)
render = ag.place_node(render, (col, pos))
rf = ngl.TimeRangeFilter(render)
if start:
rf.add_ranges(ngl.TimeRangeModeNoop(0))
rf.add_ranges(ngl.TimeRangeModeCont(start),
ngl.TimeRangeModeNoop(start + cfg.duration/nb_videos + overlap_time))
tqs.append(rf)
return ngl.Group(children=tqs)
