Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-gpu

Source of release 0.5.6

0.5.6 / src / gpu / geometry.lucb

## Immutable retained vertex storage. Camera changes record only small uniforms.
## Triangles use Vertex position/color; lines use xyz and rgb as endpoint pairs.
pub struct Geometry:
    var state: GeometryState*?

    ## Upload once. The caller may release its CPU vertices immediately.
    pub static func create(device: Device, vertices: const Vertex[], lines: bool = false) -> Geometry!:
        let owner = try device.checked()
        if vertices.length == 0 or vertices.length > 4194304 or (not lines and vertices.length % 3 != 0):
            error(invalid_geometry, "invalid retained geometry count")
        for vertex in vertices:
            if not lines and not valid_vertex(vertex): error(invalid_geometry, "invalid retained triangle vertex")
            for value in [vertex.x, vertex.y, vertex.z, vertex.w, vertex.red, vertex.green, vertex.blue, vertex.alpha]:
                if not math.is_finite((f64)value): error(invalid_geometry, "nonfinite retained geometry")
        let native = try backend_geometry_create(owner, vertices)
        errdefer owner.destroy_geometry(owner.native, native)
        let state = try new GeometryState(owner, native, 1, vertices.length, lines) in memory.heap
        owner.references += 1
        return Geometry(state)

    ## Whether storage is present (zero value is closed).
    pub func is_open() -> bool:
        return self.state != none

    ## Release this owner; recorded draws and pending GPU work retain storage.
    pub func destroy():
        if let state = self.state:
            require_thread()
            self.state = none
            release_geometry(state)

struct GeometryState:
    let device: DeviceState*
    let native: void*
    var references: usize
    let count: usize
    let lines: bool

func release_geometry(state: GeometryState*):
    state.references -= 1
    if state.references == 0:
        state.device.destroy_geometry(state.device.native, state.native)
        release_device(state.device)
        free(state) in memory.heap

## Draw retained world-space geometry. Matrix is column-major world-to-clip.
## Lines are clipped at near/far planes and expanded by the vertex shader.
## slope_bias is an optional logical-pixel raster depth-slope factor for fills;
## it does not change vertices or line depth. Zero leaves ordinary depth intact.
pub func draw_geometry(target: const RenderTarget*, geometry: Geometry, matrix: const f32[], color: Color = Color(1.0, 1.0, 1.0), width: f64 = 1.0, bias: f64 = 0.000001, slope_bias: f64 = 0.0) -> !:
    try target.frame.check()
    let state = geometry.state else error(closed, "retained geometry is closed")
    if target.frame.device != state.device: error(invalid_geometry, "retained geometry belongs to another device")
    if matrix.length != 16 or not (width > 0.0 and width <= 32.0) or not math.is_finite(bias): error(invalid_geometry, "invalid geometry drawing parameters")
    if not (slope_bias >= 0.0 and slope_bias <= 32.0) or (state.lines and slope_bias != 0.0): error(invalid_geometry, "slope bias requires triangle geometry and a finite factor in 0..32")
    for value in matrix:
        if not math.is_finite((f64)value): error(invalid_geometry, "nonfinite geometry matrix")
    try check_color(color)
    let size = try target.size()
    if size.width <= 0.0 or size.height <= 0.0: return
    let scale_x = frame_scale(target.frame.size.pixel_width, target.frame.size.width)
    let scale_y = frame_scale(target.frame.size.pixel_height, target.frame.size.height)
    let region = Viewport(target.rectangle.x * scale_x, target.rectangle.y * scale_y, size.pixel_width, size.pixel_height)
    var values: f32[28]
    for index in 0..<(usize)16: values[index] = matrix[index]
    values[16] = (f32)color.red
    values[17] = (f32)color.green
    values[18] = (f32)color.blue
    values[19] = (f32)color.alpha
    values[20] = (f32)width if state.lines else 0.0
    values[21] = (f32)size.width
    values[22] = (f32)size.height
    values[23] = -1.0 if state.device.backend == Backend.vulkan else 1.0
    values[24] = (f32)bias
    let depth_slope = slope_bias * math.max(scale_x, scale_y)
    if depth_slope > 256.0: error(invalid_geometry, "backing depth slope factor exceeds 256")
    try target.frame.canvas.retained(state, target.clipping, region, values, (f32)depth_slope)

func backend_geometry_create(device: DeviceState*, vertices: const Vertex[]) -> void*!:
    if (platform.windows or platform.linux) and device.backend == Backend.vulkan:
        return (void*)try vulkan_geometry_create((VulkanDevice*)device.native, vertices)
    if platform.macos and platform.arm64:
        return try metal_geometry_create((MetalDevice*)device.native, vertices)
    error(unsupported, "retained geometry backend unavailable")

func backend_geometry_destroyer(backend: Backend) -> func(void*, void*) -> unit:
    if (platform.windows or platform.linux) and backend == Backend.vulkan: return vulkan_geometry_release
    if platform.macos and platform.arm64 and backend == Backend.metal: return metal_geometry_release
    trap("retained geometry backend unavailable")