Ejemplo n.º 1
0
def texture_mipmap(cfg, show_dbg_points=False):
    cfg.aspect_ratio = (1, 1)
    cuepoints = _get_texture_mipmap_cuepoints()
    black = (0, 0, 0, 255)
    white = (255, 255, 255, 255)
    p = _N // 2
    cb_data = array.array(
        'B',
        ((black + white) * p + (white + black) * p) * p,
    )
    cb_buffer = ngl.BufferUBVec4(data=cb_data)

    texture = ngl.Texture2D(
        width=_N,
        height=_N,
        min_filter='nearest',
        mipmap_filter='linear',
        data_src=cb_buffer,
    )

    program = ngl.Program(vertex=_RENDER_TEXTURE_LOD_VERT,
                          fragment=_RENDER_TEXTURE_LOD_FRAG)
    program.update_vert_out_vars(var_uvcoord=ngl.IOVec2())

    quad = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0))
    render = ngl.Render(quad, program)
    render.update_frag_resources(tex0=texture)

    group = ngl.Group(children=(render, ))
    if show_dbg_points:
        group.add_children(get_debug_points(cfg, cuepoints))

    return group
Ejemplo n.º 2
0
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)
    video = ngl.Media(m0.filename)
    video_tex = ngl.Texture2D(data_src=video)

    prog = ngl.Program(fragment=cfg.get_frag('lut3d'),
                       vertex=cfg.get_vert('lut3d'))
    prog.update_vert_out_vars(var_uvcoord=ngl.IOVec2(),
                              var_tex0_coord=ngl.IOVec2())

    quad = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0))
    render = ngl.Render(quad, prog)
    render.update_frag_resources(tex0=video_tex, lut3d=lut3d_tex)
    render.update_frag_resources(xsplit=ngl.UniformFloat(value=xsplit))

    return render
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 lut3d(cfg, xsplit=0.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)
    video = ngl.Media(m0.filename)
    video_tex = ngl.Texture2D(data_src=video)

    scene_tex = ngl.RenderTexture(video_tex)

    quad = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0))
    prog_lut = ngl.Program(fragment=cfg.get_frag("lut3d"),
                           vertex=cfg.get_vert("lut3d"))
    prog_lut.update_vert_out_vars(var_uvcoord=ngl.IOVec2(),
                                  var_tex0_coord=ngl.IOVec2())
    scene_lut = ngl.Render(quad, prog_lut)
    scene_lut.update_frag_resources(tex0=video_tex, lut3d=lut3d_tex)

    return compare(cfg, scene_tex, scene_lut, xsplit)
Ejemplo n.º 5
0
def texture_mipmap(cfg, show_dbg_points=False):
    cfg.aspect_ratio = (1, 1)
    cuepoints = _get_texture_mipmap_cuepoints()
    black = (0, 0, 0, 255)
    white = (255, 255, 255, 255)
    p = _N // 2
    cb_data = array.array(
        'B',
        ((black + white) * p + (white + black) * p) * p,
    )
    cb_buffer = ngl.BufferUBVec4(data=cb_data)

    texture = ngl.Texture2D(
        width=_N,
        height=_N,
        min_filter='nearest',
        mipmap_filter='linear',
        data_src=cb_buffer,
    )

    shader_version = '300 es' if cfg.backend == 'gles' else '330'
    program = ngl.Program(
        vertex=_RENDER_TEXTURE_LOD_VERT % dict(version=shader_version),
        fragment=_RENDER_TEXTURE_LOD_FRAG % dict(version=shader_version),
    )

    quad = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0))
    render = ngl.Render(quad, program)
    render.update_textures(tex0=texture)

    group = ngl.Group(children=(render, ))
    if show_dbg_points:
        group.add_children(get_debug_points(cfg, cuepoints))

    return group
