def quaternion(cfg):
"""Animated quaternion used to rotate a plane"""
cfg.duration = 10.0
step = cfg.duration / 5.0
x = math.sqrt(0.5)
quat_animkf = [
ngl.AnimKeyFrameQuat(0 * step, (0, 0, 0, 1)),
ngl.AnimKeyFrameQuat(1 * step, (0, 0, -x, x)),
ngl.AnimKeyFrameQuat(2 * step, (0, 1, 0, 0)),
ngl.AnimKeyFrameQuat(3 * step, (1, 0, 0, 0)),
ngl.AnimKeyFrameQuat(4 * step, (x, 0, 0, x)),
ngl.AnimKeyFrameQuat(5 * step, (0, 0, 0, 1)),
]
quat = ngl.AnimatedQuat(quat_animkf, as_mat4=True)
q = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0))
m = ngl.Media(cfg.medias[0].filename)
t = ngl.Texture2D(data_src=m)
p = ngl.Program(vertex=cfg.get_vert("uniform-mat4"),
fragment=cfg.get_frag("texture"))
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.update_vert_resources(transformation_matrix=quat)
camera = ngl.Camera(render)
camera.set_eye(0.0, 0.0, 4.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 _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 quaternion(cfg):
'''Animated quaternion used to rotate a plane'''
cfg.duration = 10.
step = cfg.duration / 5.
x = math.sqrt(0.5)
quat_animkf = [
ngl.AnimKeyFrameQuat(0 * step, (0, 0, 0, 1)),
ngl.AnimKeyFrameQuat(1 * step, (0, 0,-x, x)),
ngl.AnimKeyFrameQuat(2 * step, (0, 1, 0, 0)),
ngl.AnimKeyFrameQuat(3 * step, (1, 0, 0, 0)),
ngl.AnimKeyFrameQuat(4 * step, (x, 0, 0, x)),
ngl.AnimKeyFrameQuat(5 * step, (0, 0, 0, 1)),
]
quat = ngl.AnimatedQuat(quat_animkf, as_mat4=True)
q = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0))
m = ngl.Media(cfg.medias[0].filename)
t = ngl.Texture2D(data_src=m)
p = ngl.Program(vertex=cfg.get_vert('uniform-mat4'))
render = ngl.Render(q, p)
render.update_textures(tex0=t)
render.update_uniforms(transformation_matrix=quat)
camera = ngl.Camera(render)
camera.set_eye(0.0, 0.0, 4.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 py_bindings_allow_node():
c = ngl.Camera(eye=(0, 1, 0))
assert c.set_eye(ngl.EvalVec3()) == 0
assert c.set_eye(1, 0, 0) == 0
c = ngl.Camera(eye=ngl.NoiseVec3())
assert c.set_eye(1, 0, 0) == 0
assert c.set_eye(ngl.UniformVec3()) == 0
r = ngl.Rotate(angle=30)
assert r.set_angle(ngl.NoiseFloat()) == 0
assert r.set_angle(-45) == 0
r = ngl.Rotate(angle=ngl.EvalFloat())
assert r.set_angle(90) == 0
assert r.set_angle(ngl.UniformFloat()) == 0
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 animated_camera(cfg, rotate=True):
'''Animated camera around a scene'''
g = ngl.Group()
q = ngl.Quad((-0.5, -0.5, 0), (1, 0, 0), (0, 1, 0))
m = ngl.Media(cfg.medias[0].filename)
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())
node = ngl.Render(q, program)
node.update_frag_resources(tex0=t)
g.add_children(node)
translate = ngl.Translate(node, vector=(-0.6, 0.8, -1))
g.add_children(translate)
translate = ngl.Translate(node, vector=(0.6, 0.8, -1))
g.add_children(translate)
translate = ngl.Translate(node, vector=(-0.6, -0.5, -1))
g.add_children(translate)
translate = ngl.Translate(node, vector=(0.6, -0.5, -1))
g.add_children(translate)
g = ngl.GraphicConfig(g, depth_test=True)
camera = ngl.Camera(g)
camera.set_eye(0, 0, 2)
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(0.1, 10.0)
tr_animkf = [
ngl.AnimKeyFrameVec3(0, (0.0, 0.0, 0.0)),
ngl.AnimKeyFrameVec3(10, (0.0, 0.0, 3.0), 'exp_out')
]
node = ngl.Translate(ngl.Identity(), anim=ngl.AnimatedVec3(tr_animkf))
if rotate:
rot_animkf = [
ngl.AnimKeyFrameFloat(0, 0),
ngl.AnimKeyFrameFloat(cfg.duration, 360, 'exp_out')
]
node = ngl.Rotate(node,
axis=(0, 1, 0),
anim=ngl.AnimatedFloat(rot_animkf))
camera.set_eye_transform(node)
fov_animkf = [
ngl.AnimKeyFrameFloat(0.5, 60.0),
ngl.AnimKeyFrameFloat(cfg.duration, 45.0, 'exp_out')
]
camera.set_fov_anim(ngl.AnimatedFloat(fov_animkf))
return camera
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 stl(cfg, stl=None, scale=0.8):
"""Load and display a sphere generated with OpenSCAD"""
if stl is None:
# generated with: echo 'sphere($fn=15);'>sphere.scad; openscad sphere.scad -o sphere.stl
stl = op.join(op.dirname(__file__), "data", "sphere.stl")
normals_data = array.array("f")
vertices_data = array.array("f")
solid_label = None
normal = None
with open(stl) as fp:
for line in fp.readlines():
line = line.strip()
if line.startswith("solid"):
solid_label = line.split(None, 1)[1]
elif line.startswith("facet normal"):
_, _, normal = line.split(None, 2)
normal = [float(f) for f in normal.split()]
elif normal and line.startswith("vertex"):
_, vertex = line.split(None, 1)
vertex = [float(f) for f in vertex.split()]
normals_data.extend(normal)
vertices_data.extend(vertex)
vertices = ngl.BufferVec3(data=vertices_data)
normals = ngl.BufferVec3(data=normals_data)
g = ngl.Geometry(vertices=vertices, normals=normals)
p = ngl.Program(vertex=cfg.get_vert("colored-normals"),
fragment=cfg.get_frag("colored-normals"))
p.update_vert_out_vars(var_normal=ngl.IOVec3(),
var_uvcoord=ngl.IOVec2(),
var_tex0_coord=ngl.IOVec2())
solid = ngl.Render(g, p, label=solid_label)
solid = ngl.GraphicConfig(solid, depth_test=True)
solid = ngl.Scale(solid, [scale] * 3)
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)]
solid = ngl.Rotate(solid, axis=axis, angle=rot_animkf)
camera = ngl.Camera(solid)
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 transform_animated_camera(cfg):
cfg.duration = 5.
g = ngl.Group()
elems = (
('red', None),
('yellow', (-0.6, 0.8, -1)),
('green', (0.6, 0.8, -1)),
('cyan', (-0.6, -0.5, -1)),
('magenta', (0.6, -0.5, -1)),
)
quad = ngl.Quad((-0.5, -0.5, 0), (1, 0, 0), (0, 1, 0))
prog = ngl.Program(vertex=cfg.get_vert('color'),
fragment=cfg.get_frag('color'))
for color, vector in elems:
node = ngl.Render(quad, prog)
node.update_uniforms(color=ngl.UniformVec4(value=COLORS[color]))
if vector:
node = ngl.Translate(node, vector=vector)
g.add_children(node)
g = ngl.GraphicConfig(g, depth_test=True)
camera = ngl.Camera(g)
camera.set_eye(0, 0, 2)
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(0.1, 10.0)
tr_animkf = [
ngl.AnimKeyFrameVec3(0, (0.0, 0.0, 0.0)),
ngl.AnimKeyFrameVec3(cfg.duration, (0.0, 0.0, 3.0))
]
eye_transform = ngl.Translate(ngl.Identity(),
anim=ngl.AnimatedVec3(tr_animkf))
rot_animkf = [
ngl.AnimKeyFrameFloat(0, 0),
ngl.AnimKeyFrameFloat(cfg.duration, 360)
]
eye_transform = ngl.Rotate(eye_transform,
axis=(0, 1, 0),
anim=ngl.AnimatedFloat(rot_animkf))
camera.set_eye_transform(eye_transform)
fov_animkf = [
ngl.AnimKeyFrameFloat(0.5, 60.0),
ngl.AnimKeyFrameFloat(cfg.duration, 45.0)
]
camera.set_fov_anim(ngl.AnimatedFloat(fov_animkf))
return camera
def animated_camera(cfg, rotate=True):
"""Animated camera around a scene"""
g = ngl.Group()
q = ngl.Quad((-0.5, -0.5, 0), (1, 0, 0), (0, 1, 0))
m = ngl.Media(cfg.medias[0].filename)
t = ngl.Texture2D(data_src=m)
node = ngl.RenderTexture(t, geometry=q)
g.add_children(node)
translate = ngl.Translate(node, vector=(-0.6, 0.8, -1))
g.add_children(translate)
translate = ngl.Translate(node, vector=(0.6, 0.8, -1))
g.add_children(translate)
translate = ngl.Translate(node, vector=(-0.6, -0.5, -1))
g.add_children(translate)
translate = ngl.Translate(node, vector=(0.6, -0.5, -1))
g.add_children(translate)
g = ngl.GraphicConfig(g, depth_test=True)
camera = ngl.Camera(g)
camera.set_eye(0, 0, 2)
camera.set_center(0.0, 0.0, 0.0)
camera.set_up(0.0, 1.0, 0.0)
camera.set_clipping(0.1, 10.0)
tr_animkf = [
ngl.AnimKeyFrameVec3(0, (0.0, 0.0, 0.0)),
ngl.AnimKeyFrameVec3(10, (0.0, 0.0, 3.0), "exp_out")
]
node = ngl.Translate(ngl.Identity(), vector=ngl.AnimatedVec3(tr_animkf))
if rotate:
rot_animkf = [
ngl.AnimKeyFrameFloat(0, 0),
ngl.AnimKeyFrameFloat(cfg.duration, 360, "exp_out")
]
node = ngl.Rotate(node,
axis=(0, 1, 0),
angle=ngl.AnimatedFloat(rot_animkf))
camera.set_eye_transform(node)
perspective_animkf = [
ngl.AnimKeyFrameVec2(0.5, (60.0, cfg.aspect_ratio_float)),
ngl.AnimKeyFrameVec2(cfg.duration, (45.0, cfg.aspect_ratio_float),
"exp_out"),
]
camera.set_perspective(ngl.AnimatedVec2(perspective_animkf))
return camera
def transform_eye_camera(cfg):
cfg.duration = 3.0
cfg.aspect_ratio = (1, 1)
node = ngl.RenderGradient4(geometry=ngl.Circle(radius=0.7, npoints=128))
animkf = [
ngl.AnimKeyFrameVec3(0, (0, -0.5, 0)),
ngl.AnimKeyFrameVec3(cfg.duration / 2, (0, 1, 0)),
ngl.AnimKeyFrameVec3(cfg.duration, (0, -0.5, 0)),
]
return ngl.Camera(node, eye=ngl.AnimatedVec3(animkf))
def transform_animated_camera(cfg):
cfg.duration = 5.0
g = ngl.Group()
elems = (
# fmt: off
(COLORS.red, None),
(COLORS.yellow, (-0.6, 0.8, -1)),
(COLORS.green, (0.6, 0.8, -1)),
(COLORS.cyan, (-0.6, -0.5, -1)),
(COLORS.magenta, (0.6, -0.5, -1)),
# fmt: on
)
quad = ngl.Quad((-0.5, -0.5, 0), (1, 0, 0), (0, 1, 0))
for color, vector in elems:
node = ngl.RenderColor(color, geometry=quad)
if vector:
node = ngl.Translate(node, vector=vector)
g.add_children(node)
g = ngl.GraphicConfig(g, depth_test=True)
camera = ngl.Camera(g)
camera.set_eye(0, 0, 2)
camera.set_center(0.0, 0.0, 0.0)
camera.set_up(0.0, 1.0, 0.0)
camera.set_clipping(0.1, 10.0)
tr_animkf = [
ngl.AnimKeyFrameVec3(0, (0.0, 0.0, 0.0)),
ngl.AnimKeyFrameVec3(cfg.duration, (0.0, 0.0, 3.0))
]
eye_transform = ngl.Translate(ngl.Identity(),
vector=ngl.AnimatedVec3(tr_animkf))
rot_animkf = [
ngl.AnimKeyFrameFloat(0, 0),
ngl.AnimKeyFrameFloat(cfg.duration, 360)
]
eye_transform = ngl.Rotate(eye_transform,
axis=(0, 1, 0),
angle=ngl.AnimatedFloat(rot_animkf))
camera.set_eye_transform(eye_transform)
perspective_animkf = [
ngl.AnimKeyFrameVec2(0.5, (60.0, cfg.aspect_ratio_float)),
ngl.AnimKeyFrameVec2(cfg.duration, (45.0, cfg.aspect_ratio_float)),
]
camera.set_perspective(ngl.AnimatedVec2(perspective_animkf))
return camera
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 query_inplace(**idict):
'''
Run the query in-place.
'''
module_pkgname = idict['pkg']
module_is_script = module_pkgname.endswith('.py')
# Start tracking the imported modules and opened files
ftrack = FileTracker()
ftrack.start_hooking()
odict = {}
if idict['query'] == 'scene':
# Get module.func
module_name, scene_name = idict['scene']
if module_is_script:
module = _load_script(module_pkgname)
else:
import_name = '%s.%s' % (module_pkgname, module_name)
module = importlib.import_module(import_name)
func = getattr(module, scene_name)
# Call user constructing function
odict = func(idict, **idict.get('extra_args', {}))
scene = odict['scene']
del odict['scene']
scene.set_label(scene_name)
# Make extra adjustments to the scene according to user options
if idict.get('enable_hud'):
fr = odict['framerate']
measure_window = fr[0] / (4 * fr[1]) # 1/4-second measurement window
hud = ngl.HUD(scene,
measure_window=measure_window,
bg_color=(0.0, 0.0, 0.0, 0.8),
aspect_ratio=odict['aspect_ratio'])
q = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0))
t = ngl.Texture2D(data_src=hud)
render = ngl.Render(q)
render.update_textures(tex0=t)
render = ngl.GraphicConfig(render, 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(hud, render)
scene = g
# Pipe mode for data export requires a Camera
if 'pipe' in idict:
pipe_fd, pipe_w, pipe_h = idict['pipe']
camera = scene if isinstance(scene, ngl.Camera) else ngl.Camera(scene)
camera.set_pipe_fd(pipe_fd)
camera.set_pipe_width(pipe_w)
camera.set_pipe_height(pipe_h)
scene = camera
# Prepare output data
odict['scene'] = scene.dot() if idict.get('fmt') == 'dot' else scene.serialize()
elif idict['query'] == 'list':
scripts = []
# Import the script, or the package and its sub-modules
if module_is_script:
module_pkgname = op.realpath(module_pkgname)
module = _load_script(module_pkgname)
scripts.append((module.__name__, module))
else:
module = importlib.import_module(module_pkgname)
for submod in pkgutil.iter_modules(module.__path__):
module_finder, module_name, ispkg = submod
if ispkg:
continue
script = importlib.import_module('.' + module_name, module_pkgname)
scripts.append((module_name, script))
# Find all the scenes
scenes = []
for module_name, script in scripts:
all_funcs = inspect.getmembers(script, inspect.isfunction)
sub_scenes = []
for func in all_funcs:
scene_name, func_wrapper = func
if not hasattr(func_wrapper, 'iam_a_ngl_scene_func'):
continue
sub_scenes.append((scene_name, func_wrapper.__doc__, func_wrapper.widgets_specs))
if sub_scenes:
scenes.append((module_name, sub_scenes))
# Prepare output data
odict['scenes'] = scenes
# End of file and modules tracking
ftrack.end_hooking()
odict['filelist'] = ftrack.filelist
if module_is_script:
odict['filelist'].update([module_pkgname])
return odict
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")
vert_data = cfg.get_vert("texture")
frag_data = cfg.get_frag("tex-tint")
program = ngl.Program(vertex=vert_data, fragment=frag_data)
program.update_vert_out_vars(var_uvcoord=ngl.IOVec2(),
var_tex0_coord=ngl.IOVec2())
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 = tuple(int(i == x) for x in range(3))
cube = ngl.Rotate(cube, axis=axis, angle=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("auto_depth")
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))
render = ngl.RenderTexture(texture, geometry=quad)
group.add_children(rtt, render)
quad = ngl.Quad((0.0, 0.0, 0), (1, 0, 0), (0, 1, 0))
render = ngl.RenderTexture(depth_texture, geometry=quad)
group.add_children(rtt, render)
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 blending_and_stencil(cfg):
'''Scene using blending and stencil graphic features'''
cfg.duration = 5
random.seed(0)
fragment = cfg.get_frag('color')
program = ngl.Program(fragment=fragment)
circle = ngl.Circle(npoints=256)
cloud_color = ngl.UniformVec4(value=(1, 1, 1, 0.4))
main_group = ngl.Group()
quad = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0))
render = ngl.Render(quad, program, label='sky')
render.update_uniforms(color=ngl.UniformVec4(value=(0.2, 0.6, 1, 1)))
config = ngl.GraphicConfig(render,
stencil_test=True,
stencil_write_mask=0xFF,
stencil_func='always',
stencil_ref=1,
stencil_read_mask=0xFF,
stencil_fail='replace',
stencil_depth_fail='replace',
stencil_depth_pass='******')
main_group.add_children(config)
render = ngl.Render(circle, program, label='sun')
render.update_uniforms(color=ngl.UniformVec4(value=(1, 0.8, 0, 1)))
scale = ngl.Scale(render, (0.15, 0.15, 0.0))
translate = ngl.Translate(scale, (0.4, 0.3, 0))
main_group.add_children(translate)
cloud_group = ngl.Group(label='clouds')
centers = [
(-1.0, 0.85, 0.4),
(-0.5, 2.0, 1.0),
( 0, 0.85, 0.4),
( 1.0, 1.55, 0.8),
( 0.6, 0.65, 0.075),
( 0.5, 1.80, 1.25),
]
for center in centers:
render = ngl.Render(circle, program)
render.update_uniforms(color=cloud_color)
factor = random.random() * 0.4 + center[2]
keyframe = cfg.duration * (random.random() * 0.4 + 0.2)
animkf = (ngl.AnimKeyFrameVec3(0, (factor, factor, 0)),
ngl.AnimKeyFrameVec3(keyframe, (factor + 0.1, factor + 0.1, 0)),
ngl.AnimKeyFrameVec3(cfg.duration, (factor, factor, 0)))
scale = ngl.Scale(render, anim=ngl.AnimatedVec3(animkf))
translate = ngl.Translate(scale, vector=(center[0], center[1], 0))
cloud_group.add_children(translate)
config = ngl.GraphicConfig(cloud_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',
stencil_test=True,
stencil_write_mask=0x0,
stencil_func='equal',
stencil_ref=1,
stencil_read_mask=0xFF,
stencil_fail='keep',
stencil_depth_fail='keep',
stencil_depth_pass='******')
main_group.add_children(config)
camera = ngl.Camera(main_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_orthographic(-cfg.aspect_ratio_float, cfg.aspect_ratio_float, -1.0, 1.0)
camera.set_clipping(1.0, 10.0)
return camera
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 blending_and_stencil(cfg):
"""Scene using blending and stencil graphic features"""
cfg.duration = 5
vertex = cfg.get_vert("color")
fragment = cfg.get_frag("color")
program = ngl.Program(vertex=vertex, fragment=fragment)
circle = ngl.Circle(npoints=256)
cloud_color = ngl.UniformVec3(value=(1, 1, 1))
cloud_opacity = ngl.UniformFloat(0.4)
main_group = ngl.Group()
render = ngl.RenderColor(color=(0.2, 0.6, 1), label="sky")
config = ngl.GraphicConfig(
render,
stencil_test=True,
stencil_write_mask=0xFF,
stencil_func="always",
stencil_ref=1,
stencil_read_mask=0xFF,
stencil_fail="replace",
stencil_depth_fail="replace",
stencil_depth_pass="******",
)
main_group.add_children(config)
render = ngl.RenderColor(color=(1, 0.8, 0), geometry=circle, label="sun")
scale = ngl.Scale(render, (0.15, 0.15, 0.0))
translate = ngl.Translate(scale, (0.4, 0.3, 0))
main_group.add_children(translate)
cloud_group = ngl.Group(label="clouds")
centers = [
(-1.0, 0.85, 0.4),
(-0.5, 2.0, 1.0),
(0, 0.85, 0.4),
(1.0, 1.55, 0.8),
(0.6, 0.65, 0.075),
(0.5, 1.80, 1.25),
]
for center in centers:
render = ngl.Render(circle, program, blending="src_over")
render.update_frag_resources(color=cloud_color, opacity=cloud_opacity)
factor = cfg.rng.random() * 0.4 + center[2]
keyframe = cfg.duration * (cfg.rng.random() * 0.4 + 0.2)
animkf = (
ngl.AnimKeyFrameVec3(0, (factor, factor, 0)),
ngl.AnimKeyFrameVec3(keyframe, (factor + 0.1, factor + 0.1, 0)),
ngl.AnimKeyFrameVec3(cfg.duration, (factor, factor, 0)),
)
scale = ngl.Scale(render, factors=ngl.AnimatedVec3(animkf))
translate = ngl.Translate(scale, vector=(center[0], center[1], 0))
cloud_group.add_children(translate)
config = ngl.GraphicConfig(
cloud_group,
stencil_test=True,
stencil_write_mask=0x0,
stencil_func="equal",
stencil_ref=1,
stencil_read_mask=0xFF,
stencil_fail="keep",
stencil_depth_fail="keep",
stencil_depth_pass="******",
)
main_group.add_children(config)
camera = ngl.Camera(main_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_orthographic(-cfg.aspect_ratio_float, cfg.aspect_ratio_float,
-1.0, 1.0)
camera.set_clipping(1.0, 10.0)
return camera
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)
