def _get_live_function(spec, field_id, layout):
fields = match_fields(spec, field_id)
assert len(fields) == 1
field = fields[0]
data_src = field['livechange']
def keyframes_callback(t_id):
if t_id:
v = data_src[t_id - 1]
field['node'].set_value(*v)
@test_cuepoints(points=get_data_debug_positions(spec, field_id),
nb_keyframes=len(data_src) + 1,
keyframes_callback=keyframes_callback,
tolerance=1,
exercise_serialization=False,
debug_positions=False)
@scene(seed=scene.Range(range=[0, 100]),
debug_positions=scene.Bool(),
color_tint=scene.Bool())
def scene_func(cfg, seed=0, debug_positions=True, color_tint=False):
return _live_scene(cfg, spec, field_id, seed, layout, debug_positions,
color_tint)
return scene_func
def _get_userlive_switch_func():
scene0 = ngl.RenderColor(COLORS.white, geometry=ngl.Circle())
scene1 = ngl.RenderColor(COLORS.red, geometry=ngl.Quad())
scene2 = ngl.RenderColor(COLORS.azure, geometry=ngl.Triangle())
switch0 = ngl.UserSwitch(
ngl.Scale(scene0, factors=(1 / 3, 1 / 3, 1 / 3), anchor=(-1, 0, 0)))
switch1 = ngl.UserSwitch(ngl.Scale(scene1, factors=(1 / 2, 1 / 2, 1 / 2)))
switch2 = ngl.UserSwitch(
ngl.Scale(scene2, factors=(1 / 3, 1 / 3, 1 / 3), anchor=(1, 0, 0)))
def keyframes_callback(t_id):
# Build a "random" composition of switches
switch0.set_enabled(t_id % 2 == 0)
switch1.set_enabled(t_id % 3 == 0)
switch2.set_enabled(t_id % 4 == 0)
@test_fingerprint(nb_keyframes=10,
keyframes_callback=keyframes_callback,
tolerance=1,
exercise_serialization=False)
@scene(s0=scene.Bool(), s1=scene.Bool(), s2=scene.Bool())
def scene_func(cfg, s0_enabled=True, s1_enabled=True, s2_enabled=True):
cfg.aspect_ratio = (1, 1)
switch0.set_enabled(s0_enabled)
switch1.set_enabled(s1_enabled)
switch2.set_enabled(s2_enabled)
return ngl.Group(children=(switch0, switch1, switch2))
return scene_func
def _get_live_trf_function(spec, field_id, layout):
fields = match_fields(spec, field_id)
assert len(fields) == 1
field = fields[0]
livechange_funcs = field['livechange']
def keyframes_callback(t_id):
livechange_funcs[t_id]()
@test_cuepoints(points=get_data_debug_positions(spec, field_id),
nb_keyframes=len(livechange_funcs),
keyframes_callback=keyframes_callback,
tolerance=1,
exercise_serialization=False,
debug_positions=False)
@scene(seed=scene.Range(range=[0, 100]),
debug_positions=scene.Bool(),
color_tint=scene.Bool(),
trf_step=scene.Range(range=[0, len(livechange_funcs)]))
def scene_func(cfg,
seed=0,
debug_positions=True,
color_tint=False,
trf_step=0):
s = _live_scene(cfg, spec, field_id, seed, layout, debug_positions,
color_tint)
for i in range(trf_step):
keyframes_callback(i)
return s
return scene_func
def _get_blending_function(bname, bcolor, **bparams):
@test_cuepoints(points=_get_dbg_positions(), **_TEST_SETTINGS)
@scene(show_dbg_points=scene.Bool(), show_labels=scene.Bool())
def scene_func(cfg, show_dbg_points=True, show_labels=True):
scene = _get_blending_scene(cfg, bname, bcolor, **bparams)
return _debug_overlay(cfg, scene, [bname], show_dbg_points, show_labels)
return scene_func
def _get_live_shared_uniform_function(layout=None):
data = [COLORS.red, COLORS.blue]
color = ngl.UniformVec3(value=COLORS.black, label="color")
def keyframes_callback(t_id):
color.set_value(*data[t_id])
@test_cuepoints(
points=_SHARED_UNIFORM_CUEPOINTS,
nb_keyframes=len(data),
keyframes_callback=keyframes_callback,
tolerance=1,
exercise_serialization=False,
debug_positions=False,
)
@scene(debug_positions=scene.Bool())
def scene_func(cfg, debug_positions=True):
cfg.duration = 0
cfg.aspect_ratio = (1, 1)
if layout:
return _get_live_shared_uniform_with_block_scene(
cfg, color, layout, debug_positions)
else:
return _get_live_shared_uniform_scene(cfg, color, debug_positions)
return scene_func
def _get_data_function(field_id, layout):
nb_keyframes = 5 if 'animated' in field_id else 1
spec = _get_data_spec(layout)
@test_cuepoints(points=get_data_debug_positions(spec, field_id),
nb_keyframes=nb_keyframes,
tolerance=1,
debug_positions=False)
@scene(seed=scene.Range(range=[0, 100]),
debug_positions=scene.Bool(),
color_tint=scene.Bool())
def scene_func(cfg, seed=0, debug_positions=True, color_tint=False):
return _data_scene(cfg, spec, field_id, seed, layout, debug_positions,
color_tint)
return scene_func
def _get_data_function(spec, category, field_type, layout):
nb_keyframes = 5 if "animated" in category else 1
fields = match_fields(spec, category, field_type)
@test_cuepoints(
points=get_data_debug_positions(fields),
nb_keyframes=nb_keyframes,
tolerance=1,
debug_positions=False,
)
@scene(seed=scene.Range(range=[0, 100]),
debug_positions=scene.Bool(),
color_tint=scene.Bool())
def scene_func(cfg, seed=0, debug_positions=True, color_tint=False):
cfg.duration = ANIM_DURATION
return get_field_scene(cfg, spec, category, field_type, seed,
debug_positions, layout, color_tint)
return scene_func
def _get_data_streamed_buffer_function(scale, single):
size = 2 if single else 4
nb_keyframes = 4
@test_cuepoints(points=_get_data_streamed_buffer_cuepoints(size),
nb_keyframes=nb_keyframes,
tolerance=1)
@scene(show_dbg_points=scene.Bool())
def scene_func(cfg, show_dbg_points=False):
return _get_data_streamed_buffer_vec4_scene(cfg, size, nb_keyframes,
scale, single,
show_dbg_points)
return scene_func
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))
@scene(seed=scene.Range(range=[0, 100]),
layout=scene.List(choices=LAYOUTS),
color_tint=scene.Bool())
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'),
import pynodegl as ngl
from pynodegl_utils.misc import scene
@scene(uv_corner=scene.Vector(n=2),
uv_width=scene.Vector(n=2),
uv_height=scene.Vector(n=2),
progress_bar=scene.Bool())
def centered_media(cfg,
uv_corner=(0, 0),
uv_width=(1, 0),
uv_height=(0, 1),
progress_bar=True):
'''A simple centered media with an optional progress bar in the shader'''
m0 = cfg.medias[0]
cfg.duration = m0.duration
cfg.aspect_ratio = (m0.width, m0.height)
q = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0), uv_corner, uv_width,
uv_height)
m = ngl.Media(m0.filename)
t = ngl.Texture2D(data_src=m)
p = ngl.Program(vertex=cfg.get_vert('texture'),
fragment=cfg.get_frag('texture'))
p.update_vert_out_vars(var_tex0_coord=ngl.IOVec2(),
var_uvcoord=ngl.IOVec2())
render = ngl.Render(q, p)
render.update_frag_resources(tex0=t)
if progress_bar:
p.set_fragment(cfg.get_frag('progress-bar'))
filters=(
ngl.FilterAlpha(alpha=1.0),
ngl.FilterInverseAlpha(),
ngl.FilterAlpha(alpha=0.1),
ngl.FilterInverseAlpha(),
ngl.FilterPremult(),
),
)
@test_cuepoints(points=_CUEPOINTS,
width=320,
height=240,
nb_keyframes=1,
tolerance=1)
@scene(linear=scene.Bool())
def filter_gamma_correct(cfg, linear=True):
"""This test operates a gamma correct blending (the blending happens in linear space)"""
# Hue colors rotated clockwise
dst = ngl.RenderGradient4(
color_tl=COLORS.rose,
color_tr=COLORS.blue,
color_br=COLORS.sgreen,
color_bl=COLORS.yellow,
)
# Hue colors rotated counter-clockwise started with another color
src = ngl.RenderGradient4(
color_tl=COLORS.orange,
color_tr=COLORS.magenta,
import array
import random
import pynodegl as ngl
from pynodegl_utils.misc import scene
@scene(color=scene.Color(),
rotate=scene.Bool(),
scale=scene.Bool(),
translate=scene.Bool())
def animated_square(cfg,
color=(1, 0.66, 0, 1),
rotate=True,
scale=True,
translate=True):
'''Animated Translate/Scale/Rotate on a square'''
cfg.duration = 5.0
cfg.aspect_ratio = (1, 1)
sz = 1 / 3.
q = ngl.Quad((-sz / 2, -sz / 2, 0), (sz, 0, 0), (0, sz, 0))
p = ngl.Program(vertex=cfg.get_vert('color'),
fragment=cfg.get_frag('color'))
node = ngl.Render(q, p)
ucolor = ngl.UniformVec4(value=color)
node.update_uniforms(color=ucolor)
coords = [(-1, 1), (1, 1), (1, -1), (-1, -1), (-1, 1)]
if rotate:
animkf = (ngl.AnimKeyFrameFloat(0, 0),
_N = 8
def _get_compute_histogram_cuepoints():
f = float(_N)
off = 1 / (2 * f)
c = lambda i: (i / f + off) * 2.0 - 1.0
return {
"%d%d" % (x, y): (c(x), c(y))
for y in range(_N) for x in range(_N)
}
@test_cuepoints(points=_get_compute_histogram_cuepoints(), tolerance=1)
@scene(show_dbg_points=scene.Bool())
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")
radius=0.01,
text_size=(0.08, 0.08))
overlay.add_children(dbg_points)
return overlay
_TEST_SETTINGS = dict(show_dbg_points=False,
show_labels=False,
clear_color=list(COLORS.azure) + [1],
tolerance=1)
@test_cuepoints(points=_get_dbg_positions(_NB_BLENDINGS), **_TEST_SETTINGS)
@scene(show_dbg_points=scene.Bool(), show_labels=scene.Bool())
def blending_all_diamond(cfg, show_dbg_points=True, show_labels=True):
scenes = _get_blending_scenes(cfg)
scene = autogrid_simple(scenes)
return _debug_overlay(cfg, scene, _BLENDINGS, show_dbg_points, show_labels)
@test_cuepoints(points=_get_dbg_positions(_NB_BLENDINGS),
nb_keyframes=_NB_BLENDINGS + 1,
**_TEST_SETTINGS)
@scene(show_dbg_points=scene.Bool(), show_labels=scene.Bool())
def blending_all_timed_diamond(cfg, show_dbg_points=True, show_labels=True):
scenes = _get_blending_scenes(cfg)
scene = autogrid_queue(scenes, duration=cfg.duration, overlap_time=1.5)
return _debug_overlay(cfg, scene, _BLENDINGS, show_dbg_points, show_labels)
from pynodegl_utils.misc import scene
from pynodegl_utils.toolbox.colors import get_random_color_buffer
import pynodegl as ngl
@scene(color=scene.Color(), rotate=scene.Bool(), scale=scene.Bool(), translate=scene.Bool())
def animated_square(cfg, color=(1, 0.66, 0), rotate=True, scale=True, translate=True):
"""Animated Translate/Scale/Rotate on a square"""
cfg.duration = 5.0
cfg.aspect_ratio = (1, 1)
sz = 1 / 3.0
q = ngl.Quad((-sz / 2, -sz / 2, 0), (sz, 0, 0), (0, sz, 0))
node = ngl.RenderColor(color, geometry=q)
coords = [(-1, 1), (1, 1), (1, -1), (-1, -1), (-1, 1)]
if rotate:
animkf = (ngl.AnimKeyFrameFloat(0, 0), ngl.AnimKeyFrameFloat(cfg.duration, 360))
node = ngl.Rotate(node, angle=ngl.AnimatedFloat(animkf))
if scale:
animkf = (
ngl.AnimKeyFrameVec3(0, (1, 1, 1)),
ngl.AnimKeyFrameVec3(cfg.duration / 2, (2, 2, 2)),
ngl.AnimKeyFrameVec3(cfg.duration, (1, 1, 1)),
)
node = ngl.Scale(node, factors=ngl.AnimatedVec3(animkf))
if translate:
import os.path as op
import array
import colorsys
import math
import random
import pynodegl as ngl
from pynodegl_utils.misc import scene
@scene(xsplit=scene.Range(range=[0, 1], unit_base=100),
trilinear=scene.Bool())
def lut3d(cfg, xsplit=.3, trilinear=True):
'''Lookup Table 3D using a Texture3D'''
level = 6
level2 = level**2
# Generated with `ffmpeg -f lavfi -i haldclutsrc=6,curves=vintage -f
# rawvideo -frames:v 1 lut3d.raw`
lut3d_filename = op.join(op.dirname(__file__), 'data', 'lut3d.raw')
cfg.files.append(lut3d_filename)
lut3d_buf = ngl.BufferUBVec3(filename=lut3d_filename)
lut3d_tex = ngl.Texture3D(data_src=lut3d_buf,
width=level2, height=level2, depth=level2)
if trilinear:
lut3d_tex.set_min_filter('linear')
lut3d_tex.set_mag_filter('linear')
m0 = cfg.medias[0]
cfg.duration = m0.duration
cfg.aspect_ratio = (m0.width, m0.height)
video = ngl.Media(m0.filename)
from pynodegl_utils.misc import scene
import pynodegl as ngl
@scene(uv_corner=scene.Vector(n=2), uv_width=scene.Vector(n=2), uv_height=scene.Vector(n=2), progress_bar=scene.Bool())
def centered_media(cfg, uv_corner=(0, 0), uv_width=(1, 0), uv_height=(0, 1), progress_bar=True):
"""A simple centered media with an optional progress bar in the shader"""
m0 = cfg.medias[0]
cfg.duration = m0.duration
cfg.aspect_ratio = (m0.width, m0.height)
q = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0), uv_corner, uv_width, uv_height)
m = ngl.Media(m0.filename)
t = ngl.Texture2D(data_src=m)
p = ngl.Program(vertex=cfg.get_vert("texture"), fragment=cfg.get_frag("texture"))
p.update_vert_out_vars(var_tex0_coord=ngl.IOVec2(), var_uvcoord=ngl.IOVec2())
render = ngl.Render(q, p)
render.update_frag_resources(tex0=t)
if progress_bar:
p.set_fragment(cfg.get_frag("progress-bar"))
media_duration = ngl.UniformFloat(m0.duration)
ar = ngl.UniformFloat(cfg.aspect_ratio_float)
render.update_frag_resources(media_duration=media_duration, ar=ar)
return render
@scene(speed=scene.Range(range=[0.01, 2], unit_base=1000))
def playback_speed(cfg, speed=1.0):
import os.path as op
import array
import colorsys
import math
import random
import pynodegl as ngl
from pynodegl_utils.misc import scene
@scene(xsplit=scene.Range(range=[0, 1], unit_base=100), trilinear=scene.Bool())
def lut3d(cfg, xsplit=.3, trilinear=True):
'''Lookup Table 3D using a Texture3D'''
level = 6
level2 = level**2
# Generated with `ffmpeg -f lavfi -i haldclutsrc=6,curves=vintage,format=rgba
# -f rawvideo -frames:v 1 lut3d.raw`
lut3d_filename = op.join(op.dirname(__file__), 'data', 'lut3d.raw')
cfg.files.append(lut3d_filename)
lut3d_buf = ngl.BufferUBVec4(filename=lut3d_filename)
lut3d_tex = ngl.Texture3D(data_src=lut3d_buf,
width=level2,
height=level2,
depth=level2)
if trilinear:
lut3d_tex.set_min_filter('linear')
lut3d_tex.set_mag_filter('linear')
m0 = cfg.medias[0]
cfg.duration = m0.duration
cfg.aspect_ratio = (m0.width, m0.height)
# 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))
@scene(seed=scene.Range(range=[0, 1000]), enable_computes=scene.Bool())
def benchmark_test(cfg, seed=82, enable_computes=True):
"""Function to be used for manual testing"""
return _get_scene(cfg, seed, enable_computes)
@test_fingerprint(width=1920, height=1080, nb_keyframes=120, tolerance=3)
@scene()
def benchmark_fingerprint_with_compute(cfg):
return _get_scene(cfg, seed=0, enable_computes=True)
@test_fingerprint(width=1920, height=1080, nb_keyframes=120, tolerance=3)
@scene()
def benchmark_fingerprint_without_compute(cfg):
return _get_scene(cfg, seed=1, enable_computes=False)
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)
@scene(fast=scene.Bool(),
segment_time=scene.Range(range=[0.1, 10], unit_base=10),
constrained_timeranges=scene.Bool())
def parallel_playback(cfg,
fast=True,
segment_time=2.,
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.
'''
q = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0))
