Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-gpu

Source of release 0.5.5

0.5.5 / tests / gpu / targets.lucb

from luce_gpu import gpu

## What a target reports and allows, on a device: the texel format of a texture
## frame's targets, and a draw limit raised past the default for one frame.
pub func pixels(device: gpu.Device) -> !:
    var texture = try gpu.Texture.create(device, 64, 64, gpu.Format.rgba8_linear)
    defer texture.destroy()
    let frame = try texture.frame()
    defer frame.release()
    let root = try frame.value().target()
    defer root.release()
    assert((try root.value().pixel_format()) == gpu.Format.rgba8_linear)
    let child = try root.value().region(gpu.Rect(x = 8.0, y = 8.0, width = 16.0, height = 16.0))
    assert((try child.value().pixel_format()) == gpu.Format.rgba8_linear)
    child.release()
    # 4,200 one-pixel draws: past the default 4,096 once allowed, in one pass.
    try root.value().allow_draws(4200)
    for index in 0..<(usize)4200:
        let x = (f64)(index % 64)
        let y = (f64)(index // 64)
        let quad = solid_quad(x, y, 64.0, 0.0, 1.0, 0.0)
        try root.value().triangles(quad)
    assert((try frame.value().present(gpu.Color(1.0, 0.0, 0.0, 1.0))) == gpu.PresentResult.submitted)
    var texels: u8[16384]
    try texture.read(texels)
    # Rows 0..64 are all drawn (64 * 64 = 4096 draws), the last 104 draws repeat
    # row 64's positions off the texture.
    for index in 0..<(usize)4096:
        assert(texels[index * 4] == 0 and texels[index * 4 + 1] == 255)
    var other = try gpu.Texture.create(device, 4, 4, gpu.Format.r8)
    defer other.destroy()
    let mask = try other.frame()
    defer mask.release()
    let mask_root = try mask.value().target()
    defer mask_root.release()
    assert((try mask_root.value().pixel_format()) == gpu.Format.r8)
    try kept(device)
    try clip_masks(device)

## An r8 texture as a clip mask: frames render coverage into it, a nested clip
## multiplies what is there (an `over` draw of color 0 and alpha 1 - coverage
## leaves mask * coverage), and draws sample it as red.
func clip_masks(device: gpu.Device) -> !:
    var mask = try gpu.Texture.create(device, 4, 4, gpu.Format.r8)
    defer mask.destroy()
    let frame = try mask.frame()
    let root = try frame.value().target()
    # The outer clip: the left half, everything else outside it.
    let right = try root.value().region(gpu.Rect(x = 2.0, width = 2.0, height = 4.0))
    try right.value().triangles(cover(0.0, 1.0))
    right.release()
    # A nested clip of coverage 0.25 over the top half: alpha 0.75 multiplies by 0.25.
    let top = try root.value().region(gpu.Rect(width = 4.0, height = 2.0))
    try top.value().triangles(cover(0.0, 0.75))
    top.release()
    root.release()
    assert((try frame.value().present(gpu.Color(1.0, 0.0, 0.0, 1.0))) == gpu.PresentResult.submitted)
    frame.release()
    var texels: u8[16]
    try mask.read(texels)
    for y in 0..<(usize)4:
        for x in 0..<(usize)4:
            let value = texels[y * 4 + x]
            if x >= 2:
                assert(value == 0)
            elif y < 2:
                assert(value >= 63 and value <= 64)
            else:
                assert(value == 255)
    # Sampled by a draw, the mask reads as red with alpha one.
    var shown = try gpu.Texture.create(device, 4, 4, gpu.Format.rgba8_linear)
    defer shown.destroy()
    let view = try shown.frame()
    let target = try view.value().target()
    try gpu.draw_image(target.value(), mask, gpu.Rect(width = 4.0, height = 4.0), filter = gpu.Filter.nearest)
    target.release()
    assert((try view.value().present(gpu.Color(0.0, 0.0, 0.0, 0.0))) == gpu.PresentResult.submitted)
    view.release()
    var colors: u8[64]
    try shown.read(colors)
    assert(colors[0] >= 63 and colors[0] <= 64 and colors[3] == 255 and colors[32] == 255 and colors[12] == 0)

## A full-target quad of gray `level` and straight `alpha`.
func cover(level: f32, alpha: f32) -> gpu.Vertex[6]:
    let a = gpu.Vertex(x = -1.0, y = 1.0, red = level, green = level, blue = level, alpha = alpha)
    var b = a
    b.x = 1.0
    var c = b
    c.y = -1.0
    var d = a
    d.y = -1.0
    return [a, b, c, a, c, d]

## Frames begun with `keep` draw over the texture's contents: what a cleared
## frame left, and what an upload wrote.
func kept(device: gpu.Device) -> !:
    var texture = try gpu.Texture.create(device, 8, 8, gpu.Format.rgba8_linear)
    defer texture.destroy()
    try fill(&texture, gpu.Color(1.0, 0.0, 0.0, 1.0), false, 0.0, 0.0)
    # The left half turns green; the right keeps the red the first frame cleared to.
    try fill(&texture, gpu.Color(0.0, 0.0, 1.0, 1.0), true, 0.0, 1.0)
    var texels: u8[256]
    try texture.read(texels)
    for y in 0..<(usize)8:
        for x in 0..<(usize)8:
            let at = (y * 8 + x) * 4
            if x < 4:
                assert(texels[at] == 0 and texels[at + 1] == 255 and texels[at + 2] == 0 and texels[at + 3] == 255)
            else:
                assert(texels[at] == 255 and texels[at + 1] == 0 and texels[at + 2] == 0 and texels[at + 3] == 255)
    # Over an upload, twice in a row: blue left half, uploaded grey right half.
    var grey: u8[256]
    for index in 0..<(usize)256:
        grey[index] = 100
    try texture.upload(grey)
    try fill(&texture, gpu.Color(), true, 0.0, 0.0, 1.0)
    try fill(&texture, gpu.Color(), true, 0.0, 0.0, 1.0)
    try texture.read(texels)
    assert(texels[0] == 0 and texels[2] == 255 and texels[28] == 100 and texels[31] == 100)
    # Without keep the clear color returns.
    try fill(&texture, gpu.Color(0.0, 0.0, 0.0, 0.0), false, 0.0, 0.0)
    try texture.read(texels)
    assert(texels[0] == 0 and texels[3] == 0 and texels[28] == 0 and texels[31] == 0)

## One frame of `texture`, cleared to `color` unless `keep`, with the left half
## drawn opaque (`green`, `blue`) when either is nonzero.
func fill(texture: gpu.Texture*, color: gpu.Color, keep: bool, red: f32, green: f32, blue: f32 = 0.0) -> !:
    let frame = try texture.frame(keep)
    defer frame.release()
    if green > 0.0 or blue > 0.0:
        let root = try frame.value().target()
        defer root.release()
        let half = try root.value().region(gpu.Rect(width = 4.0, height = 8.0))
        defer half.release()
        let a = gpu.Vertex(x = -1.0, y = 1.0, red = red, green = green, blue = blue)
        var b = a
        b.x = 1.0
        var c = b
        c.y = -1.0
        var d = a
        d.y = -1.0
        try half.value().triangles([a, b, c, a, c, d])
    assert((try frame.value().present(color)) == gpu.PresentResult.submitted)

## Two clip-space triangles covering the pixel at (`x`, `y`) of a `side`-pixel
## square target, in a straight linear color.
func solid_quad(x: f64, y: f64, side: f64, red: f32, green: f32, blue: f32) -> gpu.Vertex[6]:
    let left = (f32)(x * 2.0 / side - 1.0)
    let right = (f32)((x + 1.0) * 2.0 / side - 1.0)
    let top = (f32)(1.0 - y * 2.0 / side)
    let bottom = (f32)(1.0 - (y + 1.0) * 2.0 / side)
    let a = gpu.Vertex(x = left, y = top, red = red, green = green, blue = blue)
    var b = a
    b.x = right
    var c = a
    c.x = right
    c.y = bottom
    var d = a
    d.y = bottom
    return [a, b, c, a, c, d]