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 _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'),
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 triangle(cfg, size=4 / 3):
"""Rotating triangle with edge coloring specified in a vertex attribute"""
cfg.duration = 3.0
cfg.aspect_ratio = (1, 1)
colors_data = array.array("f",
[0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0])
colors_buffer = ngl.BufferVec3(data=colors_data)
p0, p1, p2 = equilateral_triangle_coords(size)
triangle = ngl.Triangle(p0, p1, p2)
p = ngl.Program(fragment=cfg.get_frag("color"),
vertex=cfg.get_vert("triangle"))
p.update_vert_out_vars(color=ngl.IOVec3())
node = ngl.Render(triangle, p)
node.update_attributes(edge_color=colors_buffer)
node.update_frag_resources(opacity=ngl.UniformFloat(1))
animkf = [
ngl.AnimKeyFrameFloat(0, 0),
ngl.AnimKeyFrameFloat(cfg.duration / 3.0, -360 / 3.0, "exp_in_out"),
ngl.AnimKeyFrameFloat(2 * cfg.duration / 3.0, -2 * 360 / 3.0,
"exp_in_out"),
ngl.AnimKeyFrameFloat(cfg.duration, -360, "exp_in_out"),
]
node = ngl.Rotate(node, angle=ngl.AnimatedFloat(animkf))
return node
def _get_texture_cubemap_from_mrt_scene(cfg, samples=0):
program = ngl.Program(vertex=_RENDER_TO_CUBEMAP_VERT,
fragment=_RENDER_TO_CUBEMAP_FRAG,
nb_frag_output=6)
program.update_vert_out_vars(var_uvcoord=ngl.IOVec3())
quad = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0))
render = ngl.Render(quad, program)
cube = ngl.TextureCube(size=64, min_filter="linear", mag_filter="linear")
rtt = ngl.RenderToTexture(render, [cube], samples=samples)
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)
return ngl.Group(children=(rtt, render))
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 py_bindings_no_param():
"""Nodes with no param (but still inherit the common parameters)"""
# Identity directly inherits from the common node
ident = ngl.Identity(label="id")
assert ident.set_label("ID") == 0
# IOVars have an intermediate inheritance before the common node
iovar = ngl.IOVec3(label="io")
assert iovar.set_label("IO") == 0
def texture_cubemap(cfg):
n = 64
p = n * n
cb_data = array.array('B', (255, 0, 0, 255) * p + (0, 255, 0, 255) * p +
(0, 0, 255, 255) * p + (255, 255, 0, 255) * p +
(0, 255, 255, 255) * p + (255, 0, 255, 255) * p)
cb_buffer = ngl.BufferUBVec4(data=cb_data)
cube = ngl.TextureCube(size=n,
min_filter="linear",
mag_filter="linear",
data_src=cb_buffer)
program = ngl.Program(vertex=_RENDER_CUBEMAP_VERT,
fragment=_RENDER_CUBEMAP_FRAG)
program.update_vert_out_vars(var_uvcoord=ngl.IOVec3())
quad = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0))
render = ngl.Render(quad, program)
render.update_frag_resources(tex0=cube)
return render
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(cfg, set_normals=False, set_indices=False):
# Fake cube (3 faces only) obtained from:
# echo 'cube();'>x.scad; openscad x.scad -o x.stl
vertices = array.array('f', [x - 0.5 for x in [
1,1,0, 0,1,1, 1,1,1,
0,1,1, 1,1,0, 0,1,0,
0,0,0, 0,1,1, 0,1,0,
0,1,1, 0,0,0, 0,0,1,
0,1,1, 1,0,1, 1,1,1,
1,0,1, 0,1,1, 0,0,1,
]])
normals = array.array('f', [
0,1,0, 0,1,0, 0,1,0,
0,1,0, 0,1,0, 0,1,0,
-1,0,0, -1,0,0, -1,0,0,
-1,0,0, -1,0,0, -1,0,0,
0,0,1, 0,0,1, 0,0,1,
0,0,1, 0,0,1, 0,0,1,
])
vertices_buffer = ngl.BufferVec3(data=vertices)
normals_buffer = ngl.BufferVec3(data=normals)
cfg.aspect_ratio = (1, 1)
geometry = ngl.Geometry(vertices=vertices_buffer)
if set_normals:
geometry.set_normals(normals_buffer)
prog = ngl.Program(vertex=cfg.get_vert('colored-normals'), fragment=cfg.get_frag('colored-normals'))
prog.update_vert_out_vars(var_normal=ngl.IOVec3())
render = ngl.Render(geometry, prog)
else:
render = _render_shape(cfg, geometry, COLORS['magenta'])
if set_indices:
indices = array.array('H', list(range(3 * 6)))
indices_buffer = ngl.BufferUShort(data=indices)
geometry.set_indices(indices_buffer)
return ngl.Rotate(render, 45, axis=(1, 1, 1))
def _shape_geometry(cfg, set_normals=False, set_indices=False):
# Fake cube (3 faces only) obtained from:
# echo 'cube();'>x.scad; openscad x.scad -o x.stl
vertices = array.array(
"f",
[
x - 0.5 for x in [
# fmt: off
1,
1,
0,
0,
1,
1,
1,
1,
1,
0,
1,
1,
1,
1,
0,
0,
1,
0,
0,
0,
0,
0,
1,
1,
0,
1,
0,
0,
1,
1,
0,
0,
0,
0,
0,
1,
0,
1,
1,
1,
0,
1,
1,
1,
1,
1,
0,
1,
0,
1,
1,
0,
0,
1,
# fmt: on
]
],
)
normals = array.array(
"f",
[
# fmt: off
0,
1,
0,
0,
1,
0,
0,
1,
0,
0,
1,
0,
0,
1,
0,
0,
1,
0,
-1,
0,
0,
-1,
0,
0,
-1,
0,
0,
-1,
0,
0,
-1,
0,
0,
-1,
0,
0,
0,
0,
1,
0,
0,
1,
0,
0,
1,
0,
0,
1,
0,
0,
1,
0,
0,
1,
# fmt: on
],
)
vertices_buffer = ngl.BufferVec3(data=vertices)
normals_buffer = ngl.BufferVec3(data=normals)
cfg.aspect_ratio = (1, 1)
geometry = ngl.Geometry(vertices=vertices_buffer)
if set_normals:
geometry.set_normals(normals_buffer)
prog = ngl.Program(vertex=cfg.get_vert("colored-normals"),
fragment=cfg.get_frag("colored-normals"))
prog.update_vert_out_vars(var_normal=ngl.IOVec3())
render = ngl.Render(geometry, prog)
else:
prog = ngl.Program(vertex=cfg.get_vert("color"),
fragment=cfg.get_frag("color"))
render = ngl.Render(geometry, prog)
render.update_frag_resources(
color=ngl.UniformVec3(value=COLORS.magenta),
opacity=ngl.UniformFloat(1))
if set_indices:
indices = array.array("H", list(range(3 * 6)))
indices_buffer = ngl.BufferUShort(data=indices)
geometry.set_indices(indices_buffer)
return ngl.Rotate(render, 45, axis=(1, 1, 1))
