def gradient_eval(cfg, mode="ramp", c0=(1, 0.5, 0.5), c1=(0.5, 1, 0.5)): """Animate a gradient and objects using CPU evaluation""" pos_res = dict(t=ngl.Time()) pos0_x = ngl.EvalFloat("sin( 0.307*t - 0.190)", resources=pos_res) pos0_y = ngl.EvalFloat("sin( 0.703*t - 0.957)", resources=pos_res) pos1_x = ngl.EvalFloat("sin(-0.236*t + 0.218)", resources=pos_res) pos1_y = ngl.EvalFloat("sin(-0.851*t - 0.904)", resources=pos_res) trf0 = ngl.EvalVec3("x", "y", "0", resources=dict(x=pos0_x, y=pos0_y)) trf1 = ngl.EvalVec3("x", "y", "0", resources=dict(x=pos1_x, y=pos1_y)) geom = ngl.Circle(radius=0.02, npoints=64) p0 = ngl.RenderColor(color=(1 - c0[0], 1 - c0[1], 1 - c0[2]), geometry=geom) p1 = ngl.RenderColor(color=(1 - c1[0], 1 - c1[1], 1 - c1[2]), geometry=geom) p0 = ngl.Scale(p0, factors=(1 / cfg.aspect_ratio_float, 1, 1)) p1 = ngl.Scale(p1, factors=(1 / cfg.aspect_ratio_float, 1, 1)) p0 = ngl.Translate(p0, vector=trf0) p1 = ngl.Translate(p1, vector=trf1) pos0 = ngl.EvalVec2("x/2+.5", ".5-y/2", resources=dict(x=pos0_x, y=pos0_y)) pos1 = ngl.EvalVec2("x/2+.5", ".5-y/2", resources=dict(x=pos1_x, y=pos1_y)) grad = ngl.RenderGradient(pos0=pos0, pos1=pos1, mode=mode, color0=c0, color1=c1) return ngl.Group(children=(grad, p0, p1))
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_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 _rtt_load_attachment(): background = ngl.RenderColor(COLORS.white) render = ngl.RenderColor(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)) foreground = ngl.RenderTexture(texture, geometry=quad) return ngl.Group(children=(background, rtt, rtt_noop, foreground))
def _path_scene(cfg, path, points=None, controls=None, easing="linear"): cfg.aspect_ratio = (1, 1) anim_kf = [ ngl.AnimKeyFrameFloat(0, 0), ngl.AnimKeyFrameFloat(cfg.duration, 1, easing), ] geom = ngl.Circle(radius=0.03, npoints=32) shape = ngl.RenderColor(COLORS.orange, geometry=geom) moving_shape = ngl.Translate(shape, vector=ngl.AnimatedPath(anim_kf, path)) objects = [] if points: debug_points = {f"P{i}": p[:2] for i, p in enumerate(points)} objects.append(get_debug_points(cfg, debug_points)) if controls: debug_controls = {f"C{i}": p[:2] for i, p in enumerate(controls)} objects.append(get_debug_points(cfg, debug_controls, color=COLORS.cyan)) objects.append(moving_shape) return ngl.Group(children=objects)
def buffer_dove(cfg, bgcolor1=(0.6, 0, 0), bgcolor2=(0.8, 0.8, 0), bilinear_filtering=True): """Blending of a Render using a Buffer as data source""" cfg.duration = 3.0 # Credits: https://icons8.com/icon/40514/dove # (Raw data is the premultiplied) icon_filename = op.join(op.dirname(__file__), "data", "icons8-dove.raw") cfg.files.append(icon_filename) w, h = (96, 96) cfg.aspect_ratio = (w, h) img_buf = ngl.BufferUBVec4(filename=icon_filename, label="icon raw buffer") img_tex = ngl.Texture2D(data_src=img_buf, width=w, height=h) if bilinear_filtering: img_tex.set_mag_filter("linear") quad = ngl.Quad((-0.5, -0.5, 0.1), (1, 0, 0), (0, 1, 0)) render = ngl.RenderTexture(img_tex, geometry=quad, blending="src_over") shape_bg = ngl.Circle(radius=0.6, npoints=256) color_animkf = [ ngl.AnimKeyFrameColor(0, bgcolor1), ngl.AnimKeyFrameColor(cfg.duration / 2.0, bgcolor2), ngl.AnimKeyFrameColor(cfg.duration, bgcolor1), ] ucolor = ngl.AnimatedColor(color_animkf) render_bg = ngl.RenderColor(ucolor, geometry=shape_bg, label="background") return ngl.Group(children=(render_bg, render))
def _get_random_render(cfg, rng, t0, t1, enable_computes): color = lambda rng: ngl.RenderColor( color=_get_random_animated_color(rng, t0, t1), opacity=_get_random_animated_opacity(rng, t0, t1), geometry=_get_random_geometry(rng), blending="src_over", ) gradient = lambda rng: ngl.RenderGradient( color0=_get_random_animated_color(rng, t0, t1), color1=_get_random_animated_color(rng, t0, t1), opacity0=_get_random_animated_opacity(rng, t0, t1), opacity1=_get_random_animated_opacity(rng, t0, t1), pos0=(rng.random(), rng.random()), pos1=(rng.random(), rng.random()), mode=rng.choice(("ramp", "radial")), geometry=_get_random_geometry(rng), blending="src_over", ) texture = lambda rng: _get_random_rendertexture(cfg, rng) text = lambda rng: _get_random_text(cfg, rng) compute = lambda rng: _get_random_compute(cfg, rng, t0, t1) render_funcs = [ color, gradient, text, texture, ] if enable_computes: render_funcs.append(compute) return rng.choice(render_funcs)(rng)
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 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 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: animkf = [] tscale = 1.0 / float(len(coords) - 1) * cfg.duration for i, xy in enumerate(coords): pos = (xy[0] * 0.5, xy[1] * 0.5, 0) t = i * tscale animkf.append(ngl.AnimKeyFrameVec3(t, pos)) node = ngl.Translate(node, vector=ngl.AnimatedVec3(animkf)) return node
def _get_live_shared_uniform_scene(cfg, color, debug_positions): group = ngl.Group() for i in range(2): quad = ngl.Quad((-1 + i, -1 + i, 0), (1, 0, 0), (0, 1, 0)) render = ngl.RenderColor(color, geometry=quad) group.add_children(render) if debug_positions: group.add_children(get_debug_points(cfg, _SHARED_UNIFORM_CUEPOINTS)) return group
def _get_blending_base_objects(): circle = ngl.Circle(radius=_CIRCLE_RADIUS, npoints=100) positions = _equilateral_triangle_coords(_CIRCLE_RADIUS * 2.0 / 3.0) colored_circles = ngl.Group(label="colored circles") for position, color in zip(positions, _CIRCLES_COLORS): render = ngl.RenderColor(color, geometry=circle) render = ngl.Translate(render, position + (0.0, )) colored_circles.add_children(render) return colored_circles, circle, positions
def shape_diamond_colormask(_): color_write_masks = ("r+g+b+a", "r+g+a", "g+b+a", "r+b+a") geometry = ngl.Circle(npoints=5) render = ngl.RenderColor(COLORS.white, geometry=geometry) scenes = [ ngl.GraphicConfig(render, color_write_mask=cwm) for cwm in color_write_masks ] return autogrid_simple(scenes)
def _block(w, h, color, corner=None): block_width = (w, 0, 0) block_height = (0, h, 0) block_corner = (-w / 2.0, -h / 2.0, 0) if corner is None else corner block_quad = ngl.Quad(corner=block_corner, width=block_width, height=block_height) block_render = ngl.RenderColor(color=color, geometry=block_quad) return block_render
def scene_func(cfg): cfg.duration = 5 color_animkf = [ # Start at t=1 and end 1s earlier so that it tests the underflow # and overflow of the animation ngl.AnimKeyFrameColor(1, c0), ngl.AnimKeyFrameColor(cfg.duration - 1, c1), ] ucolor = ngl.AnimatedColor(color_animkf, space=space) return ngl.RenderColor(ucolor)
def _get_compositing_scene(cfg, op, show_label=False): cfg.aspect_ratio = (1, 1) cfg.duration = 6 # We can not use a circle geometry because the whole areas must be # rasterized for the compositing to work, so instead we build 2 overlapping # quad into which we draw colored circles, offsetted with an animation. # Alternatively, we could use a RTT. quad = ngl.Quad(corner=(-1, -1, 0), width=(2, 0, 0), height=(0, 2, 0)) prog = ngl.Program(vertex=_VERTEX, fragment=_FRAGMENT) prog.update_vert_out_vars(uv=ngl.IOVec2()) A_off_kf = ( ngl.AnimKeyFrameVec2(0, (-1 / 3, 0)), ngl.AnimKeyFrameVec2(cfg.duration / 2, (1 / 3, 0)), ngl.AnimKeyFrameVec2(cfg.duration, (-1 / 3, 0)), ) B_off_kf = ( ngl.AnimKeyFrameVec2(0, (1 / 3, 0)), ngl.AnimKeyFrameVec2(cfg.duration / 2, (-1 / 3, 0)), ngl.AnimKeyFrameVec2(cfg.duration, (1 / 3, 0)), ) A_off = ngl.AnimatedVec2(A_off_kf) B_off = ngl.AnimatedVec2(B_off_kf) A = ngl.Render(quad, prog, label="A") A.update_frag_resources(color=ngl.UniformVec3(value=COLORS.azure), off=A_off) B = ngl.Render(quad, prog, label="B", blending=op) B.update_frag_resources(color=ngl.UniformVec3(value=COLORS.orange), off=B_off) bg = ngl.RenderColor(blending="dst_over") # draw A in current FBO, then draw B with the current operator, and # then result goes over the white background ret = ngl.Group(children=(A, B, bg)) if show_label: label_h = 1 / 4 label_pad = 0.1 label = ngl.Text( op, fg_color=COLORS.black, bg_color=(0.8, 0.8, 0.8), bg_opacity=1, box_corner=(label_pad / 2 - 1, 1 - label_h - label_pad / 2, 0), box_width=(2 - label_pad, 0, 0), box_height=(0, label_h, 0), ) ret.add_children(label) return ret
def _render_quad(cfg, corner=(-1, -1, 0), width=(2, 0, 0), height=(0, 2, 0), color=(1, 1, 1), opacity=1): quad = ngl.Quad(corner, width, height) return ngl.RenderColor(color, opacity=opacity, geometry=quad, blending="src_over")
def texture_scissor(cfg): cfg.aspect_ratio = (1, 1) render = ngl.RenderColor(COLORS.orange) graphic_config = ngl.GraphicConfig(render, scissor_test=True, scissor=(32, 32, 32, 32)) texture = ngl.Texture2D(width=64, height=64) rtt = ngl.RenderToTexture(graphic_config, [texture], clear_color=(0, 0, 0, 1)) render = ngl.RenderTexture(texture) return ngl.Group(children=(rtt, render))
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 texture_clear_and_scissor(cfg): render = ngl.RenderColor(COLORS.white) graphic_config = ngl.GraphicConfig(render, scissor_test=True, scissor=(0, 0, 0, 0), color_write_mask="") texture = ngl.Texture2D(width=64, height=64) rtt = ngl.RenderToTexture(ngl.Identity(), [texture], clear_color=list(COLORS.orange) + [1]) render = ngl.RenderTexture(texture) return ngl.Group(children=(graphic_config, rtt, render))
def _get_userlive_select_func(): # We point on the same underlying render to test the different render paths render = ngl.RenderColor(COLORS.white, opacity=0.5, geometry=ngl.Quad()) below = ngl.Translate(render, vector=(0.5 - 2 / 3, 0.5 - 1 / 3, 0)) above = ngl.Translate(render, vector=(0.5 - 1 / 3, 0.5 - 2 / 3, 0)) # Additive blending (for premultiplied values): lighten gc0 = ngl.GraphicConfig( above, blend=True, blend_src_factor="one", blend_dst_factor="one", blend_src_factor_a="one", blend_dst_factor_a="one", ) # Multiply blending (for premultiplied values): darken gc1 = ngl.GraphicConfig( above, blend=True, blend_src_factor="zero", blend_dst_factor="src_color", blend_src_factor_a="zero", blend_dst_factor_a="src_alpha", ) # Select has 3 branches: simple over blending, additive blending, multiply # blending select = ngl.UserSelect(branches=(above, gc0, gc1)) def keyframes_callback(t_id): # 4 states: the for the 3 blending branches and one extra for nothing # (branch ID overflow). We remain on the each state for 2 frames. select.set_branch((t_id // 2) % 4) @test_fingerprint(nb_keyframes=8, keyframes_callback=keyframes_callback, tolerance=1, exercise_serialization=False) @scene(branch=scene.Range([0, 3])) def scene_func(cfg, branch=0): cfg.aspect_ratio = (1, 1) select.set_branch(branch) return ngl.Group(children=(below, select)) return scene_func
def compare(cfg, scene0, scene1, xsplit): """ Compare two scenes by splitting them vertically. The scene generated by this function relies on the stencil buffer, and thus can not work properly if one of the compared scenes uses it. """ # Fill the stencil buffer with 1's on the left side, and 0's on the right scene_mask = ngl.RenderColor() scene_mask = ngl.Scale(scene_mask, factors=(xsplit, 1, 1), anchor=(-1, 0, 0)) scene_mask = ngl.GraphicConfig( scene_mask, color_write_mask= "", # no need to write the color themselves, only the stencil stencil_test=True, stencil_ref=1, stencil_read_mask=0, stencil_write_mask=0xFF, stencil_fail="replace", stencil_depth_fail="replace", stencil_depth_pass="******", ) # Draw the 1st scene where the stencil is equal to 1 (left) scene0 = ngl.GraphicConfig(scene0, stencil_func="equal") # Draw the 2nd scene where the stencil is not equal to 1 (right) scene1 = ngl.GraphicConfig(scene1, stencil_func="notequal") stencil_test = ngl.GraphicConfig( ngl.Group(children=(scene0, scene1)), stencil_test=True, stencil_ref=1, stencil_read_mask=0xFF, stencil_write_mask=0, stencil_fail="keep", stencil_depth_fail="keep", stencil_depth_pass="******", ) return ngl.Group(children=(scene_mask, stencil_test))
def get_debug_points(cfg, points, radius=0.025, color=COLORS.green, text_size=(0.1, 0.1)): g = ngl.Group(label="Debug circles") circle = ngl.Circle(radius=radius) circle_render = ngl.RenderColor(color, geometry=circle) 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_opacity=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 g
def fibo(cfg, n=8): """Fibonacci with a recursive tree (nodes inherit transforms)""" cfg.duration = 5.0 cfg.aspect_ratio = (1, 1) fib = [0, 1, 1] for i in range(2, n): fib.append(fib[i] + fib[i - 1]) fib = fib[::-1] shift = 1 / 3.0 # XXX: what's the exact math here? shape_scale = 1.0 / ((2.0 - shift) * sum(fib)) orig = (-shift, -shift, 0) g = None root = None for i, x in enumerate(fib[:-1]): w = x * shape_scale gray = 1.0 - i / float(n) color = (gray, gray, gray) q = ngl.Quad(orig, (w, 0, 0), (0, w, 0)) render = ngl.RenderColor(color, geometry=q) new_g = ngl.Group() animkf = [ ngl.AnimKeyFrameFloat(0, 90), ngl.AnimKeyFrameFloat(cfg.duration / 2, -90, "exp_in_out"), ngl.AnimKeyFrameFloat(cfg.duration, 90, "exp_in_out"), ] rot = ngl.Rotate(new_g, anchor=orig, angle=ngl.AnimatedFloat(animkf)) if g: g.add_children(rot) else: root = rot g = new_g new_g.add_children(render) orig = (orig[0] + w, orig[1] + w, 0) assert root is not None return root
def animated_circles(cfg): """Simple cyclic circles animation""" group = ngl.Group() cfg.duration = 5.0 cfg.aspect_ratio = (1, 1) radius = 0.2 n = 10 step = 360.0 / n shape = ngl.Circle(radius=radius, npoints=128) render = ngl.RenderColor(geometry=shape) for i in range(n): mid_time = cfg.duration / 2.0 start_time = mid_time / (i + 2) end_time = cfg.duration - start_time scale_animkf = [ ngl.AnimKeyFrameVec3(start_time, (0, 0, 0)), ngl.AnimKeyFrameVec3(mid_time, (1.0, 1.0, 1.0), "exp_out"), ngl.AnimKeyFrameVec3(end_time, (0, 0, 0), "exp_in"), ] angle = i * step rotate_animkf = [ ngl.AnimKeyFrameFloat(start_time, 0), ngl.AnimKeyFrameFloat(mid_time, angle, "exp_out"), ngl.AnimKeyFrameFloat(end_time, 0, "exp_in"), ] tnode = render tnode = ngl.Scale(tnode, factors=ngl.AnimatedVec3(scale_animkf)) tnode = ngl.Translate(tnode, vector=(1 - radius, 0, 0)) tnode = ngl.Rotate(tnode, angle=ngl.AnimatedFloat(rotate_animkf)) group.add_children(tnode) return group
def shape_geometry_with_renderother(cfg): cfg.aspect_ratio = (1, 1) vertices_data = array.array("f") uvcoords_data = array.array("f") boundaries = ( (-1, 0, 0, 1), (0, 1, 0, 1), (-1, 0, -1, 0), (0, 1, -1, 0), ) for xmin, xmax, ymin, ymax in boundaries: x0, y0 = cfg.rng.uniform(xmin, xmax), cfg.rng.uniform(ymin, ymax) x1, y1 = cfg.rng.uniform(xmin, xmax), cfg.rng.uniform(ymin, ymax) vertices_data.extend((0, 0, 0, x0, y0, 0, x1, y1, 0)) uvcoords_data.extend((0, 0, x0, y0, x1, y1)) geometry = ngl.Geometry( vertices=ngl.BufferVec3(data=vertices_data), uvcoords=ngl.BufferVec2(data=uvcoords_data), topology="triangle_list", ) return ngl.RenderColor(geometry=geometry)
def _render_shape(geometry, color): return ngl.RenderColor(color, geometry=geometry)
def scene_func(_): return ngl.RenderColor(color=ngl.UniformColor(c, space=space))
def _get_scene(geometry=None): return ngl.RenderColor(geometry=ngl.Quad() if geometry is None else geometry)
def _transform_shape(cfg, w=0.75, h=0.45): geometry = ngl.Quad(corner=(-w / 2.0, -h / 2.0, 0), width=(w, 0, 0), height=(0, h, 0)) return ngl.RenderColor(COLORS.rose, geometry=geometry)