Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.6

0.7.6 / src / geometries / shading / normals.lucb

## Per-corner shading normals, grouped by analytic face when requested.
import interop
import memory
from geometries.polygon import Mesh
from math.vector import Vector3
from errors import invalid

pub struct MeshNormals:
    let reserved: u8 = 0

    pub static func generate(source: interop.Reference[Mesh], groups: const i64[]) -> interop.Reference[Mesh]!:
        let mesh = source.value()
        if groups.length != 0 and groups.length != (usize)mesh.face_count():
            error(invalid, "normal groups must match polygon faces")
        var capacity: usize = 16
        while capacity < (usize)mesh.vertex_count() * 2 + 1:
            capacity *= 2
        let keys = try new i64[capacity] --- in memory.heap
        defer free(keys) in memory.heap
        let sums = try new Vector3[capacity] --- in memory.heap
        defer free(sums) in memory.heap
        let slots = try new usize[(usize)mesh.vertex_count()] --- in memory.heap
        defer free(slots) in memory.heap
        for at in 0..<keys.length:
            keys[at] = -1
        for face in 0..<mesh.face_count():
            let size = try mesh.face_size(face)
            let offset = try mesh.face_offset(face)
            let normal = try mesh.face_normal(face)
            for corner in 0..<size:
                let point = try mesh.face_point(face, corner)
                let group = groups[(usize)face] if groups.length > 0 else 0
                if group < 0 or group > 1048576:
                    error(invalid, "normal group out of range")
                let key = point * 1048577 + group
                var slot = (usize)(key ^ (key >> 17) ^ (key >> 9)) % capacity
                while keys[slot] >= 0 and keys[slot] != key:
                    slot = (slot + 1) % keys.length
                if keys[slot] < 0:
                    keys[slot] = key
                    sums[slot] = Vector3()
                sums[slot] = sums[slot].add(normal)
                slots[(usize)(offset + corner)] = slot
        let values = try new f64[(usize)mesh.vertex_count() * 3] --- in memory.heap
        defer free(values) in memory.heap
        for corner in 0..<slots.length:
            let sum = sums[slots[corner]]
            let n = try sum.normalized() if sum.length() > 0.000000001 else Vector3(0.0, 1.0, 0.0)
            values[corner * 3] = n.x
            values[corner * 3 + 1] = n.y
            values[corner * 3 + 2] = n.z
        return try mesh.with_attribute("N", 1, 3, values)