dymokomi/luce-geocore
Source of release 0.7.4
0.7.4 / src / geometries / attribute_kernels.lucb
## Whole-mesh attribute kernels for the attribute nodes. Each computes one new
## column in Base and shares every other: the Luce loops they replace made an
## interop call per element (about 0.5 s on a 700k-face mesh).
import interop
from luce_std import math
import memory
import errors
from math.vector import Vector3
from core.attributes import Attribute, Domain, DataType, Storage
from core.attribute_ops import typed_mut
from geometries.polygon import Mesh
pub struct AttributeKernels:
let reserved: u8 = 0
## Corner uv = (x, z) * scale of each corner's point.
pub static func uv_project(source: interop.Reference[Mesh], scale: f64) -> interop.Reference[Mesh]!:
let mesh = try source.get()
if not math.is_finite(scale): error(errors.invalid, "UV scale must be finite")
let corners = mesh.corner_span()
let points = mesh.point_span()
let origin = mesh.position_origin()
var attribute = try Attribute.create("uv", Domain.corner, DataType.float64, 2, corners.length)
let values = typed_mut[f64](attribute.data.span())
for corner in 0..<corners.length:
let p = points[(usize)corners[corner]].vector().add(origin)
values[corner * 2] = p.x * scale
values[corner * 2 + 1] = p.z * scale
return try mesh.with_attribute_entry(attribute)
## N on faces (the face normals) or points (the normalized sum of the
## incident face normals; zero for isolated points).
pub static func normals(source: interop.Reference[Mesh], domain: i64) -> interop.Reference[Mesh]!:
let mesh = try source.get()
let face_domain = domain == 2
let normals = mesh.face_normal_span()
let count = normals.length if face_domain else (usize)mesh.point_count()
var attribute = try Attribute.create("N", Domain.face if face_domain else Domain.point, DataType.float64, 3, count)
let values = typed_mut[f64](attribute.data.span())
if face_domain:
for face in 0..<count:
values[face * 3] = (f64)normals[face].x
values[face * 3 + 1] = (f64)normals[face].y
values[face * 3 + 2] = (f64)normals[face].z
return try mesh.with_attribute_entry(attribute)
let sums = new Vector3[count] --- in memory.heap catch failure:
attribute.release()
error(failure.code, failure.message)
defer free(sums) in memory.heap
for at in 0..<count: sums[at] = Vector3()
let offsets = mesh.offset_span()
let corners = mesh.corner_span()
for face in 0..<normals.length:
for corner in (usize)offsets[face]..<(usize)offsets[face + 1]:
let point = (usize)corners[corner]
sums[point] = sums[point].add(normals[face].vector())
for at in 0..<count:
let length = sums[at].length()
let n = sums[at].multiply_scalar(1.0 / length) if length > 0.000001 else Vector3()
values[at * 3] = n.x
values[at * 3 + 1] = n.y
values[at * 3 + 2] = n.z
return try mesh.with_attribute_entry(attribute)
## Face "area": the summed area of each face's display triangles.
pub static func face_areas(source: interop.Reference[Mesh]) -> interop.Reference[Mesh]!:
let mesh = try source.get()
let points = mesh.point_span()
let corners = mesh.corner_span()
let faces = try mesh.corner_face_span()
let triangles = mesh.triangle_span()
var attribute = try Attribute.create("area", Domain.face, DataType.float64, 1, (usize)mesh.face_count())
let values = typed_mut[f64](attribute.data.span())
for at in 0..<values.length: values[at] = 0.0
for triangle in 0..<triangles.length // 3:
let a = points[(usize)corners[(usize)triangles[triangle * 3]]].vector()
let b = points[(usize)corners[(usize)triangles[triangle * 3 + 1]]].vector()
let c = points[(usize)corners[(usize)triangles[triangle * 3 + 2]]].vector()
values[(usize)faces[(usize)triangles[triangle * 3]]] += b.subtract(a).cross(c.subtract(a)).length() * 0.5
return try mesh.with_attribute_entry(attribute)
## `name` = `values` (1..4 components) on every element, optionally scaled
## per element and component by a deterministic hash of the element id and
## `seed`. Unscaled values are stored once for the whole domain.
pub static func filled(source: interop.Reference[Mesh], name: str, domain: i64, values: const f64[], integer: bool, randomize: bool, seed: f64) -> interop.Reference[Mesh]!:
let mesh = try source.get()
let count = (usize)(try mesh.domain_count(domain))
let width = values.length
if width < 1 or width > 4: error(errors.invalid, "an attribute value has 1..4 components")
if not randomize:
var rounded: f64[4]
for component in 0..<width:
rounded[component] = math.floor(values[component]) if integer else values[component]
return try mesh.with_single_attribute(name, domain, rounded[..<width], integer)
let generated = try new f64[count * width] --- in memory.heap
defer free(generated) in memory.heap
for id in 0..<count:
for component in 0..<width:
let random = math.sin((f64)(id * 7 + component) * 12.9898 + seed * 78.233) * 43758.5453
let value = values[component] * (random - math.floor(random))
generated[id * width + component] = math.floor(value) if integer else value
return try mesh.with_attribute(name, domain, (i64)width, generated, integer)
## An integer `name` that is 1 on `members` of `domain` and 0 elsewhere.
pub static func membership(source: interop.Reference[Mesh], name: str, domain: i64, members: const i64[]) -> interop.Reference[Mesh]!:
let mesh = try source.get()
let count = (usize)(try mesh.domain_count(domain))
var attribute = try Attribute.create(name, Domain((u8)domain), DataType.int32, 1, count)
let values = typed_mut[i32](attribute.data.span())
for at in 0..<count: values[at] = 0
for id in members:
if id >= 0 and (usize)id < count: values[(usize)id] = 1
return try mesh.with_attribute_entry(attribute)