dymokomi/luce-gpu
Source of release 0.5.2
0.5.2 / 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]