dymokomi/luce-gpu
Source of release 0.5.2
0.5.2 / tests / gpu / frames.lucb
## Frame/view scopes share one contract across independent UI/3D drawing code.
from luce_gpu import gpu
import interop
import ownership
from luce_window import window
import native
import memory
import allocation
import thread
func quad(color: gpu.Vertex) -> gpu.Vertex[6]:
var a = color
var b = color
var c = color
var d = color
a.x = -1.0
a.y = -1.0
b.x = 1.0
b.y = -1.0
c.x = 1.0
c.y = 1.0
d.x = -1.0
d.y = 1.0
return [a, b, c, a, c, d]
pub func contracts() -> !:
# Frames are numbered as they begin and counted while they record: two draws
# into one frame share its serial, and a frame inside another makes two open.
let open_before = gpu.open_frames()
var outer = try gpu.Frame(window.Size(width = 10.0, height = 10.0, pixel_width = 10.0, pixel_height = 10.0, scale = 1.0))
let outer_target = try outer.target()
let first = outer_target.value().frame_serial()
let again = try outer.target()
assert(again.value().frame_serial() == first and gpu.open_frames() == open_before + 1)
var inner = try gpu.Frame(window.Size(width = 10.0, height = 10.0, pixel_width = 10.0, pixel_height = 10.0, scale = 1.0))
let inner_target = try inner.target()
assert(inner_target.value().frame_serial() > first and gpu.open_frames() == open_before + 2)
inner_target.release()
inner.close()
inner.close()
assert(gpu.open_frames() == open_before + 1)
again.release()
outer_target.release()
outer.close()
assert(gpu.open_frames() == open_before)
var frame = try gpu.Frame(window.Size(width = 100.0, height = 80.0, pixel_width = 200.0, pixel_height = 160.0, scale = 2.0))
defer frame.close()
let target = try frame.target()
defer target.release()
let region = try target.value().region(gpu.Rect(x = -10.0, y = 5.0, width = 30.0, height = 20.0))
defer region.release()
assert((try region.value().size()).pixel_width == 60.0)
assert((try region.value().pixel_format()) == none)
try region.value().allow_draws(8192)
try region.value().triangles(quad(gpu.Vertex(red = 1.0)))
frame.close()
assert(not target.is_valid() and not region.is_valid())
let rejected: const gpu.RenderTarget*? = region.get() catch failure:
assert(failure.code == interop.expired)
recover none
assert(rejected == none)
var invalid = false
let bad: gpu.Frame? = gpu.Frame(window.Size(width = 1.0, height = 1.0, pixel_width = 1.5, pixel_height = 1.0, scale = 1.0)) catch failure:
assert(failure.code == gpu.invalid_geometry)
invalid = true
recover none
assert(invalid and bad == none)
pub func pixels() -> !:
var device = try gpu.Device.open()
defer device.destroy()
var host = try window.Window.open(window.Options(title = "Scoped GPU frames", width = 80, height = 60))
defer host.destroy()
var surface = try gpu.Surface.open(device, host)
defer surface.destroy()
# A skipped acquisition and an invalid submission both consume their frame.
let hidden = try surface.frame()
defer hidden.release()
let hidden_target = try hidden.value().target()
defer hidden_target.release()
assert((try hidden.value().present()) == gpu.PresentResult.skipped)
assert(not hidden_target.is_valid())
try host.show()
while (try host.poll()) != none:
_ = 0
let size = try surface.size()
let frame = try surface.frame()
defer frame.release()
let target = try frame.value().target()
defer target.release()
let region = try target.value().region(gpu.Rect(x = size.width * 0.25, y = size.height * 0.25, width = size.width * 0.5, height = size.height * 0.5))
defer region.release()
# A nested region is larger than its parent; clipping may not expand.
let child = try region.value().region(gpu.Rect(x = -size.width * 0.25, y = -size.height * 0.25, width = size.width, height = size.height))
defer child.release()
try child.value().triangles(quad(gpu.Vertex(red = 1.0, z = 0.2)), true)
try child.value().triangles(quad(gpu.Vertex(blue = 1.0, z = 0.8)), true)
var refused = false
let duplicate: interop.Reference[gpu.Frame]? = surface.frame() catch failure:
assert(failure.code == gpu.frame_in_use)
refused = true
recover none
assert(refused and duplicate == none)
native.begin("Scoped GPU frames")
assert((try frame.value().present(gpu.Color(green = 1.0))) == gpu.PresentResult.submitted)
assert(not target.is_valid() and not child.is_valid())
# A presented frame hands out its submission; a skipped one has none.
let shown = frame.value().submission()
assert(shown.serial > 0 and hidden.value().submission().serial == 0)
try device.wait(shown)
if (try device.limits()).timestamps:
let shown_time = (try device.gpu_time(shown)) else error(gpu.failed, "a presented frame has no GPU time")
assert(shown_time.end >= shown_time.start)
try surface.wait_idle()
native.pixel(0, 0, 0, 255, 0)
native.pixel((u64)(size.pixel_width * 0.5), (u64)(size.pixel_height * 0.5), 255, 0, 0)
native.pixel((u64)size.pixel_width - 1, (u64)size.pixel_height - 1, 0, 255, 0)
native.end()
let invalid = try surface.frame()
defer invalid.release()
let invalid_target = try invalid.value().target()
defer invalid_target.release()
_ = invalid.value().present(gpu.Color(red = 2.0)) catch failure:
assert(failure.code == gpu.invalid_color)
recover gpu.PresentResult.skipped
assert(not invalid_target.is_valid())
let resized = try surface.frame()
defer resized.release()
let stale = try resized.value().target()
defer stale.release()
try host.resize(96, 64)
refused = false
stale.value().triangles(quad(gpu.Vertex())) catch failure:
assert(failure.code == gpu.frame_resized)
refused = true
assert(refused)
_ = resized.value().present() catch failure:
assert(failure.code == gpu.frame_resized)
recover gpu.PresentResult.skipped
assert(not stale.is_valid())
let closing = try surface.frame()
defer closing.release()
let expired = try closing.value().target()
defer expired.release()
surface.destroy()
refused = false
expired.value().triangles(quad(gpu.Vertex())) catch failure:
assert(failure.code == gpu.closed)
refused = true
assert(refused)
closing.value().close()
assert(not expired.is_valid())
# Releasing the final frame releases surface exclusivity without closing the window.
var again = try gpu.Surface.open(device, host)
defer again.destroy()
let final = try again.frame()
defer final.release()
host.destroy()
_ = final.value().present() catch failure:
assert(failure.code == window.closed)
recover gpu.PresentResult.skipped
final.value().close()
## Refuse each ownership/view/command allocation, then prove the same operation
## can succeed with no surviving storage from an earlier failed attempt.
pub func failures() -> !:
let original = memory.heap
var tracker = allocation.Tracker(upstream = original)
memory.heap = &tracker
defer allocation.restore(original)
var succeeded = false
for stage in 0..<16:
tracker.remaining = (usize)stage
with tracker:
record() catch failure:
assert(failure.code == memory.exhausted)
tracker.remaining = none
ownership.collect()
assert(tracker.live == 0)
with tracker:
try record()
succeeded = true
ownership.collect()
assert(succeeded and tracker.live == 0)
func record() -> !:
var frame = try gpu.Frame(window.Size(width = 10.0, height = 10.0, pixel_width = 10.0, pixel_height = 10.0, scale = 1.0))
defer frame.close()
let target = try frame.target()
defer target.release()
let child = try target.value().clipped(gpu.Rect(width = 5.0, height = 5.0))
defer child.release()
try child.value().triangles(quad(gpu.Vertex()))
## This runs in a separate process: Base cannot transfer a recording view into
## another ownership context, even if its frame remains alive on the caller.
pub func wrong_thread() -> !:
var frame = try gpu.Frame(window.Size(scale = 1.0))
defer frame.close()
var target = try frame.target()
defer target.release()
var worker = try thread.spawn(read_target, (void*)&target)
try worker.join()
trap("a render target crossed runtime threads")
func read_target(context: void*?):
let target = (interop.View[gpu.RenderTarget]*)(context else trap("missing target"))
_ = target.value()