Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-3d

Source of release 0.9.6

0.9.6 / src / renderers / splat_view.lucb

## The per-view work that draws Gaussian splats, for one cloud or many at
## once. Every cloud's splats take a run of slots in one combined index space
## (each run padded to whole workgroups of 256), so a view is one compute pass:
## 1. splat_project.comp, once per cloud, projects its splats (EWA), culls
##    them, picks merged splats far away (level of detail), evaluates SH and
##    writes quad records and depth keys at the cloud's slots;
## 2. splat_offsets.comp and splat_compact.comp gather every visible slot's
##    key in slot order, with the count and the draw's arguments;
## 3. one GPU LSD radix sort (renderers/radix_sort) orders them all back to
##    front.
## The frame then draws one quad per visible slot in that order with
## luce-gpu's shade_quads. Since all clouds sort together, splats of
## interleaved clouds (overlapping captures, instances) blend in depth order.
## A view whose clouds, placements and camera did not change draws without
## the pass.
from luce_gpu import gpu
import memory
import errors
from luce_geocore.core.growing import Growing
from renderers.radix_sort import RadixSort
from renderers.splat_shaders import splat_project_comp_words, splat_project_comp_msl, splat_project_comp_group, splat_project_comp_bindings, splat_project_comp_fast_math
from renderers.splat_shaders import splat_offsets_comp_words, splat_offsets_comp_msl, splat_offsets_comp_group, splat_offsets_comp_bindings
from renderers.splat_shaders import splat_compact_comp_words, splat_compact_comp_msl, splat_compact_comp_group, splat_compact_comp_bindings

## Bits of the depth keys the sort orders: a view depth's float bits but the
## low 7 (a relative depth step of 2^-16).
let key_bits: u32 = 24
## Workgroups along x of the per-splat kernels' 2D grids.
let grid_width: usize = 32768
## Words of one cloud's entry in a view's signature: its serial (2) and its
## uniforms (32).
pub let signature_words: usize = 34

## What one cloud gives a view: its static buffers (absent ones are bound to
## its centers, which the kernel then never reads), its splat count and the
## uniforms of its projection.
pub struct CloudInput:
    pub var centers: gpu.Buffer
    pub var covariances: gpu.Buffer
    pub var colors: gpu.Buffer
    pub var frames: gpu.Buffer
    pub var harmonics: gpu.Buffer
    pub var marks: gpu.Buffer
    pub var count: usize
    pub var uniforms: f32[32]

## GPU milliseconds of the last sorted view's steps, and its visible count.
pub struct SplatTimes:
    ## Projection, culling and SH (splat_project).
    pub var project: f64
    ## Gathering the visible splats' keys (splat_offsets, splat_compact).
    pub var compact: f64
    ## The radix sort.
    pub var sort: f64
    ## Splats drawn.
    pub var visible: i64

## Slots `count` splats take: whole workgroups.
pub func padded(count: usize) -> usize:
    return (count + 255) // 256 * 256