Ejemplo n.º 6
0
def texture_3d(cfg):
    random.seed(0)
    width, height, depth = 9, 9, 3
    n = width * height
    data = array.array('B')
    for i in random.sample(range(n), n):
        data.extend([i * 255 // n, 0, 0, 255])
    for i in random.sample(range(n), n):
        data.extend([0, i * 255 // n, 0, 255])
    for i in random.sample(range(n), n):
        data.extend([0, 0, i * 255 // n, 255])
    texture_buffer = ngl.BufferUBVec4(data=data)
    texture = ngl.Texture3D(width=width,
                            height=height,
                            depth=depth,
                            data_src=texture_buffer)

    glsl_version = '300 es' if cfg.backend == 'gles' else '330'
    glsl_header = '#version %s\n' % glsl_version
    render_cubemap_vert = glsl_header + _TEXTURE3D_VERT
    render_cubemap_frag = glsl_header + _TEXTURE3D_FRAG

    quad = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0))
    program = ngl.Program(vertex=render_cubemap_vert,
                          fragment=render_cubemap_frag)
    render = ngl.Render(quad, program)
    render.update_textures(tex0=texture)
    return render
Ejemplo n.º 7
0
def buffer_dove(cfg,
                bgcolor1=(.6, 0, 0, 1),
                bgcolor2=(.8, .8, 0, 1),
                bilinear_filtering=True):
    '''Blending of a Render using a Buffer as data source'''
    cfg.duration = 3.

    # Credits: https://icons8.com/icon/40514/dove
    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((-.5, -.5, 0.1), (1, 0, 0), (0, 1, 0))
    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, label='dove')
    render.update_frag_resources(tex0=img_tex)
    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')

    prog_bg = ngl.Program(vertex=cfg.get_vert('color'),
                          fragment=cfg.get_frag('color'))
    shape_bg = ngl.Circle(radius=.6, npoints=256)
    render_bg = ngl.Render(shape_bg, prog_bg, label='background')
    color_animkf = [
        ngl.AnimKeyFrameVec4(0, bgcolor1),
        ngl.AnimKeyFrameVec4(cfg.duration / 2.0, bgcolor2),
        ngl.AnimKeyFrameVec4(cfg.duration, bgcolor1)
    ]
    ucolor = ngl.AnimatedVec4(color_animkf)
    render_bg.update_frag_resources(color=ucolor)

    return ngl.Group(children=(render_bg, render))
Ejemplo n.º 8
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 texture_3d(cfg):
    width, height, depth = 9, 9, 3
    n = width * height
    data = array.array("B")
    for i in cfg.rng.sample(range(n), n):
        data.extend([i * 255 // n, 0, 0, 255])
    for i in cfg.rng.sample(range(n), n):
        data.extend([0, i * 255 // n, 0, 255])
    for i in cfg.rng.sample(range(n), n):
        data.extend([0, 0, i * 255 // n, 255])
    texture_buffer = ngl.BufferUBVec4(data=data)
    texture = ngl.Texture3D(width=width,
                            height=height,
                            depth=depth,
                            data_src=texture_buffer)

    quad = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0))
    program = ngl.Program(vertex=_TEXTURE3D_VERT, fragment=_TEXTURE3D_FRAG)
    program.update_vert_out_vars(var_uvcoord=ngl.IOVec2())
    render = ngl.Render(quad, program)
    render.update_frag_resources(tex0=texture)
    return render
Ejemplo n.º 10
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)

    glsl_version = '300 es' if cfg.backend == 'gles' else '330'
    glsl_header = '#version %s\n' % glsl_version
    render_cubemap_vert = glsl_header + _RENDER_CUBEMAP_VERT
    render_cubemap_frag = glsl_header + _RENDER_CUBEMAP_FRAG
    program = ngl.Program(vertex=render_cubemap_vert,
                          fragment=render_cubemap_frag)
    quad = ngl.Quad((-1, -1, 0), (2, 0, 0), (0, 2, 0))
    render = ngl.Render(quad, program)
    render.update_textures(tex0=cube)
    return render