def test_ctx_ownership():
viewer = ngl.Viewer()
viewer2 = ngl.Viewer()
assert viewer.configure(offscreen=1, width=16, height=16) == 0
assert viewer2.configure(offscreen=1, width=16, height=16) == 0
scene = ngl.Render(ngl.Quad())
viewer.set_scene(scene)
viewer.draw(0)
assert viewer2.set_scene(scene) != 0
viewer2.draw(0)
del viewer
del viewer2
def _init_viewer(self, rendering_backend):
if self._viewer:
return
self._viewer = ngl.Viewer()
self._viewer.configure(backend=misc.get_backend(rendering_backend),
offscreen=1,
width=16,
height=16)
def test_ctx_ownership_subgraph():
for shared in (True, False):
viewer = ngl.Viewer()
viewer2 = ngl.Viewer()
assert viewer.configure(offscreen=1, width=16, height=16) == 0
assert viewer2.configure(offscreen=1, width=16, height=16) == 0
quad = ngl.Quad()
render1 = ngl.Render(quad)
if not shared:
quad = ngl.Quad()
render2 = ngl.Render(quad)
scene = ngl.Group([render1, render2])
viewer.set_scene(render2)
viewer.draw(0)
assert viewer2.set_scene(scene) != 0
viewer2.draw(0)
del viewer
del viewer2
def test_reconfigure_fail():
viewer = ngl.Viewer()
assert viewer.configure(offscreen=1, width=16, height=16) == 0
scene = ngl.Render(ngl.Quad())
viewer.set_scene(scene)
viewer.draw(0)
assert viewer.configure(offscreen=0) != 0
viewer.draw(1)
del viewer
def test_capture_buffer_lifetime(width=1024, height=1024):
capture_buffer = bytearray(width * height * 4)
viewer = ngl.Viewer()
assert viewer.configure(offscreen=1, width=width, height=height, capture_buffer=capture_buffer) == 0
del capture_buffer
scene = ngl.Render(ngl.Quad())
viewer.set_scene(scene)
viewer.draw(0)
del viewer
def test_reconfigure():
viewer = ngl.Viewer()
assert viewer.configure(offscreen=1, width=16, height=16) == 0
scene = ngl.Render(ngl.Quad())
viewer.set_scene(scene)
viewer.draw(0)
assert viewer.configure(offscreen=1, width=16, height=16) == 0
# FIXME: errors should be raised by the draw call so we can assert here
viewer.draw(1)
del viewer
def api_hud(width=234, height=123):
viewer = ngl.Viewer()
assert viewer.configure(offscreen=1,
width=width,
height=height,
backend=_backend) == 0
quad = ngl.Quad()
render = ngl.Render(quad)
scene = ngl.HUD(render)
viewer.set_scene(scene)
for i in range(60 * 3):
viewer.draw(i / 60.)
del viewer
def set_scene(self, cfg):
with QtCore.QMutexLocker(self._mutex):
self._scene = cfg['scene']
self._framerate = cfg['framerate']
self._duration = cfg['duration']
self._clear_color = cfg['clear_color']
self._aspect_ratio = cfg['aspect_ratio']
self._samples = cfg['samples']
if self._backend != cfg['backend']:
self._backend = cfg['backend']
self._viewer = ngl.Viewer()
self._configure_viewer()
self._push_event(lambda: self._set_scene())
def render_frames(self):
# We make sure the lists of medias is explicitely empty. If we don't a
# jobbed make on the tests will attempt concurrent generations of a
# default ngl-media.mp4.
idict = dict(medias=[])
backend = os.environ.get('BACKEND')
if backend:
idict['backend'] = backend
ret = self._scene_func(idict=idict, **self._scene_kwargs)
width, height = self._width, self._height
duration = ret['duration']
scene = ret['scene']
capture_buffer = bytearray(width * height * 4)
viewer = ngl.Viewer()
assert viewer.configure(
offscreen=1,
width=width,
height=height,
backend=get_backend(backend) if backend else ngl.BACKEND_AUTO,
samples=self._samples,
clear_color=self._clear_color,
capture_buffer=capture_buffer) == 0
timescale = duration / float(self._nb_keyframes)
if self._scene_wrap:
scene = self._scene_wrap(scene)
if self._exercise_dot:
assert scene.dot()
if self._exercise_serialization:
scene_str = scene.serialize()
viewer.set_scene_from_string(scene_str)
else:
viewer.set_scene(scene)
for t_id in range(self._nb_keyframes):
if self._keyframes_callback:
self._keyframes_callback(t_id)
viewer.draw(t_id * timescale)
yield (width, height, capture_buffer)
if not self._exercise_serialization and self._exercise_dot:
scene.dot()
def _set_scene(self, cfg):
if cfg is None:
self._pause()
self._scene = None
self._viewer.set_scene(None)
return False
self._scene = cfg['scene']
self._framerate = cfg['framerate']
self._duration = cfg['duration']
self._clear_color = cfg['clear_color']
self._aspect_ratio = cfg['aspect_ratio']
if self._samples != cfg['samples'] or self._backend != cfg['backend']:
self._samples = cfg['samples']
self._backend = cfg['backend']
self._viewer = ngl.Viewer()
self._viewer.set_scene_from_string(self._scene)
self._configure_viewer()
self._clock.configure(self._framerate, self._duration)
self.onSceneMetadata.emit({'framerate': self._framerate, 'duration': self._duration})
return False
def __init__(self, window, width, height, config):
super(Player, self).__init__()
self._mutex = QtCore.QMutex()
self._cond = QtCore.QWaitCondition()
self._window = window
self._width = width
self._height = height
self._scene = None
self._framerate = config.get('framerate')
self._duration = 0.0
self._clear_color = config.get('clear_color')
self._aspect_ratio = config.get('aspect_ratio')
self._samples = config.get('samples')
self._backend = config.get('backend')
self._events = []
self._wait_first_frame = True
self._clock = Clock(self._framerate, self._duration)
self._viewer = ngl.Viewer()
self._configure_viewer()
def _export(self, filename, width, height, extra_enc_args=None):
fd_r, fd_w = os.pipe()
cfg = self._get_scene_func()
if not cfg:
self.failed.emit()
return False
fps = cfg['framerate']
duration = cfg['duration']
samples = cfg['samples']
cmd = [
'ffmpeg', '-r',
'%d/%d' % fps, '-nostats', '-nostdin', '-f', 'rawvideo',
'-video_size',
'%dx%d' % (width, height), '-pixel_format', 'rgba', '-i',
'pipe:%d' % fd_r
]
if extra_enc_args:
cmd += extra_enc_args
cmd += ['-y', filename]
def close_unused_child_fd():
os.close(fd_w)
def close_unused_parent_fd():
os.close(fd_r)
reader = subprocess.Popen(cmd,
preexec_fn=close_unused_child_fd,
close_fds=False)
close_unused_parent_fd()
capture_buffer = bytearray(width * height * 4)
# node.gl context
ngl_viewer = ngl.Viewer()
ngl_viewer.configure(
platform=ngl.PLATFORM_AUTO,
backend=get_backend(cfg['backend']),
offscreen=1,
width=width,
height=height,
viewport=get_viewport(width, height, cfg['aspect_ratio']),
samples=samples,
clear_color=cfg['clear_color'],
capture_buffer=capture_buffer,
)
ngl_viewer.set_scene_from_string(cfg['scene'])
if self._time is not None:
ngl_viewer.draw(self._time)
os.write(fd_w, capture_buffer)
self.progressed.emit(100)
else:
# Draw every frame
nb_frame = int(duration * fps[0] / fps[1])
for i in range(nb_frame):
if self._cancelled:
break
time = i * fps[1] / float(fps[0])
ngl_viewer.draw(time)
os.write(fd_w, capture_buffer)
self.progressed.emit(i * 100 / nb_frame)
self.progressed.emit(100)
os.close(fd_w)
reader.wait()
return True
def api_backend():
viewer = ngl.Viewer()
assert viewer.configure(backend=0x1234) < 0
del viewer
def _set_backend(self, backend):
self._backend = backend
self._viewer = ngl.Viewer()
self._configure_viewer()
return False
def _set_samples(self, samples):
self._samples = samples
self._viewer = ngl.Viewer()
self._configure_viewer()
return False