pub struct SplatView:
    var device: gpu.Device
    ## Slots the buffers hold.
    var capacity: usize
    var records: gpu.Buffer
    var depth_keys: gpu.Buffer
    var group_counts: gpu.Buffer
    var group_offsets: gpu.Buffer
    var keys: gpu.Buffer
    var values: gpu.Buffer
    var arguments: gpu.Buffer
    var sort: RadixSort?
    var project: gpu.Kernel
    var offsets: gpu.Kernel
    var compact: gpu.Kernel
    ## The last pass (kept for its timings), and what it sorted: per cloud
    ## its serial and uniforms (heap; `signed` words used).
    var pass: gpu.Compute?
    var signature: u32[]
    var signed: usize
    var sorts: i64
    ## Each cloud's selection marks (their key) the last projection tinted.
    var marked: Growing[u64]

    ## A view on `device`: its kernels; buffers come with the first sort.
    pub static func open(device: gpu.Device) -> SplatView!:
        var made = SplatView(device = try device.share(), capacity = 0, signed = 0, sorts = 0, marked = Growing[u64]())
        errdefer made.destroy()
        made.project = try gpu.Kernel.create(device, splat_project_comp_words, splat_project_comp_msl, splat_project_comp_group, splat_project_comp_bindings,
                                             splat_project_comp_fast_math)
        made.offsets = try gpu.Kernel.create(device, splat_offsets_comp_words, splat_offsets_comp_msl, splat_offsets_comp_group, splat_offsets_comp_bindings)
        made.compact = try gpu.Kernel.create(device, splat_compact_comp_words, splat_compact_comp_msl, splat_compact_comp_group, splat_compact_comp_bindings)
        return made

    ## Whether this view lives on `device`.
    pub func on(device: gpu.Device) -> bool:
        var own = self.device
        var other = device
        return own.same(&other)

    ## How many views it sorted.
    pub func sort_count() -> i64:
        return self.sorts

    ## Whether `signature` (signature_words per cloud) is what the last pass sorted.
    pub func sorted_for(signature: const u32[]) -> bool:
        if self.pass == none or signature.length != self.signed: return false
        for index in 0..<signature.length:
            if signature[index] != self.signature[index]: return false
        return true

    ## Whether the last projection tinted each cloud's marks `marks` (keys).
    pub func marked_for(marks: const u64[]) -> bool:
        if marks.length != self.marked.count: return false
        for at in 0..<marks.length:
            if marks[at] != self.marked.items[at]: return false
        return true

    ## Project `clouds` again into the records the last sort ordered, for a
    ## new selection's tint (`marks`): the camera and the clouds are those the
    ## sort saw, so every record keeps its slot and its depth, and nothing is
    ## gathered or sorted again.
    pub func recolor_clouds(clouds: const CloudInput[], marks: const u64[]) -> !:
        try self.marked.assign(marks)
        if let previous = self.pass:
            var closing = previous
            closing.close()
            self.pass = none
        var pass = try gpu.Compute.begin(self.device)
        errdefer pass.close()
        try self.project_clouds(&pass, clouds)
        _ = try pass.timestamp()
        _ = try pass.timestamp()
        _ = try pass.timestamp()
        try pass.submit()
        self.pass = pass

    ## Record and submit the pass that projects, gathers and sorts `clouds`
    ## together; `signature` says what it sorted.
    pub func sort_clouds(clouds: const CloudInput[], signature: const u32[], marks: const u64[]) -> !:
        var slots: usize = 0
        for cloud in clouds: slots += padded(cloud.count)
        try self.reserve(slots)
        try self.remember(signature)
        try self.marked.assign(marks)
        if let previous = self.pass:
            var closing = previous
            closing.close()
            self.pass = none
        var pass = try gpu.Compute.begin(self.device)
        errdefer pass.close()
        try self.project_clouds(&pass, clouds)
        _ = try pass.timestamp()
        # The gather kernels see the whole index space as one cloud.
        var whole: f32[32]
        for index in 0..<(usize)32: whole[index] = 0.0
        whole[20] = f32.bits((u32)slots)
        let block = u8[]((u8*)&whole[0], 128)
        let groups = slots // 256
        let across = groups if groups < grid_width else grid_width
        let down = (groups + across - 1) // across
        let placing: gpu.Binding[3] = [gpu.Binding(buffer = self.group_counts), gpu.Binding(buffer = self.group_offsets), gpu.Binding(buffer = self.arguments)]
        try pass.dispatch(self.offsets, placing, block, 1)
        let gathering: gpu.Binding[4] = [gpu.Binding(buffer = self.depth_keys), gpu.Binding(buffer = self.group_offsets), gpu.Binding(buffer = self.keys),
                                         gpu.Binding(buffer = self.values)]
        try pass.dispatch(self.compact, gathering, block, (u32)across, (u32)down)
        _ = try pass.timestamp()
        var sort = self.sort else trap("splat sort")
        try sort.record(&pass, self.keys, self.values, self.arguments, key_bits)
        _ = try pass.timestamp()
        try pass.submit()
        self.pass = pass
        self.sorts += 1

    ## Each cloud's projection into its slots of the records and depth keys.
    func project_clouds(pass: gpu.Compute*, clouds: const CloudInput[]) -> !:
        var first: usize = 0
        for cloud in clouds:
            if cloud.count == 0: continue
            var bytes = cloud.uniforms
            # The cloud's first slot (splat_params.glsl's view.z).
            bytes[18] = f32.bits((u32)first)
            let groups = padded(cloud.count) // 256
            let across = groups if groups < grid_width else grid_width
            let down = (groups + across - 1) // across
            let projecting: gpu.Binding[9] = [gpu.Binding(buffer = cloud.centers), gpu.Binding(buffer = cloud.covariances), gpu.Binding(buffer = cloud.colors),
                                              gpu.Binding(buffer = cloud.frames), gpu.Binding(buffer = cloud.harmonics), gpu.Binding(buffer = self.records),
                                              gpu.Binding(buffer = self.depth_keys), gpu.Binding(buffer = self.group_counts), gpu.Binding(buffer = cloud.marks)]
            try pass.dispatch(self.project, projecting, u8[]((u8*)&bytes[0], 128), (u32)across, (u32)down)
            first += padded(cloud.count)

    ## Draw the last sorted view into `target` with `pipeline`; `cull` is the
    ## alpha cull.
    pub func draw(target: const gpu.RenderTarget*, pipeline: gpu.Pipeline, cull: f64) -> !:
        if self.pass == none: return
        var fragment: f32[1] = [(f32)cull]
        var quads = gpu.Quads(records = self.records, data = 1, order = self.values, arguments = self.arguments, arguments_offset = 0)
        try gpu.shade_quads(target, pipeline, &quads, u8[]((u8*)&fragment[0], 4))

    ## The GPU times of the last sorted view's steps (waiting for its pass).
    pub func timings() -> SplatTimes!:
        let pass = self.pass else error(errors.invalid, "no view was sorted yet")
        var waited = pass
        try waited.wait()
        var stamps: u64[3]
        try waited.timestamps(stamps)
        let span = (try self.device.gpu_time(try waited.submission())) else error(errors.invalid, "the sorting pass's GPU time is gone")
        var visible: u32[1]
        try self.arguments.read(4, u8[]((u8*)&visible[0], 4))
        return SplatTimes(project = milliseconds(span.start, stamps[0]), compact = milliseconds(stamps[0], stamps[1]),
                          sort = milliseconds(stamps[1], stamps[2]), visible = (i64)visible[0])

    ## Buffers for at least `slots` slots (a quarter more when they grow, so
    ## a scene growing a little at a time reallocates seldom).
    func reserve(slots: usize) -> !:
        if slots <= self.capacity and self.capacity > 0: return
        var wanted = slots + slots // 4
        if wanted < 256: wanted = 256
        wanted = padded(wanted)
        self.release_buffers()
        let groups = wanted // 256
        self.records = try gpu.Buffer.allocate(self.device, wanted * 48)
        self.depth_keys = try gpu.Buffer.allocate(self.device, wanted * 4)
        self.group_counts = try gpu.Buffer.allocate(self.device, groups * 4)
        self.group_offsets = try gpu.Buffer.allocate(self.device, groups * 4)
        self.keys = try gpu.Buffer.allocate(self.device, wanted * 4)
        self.values = try gpu.Buffer.allocate(self.device, wanted * 4)
        self.arguments = try gpu.Buffer.allocate(self.device, 32)
        # The sort's kernels stay; only its scratch follows the size.
        if let held = self.sort:
            var sort = held
            try sort.resize(self.device, wanted)
            self.sort = sort
        else:
            self.sort = try RadixSort.create(self.device, wanted)
        self.capacity = wanted

    func remember(signature: const u32[]) -> !:
        if self.signature.length < signature.length:
            if self.signature.length > 0: free(self.signature) in memory.heap
            var nothing: u32[]
            self.signature = nothing
            self.signature = try new u32[signature.length] --- in memory.heap
        for index in 0..<signature.length: self.signature[index] = signature[index]
        self.signed = signature.length

    func release_buffers():
        if let pass = self.pass:
            var closing = pass
            closing.close()
            self.pass = none
        for buffer in [self.records, self.depth_keys, self.group_counts, self.group_offsets, self.keys, self.values, self.arguments]:
            var owned = buffer
            owned.destroy()
        self.capacity = 0

    ## Free the buffers, kernels and the last pass.
    pub func destroy():
        self.release_buffers()
        if let sort = self.sort:
            var owned = sort
            owned.destroy()
            self.sort = none
        self.marked.close()
        if self.signature.length > 0: free(self.signature) in memory.heap
        var nothing: u32[]
        self.signature = nothing
        self.project.destroy()
        self.offsets.destroy()
        self.compact.destroy()
        self.device.destroy()

## A heap view on `device` (close_view frees it).
pub func open_view(device: gpu.Device) -> SplatView*!:
    var made = try SplatView.open(device)
    errdefer made.destroy()
    let storage = try new SplatView[1] --- in memory.heap
    storage[0] = made
    return storage.data

pub func close_view(view: SplatView*):
    view.destroy()
    free(SplatView[](view, 1)) in memory.heap

func milliseconds(from_time: u64, to_time: u64) -> f64:
    return (f64)(to_time - from_time) / 1.0e6 if to_time > from_time else 0.0