Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-3d

Source of release 0.9.5

0.9.5 / tests / splat_pixels / timings.lucb

## GPU times per step of `count` synthetic splats (degree 3) in a 2800×1800
## view, as a 1400×900 window at 2x shows them: CPU packing, then for a few
## orbiting views the projection, gathering, sort and quad draw, and a view
## at rest (the draw alone). Report only.
from luce_gpu import gpu
import interop
from luce_std import math, clock
from luce_3d.graphics import GaussianSplats, SplatScene, SplatLook, SplatTimes, Vector3, splat_scene_type
import memory
import clouds
from views import View, Wall

let frames: usize = 6

pub func report(device: gpu.Device, count: usize) -> !:
    let set = try clouds.random_set(count, 2.0, 0.0005, 0.006, 15, 11)
    defer set.release()
    let packing = clock.now()
    let cloud = try GaussianSplats.of(set)
    defer cloud.release()
    let packed = packing.elapsed().seconds() * 1000.0
    var view = try View(device, 2800, 1800, false)
    defer view.close()
    let shown: interop.Reference[GaussianSplats][1] = [cloud]
    var walls: Wall[]
    var device_handle = device
    # The first frame uploads.
    try view.look_from(Vector3(0.0, 0.5, 5.0))
    try device_handle.wait(try view.draw(shown, walls))
    var total = SplatTimes(project = 0.0, compact = 0.0, sort = 0.0, visible = 0)
    var raster = 0.0
    for frame in 0..<frames:
        let angle = 0.15 * (f64)(frame + 1)
        try view.look_from(Vector3(5.0 * math.sin(angle), 0.5, 5.0 * math.cos(angle)))
        let submission = try view.draw(shown, walls)
        try device_handle.wait(submission)
        let times = try cloud.value().timings()
        total.project += times.project
        total.compact += times.compact
        total.sort += times.sort
        total.visible += times.visible
        if let span = try device_handle.gpu_time(submission): raster += (f64)span.elapsed() / 1.0e6
    let n = (f64)frames
    let rest_submission = try view.draw(shown, walls)
    try device_handle.wait(rest_submission)
    var rest = 0.0
    if let span = try device_handle.gpu_time(rest_submission): rest = (f64)span.elapsed() / 1.0e6
    let steps = (total.project + total.compact + total.sort) / n + raster / n
    print(f"splats {count}: pack {packed:.0f} ms (CPU); per view: project {total.project / n:.2f} ms, gather {total.compact / n:.2f} ms, sort {total.sort / n:.2f} ms, draw {raster / n:.2f} ms, total {steps:.2f} ms ({1000.0 / steps:.0f} fps), visible {total.visible // (i64)frames}; at rest {rest:.2f} ms")

## Frame times of `count` synthetic splats (no SH) drawn through a
## SplatScene in a 2800×1800 view: a field 200 units across seen from 2 units
## up looking across it (near splats large, the far half tiny) and from 150
## units overhead (the whole field in view), each with level of detail off,
## at 2 pixels (the default) and at 4. Report only (SPLAT_LARGE=<count>).
pub func report_lod(device: gpu.Device, count: usize) -> !:
    let set = try clouds.ground_set(count, 100.0, 13)
    defer set.release()
    let packing = clock.now()
    let cloud = try GaussianSplats.of(set)
    defer cloud.release()
    let packed = packing.elapsed().seconds() * 1000.0
    var view = try View(device, 2800, 1800, false, 1000.0)
    defer view.close()
    let shown: interop.Reference[GaussianSplats][1] = [cloud]
    let scene = try interop.Reference[SplatScene].adopt(new SplatScene() in memory.heap, splat_scene_type, memory.heap)
    defer scene.release()
    var walls: Wall[]
    var device_handle = device
    try view.look_from(Vector3(0.0, 150.0, 1.0))
    try device_handle.wait(try view.draw_scene(scene, shown, walls))
    print(f"splats {count}: pack {packed:.0f} ms (CPU, level of detail {cloud.value().has_lod()})")
    for case in 0..<(usize)6:
        var look = SplatLook()
        look.lod_pixels = [0.0, 2.0, 4.0][case % 3]
        try scene.value().set_look(look)
        var total = SplatTimes(project = 0.0, compact = 0.0, sort = 0.0, visible = 0)
        var raster = 0.0
        for frame in 0..<frames:
            let turn = 0.1 * (f64)(frame + 1)
            # Eye level: from the field's edge toward its middle; overhead: a slow turn.
            let eye = Vector3(95.0 * math.sin(turn), 2.0, 95.0 * math.cos(turn)) if case < 3 else Vector3(math.sin(turn), 150.0, math.cos(turn))
            try view.look_from(eye)
            let submission = try view.draw_scene(scene, shown, walls)
            try device_handle.wait(submission)
            let times = try scene.value().timings()
            total.project += times.project
            total.compact += times.compact
            total.sort += times.sort
            total.visible += times.visible
            if let span = try device_handle.gpu_time(submission): raster += (f64)span.elapsed() / 1.0e6
        let n = (f64)frames
        let steps = (total.project + total.compact + total.sort) / n + raster / n
        let place = "eye level" if case < 3 else "overhead"
        print(f"  {place}, LOD {look.lod_pixels:.1f} px: project {total.project / n:.2f} ms, gather {total.compact / n:.2f} ms, sort {total.sort / n:.2f} ms, draw {raster / n:.2f} ms, total {steps:.2f} ms ({1000.0 / steps:.0f} fps), visible {total.visible // (i64)frames}")