Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.4

0.7.4 / src / geometries / primitives.lucb

## Indexed modeling primitives, sharing points across seams.
import interop
from luce_std import math
import errors
from math.vector import Vector3
from geometries.polygon import Mesh, assembled, mesh_adopt
from core.float3 import Float3
from core.shared import Column
import core.ranges
from geometries.builder import MeshBuilder

pub struct MeshPrimitives:
    let reserved: u8 = 0

    ## A flat square grid in XZ of `divisions` squared quads (1..2048: up to 4.2M
    ## points, as Houdini's Grid builds wrangle-sized inputs).
    pub static func grid(size: f64 = 2.0, divisions: i64 = 4) -> interop.Reference[Mesh]!:
        try parameters(size, divisions, most_grid_divisions)
        let steps = (usize)divisions
        let points = (steps + 1) * (steps + 1)
        let faces = steps * steps
        var positions = try Column[Float3].allocate(points)
        errdefer positions.release()
        var offsets = try Column[i32].allocate(faces + 1)
        errdefer offsets.release()
        var corners = try Column[i32].allocate(faces * 4)
        errdefer corners.release()
        # A first index of -1 asks assembly to triangulate the face, as a builder's mesh is.
        var triangles = try Column[i32].filled(faces * 6, -1)
        errdefer triangles.release()
        var work = GridWork(size = size, steps = steps, positions = positions.span(), offsets = offsets.span(), corners = corners.span())
        ranges.each_range(steps + 1, 64, (void*)&work, grid_rows)
        offsets.span()[faces] = (i32)(faces * 4)
        let storage = try assembled(positions.take(), Vector3(), offsets.take(), corners.take(), triangles.take(), Column[Float3](), Column[Vector3]())
        return try mesh_adopt(storage)

    pub static func sphere(radius: f64 = 1.0, segments: i64 = 16) -> interop.Reference[Mesh]!:
        try parameters(radius, segments)
        if segments < 4:
            error(errors.invalid, "Sphere needs at least four segments")
        let rows = segments // 2
        var out = try MeshBuilder()
        defer out.close()
        _ = try out.point(Vector3(0.0, radius * 2.0, 0.0))
        for row in 1..<rows:
            let theta = (f64)row * math.pi / (f64)rows
            for segment in 0..<segments:
                let phi = (f64)segment * (2.0 * math.pi) / (f64)segments
                _ = try out.point(Vector3(math.sin(theta) * math.cos(phi) * radius, (math.cos(theta) + 1.0) * radius, math.sin(theta) * math.sin(phi) * radius))
        let bottom = try out.point(Vector3())
        for segment in 0..<segments:
            let next = (segment + 1) % segments
            try out.face(3)
            try out.corner(0)
            try out.corner(1 + next)
            try out.corner(1 + segment)
            for row in 0..<rows - 2:
                let a = 1 + row * segments
                try out.face(4)
                try out.corner(a + segment)
                try out.corner(a + next)
                try out.corner(a + segments + next)
                try out.corner(a + segments + segment)
            try out.face(3)
            try out.corner(bottom)
            try out.corner(1 + (rows - 2) * segments + segment)
            try out.corner(1 + (rows - 2) * segments + next)
        return try out.finish()

    pub static func cylinder(radius: f64 = 1.0, height: f64 = 2.0, segments: i64 = 16, cone: bool = false) -> interop.Reference[Mesh]!:
        try parameters(radius, segments)
        if segments < 3 or not (height > 0.0 and height <= 100000.0):
            error(errors.invalid, "Cylinder needs positive height and at least three sides")
        var out = try MeshBuilder()
        defer out.close()
        for row in 0..<(i64)(1 if cone else 2):
            for segment in 0..<segments:
                let angle = (f64)segment * (2.0 * math.pi) / (f64)segments
                _ = try out.point(Vector3(math.cos(angle) * radius, (f64)row * height, math.sin(angle) * radius))
        if cone:
            _ = try out.point(Vector3(0.0, height, 0.0))
        try out.face(segments)
        for segment in 0..<segments:
            try out.corner(segment)
        if not cone:
            try out.face(segments)
            for segment in 0..<segments:
                try out.corner(segments * 2 - segment - 1)
        for segment in 0..<segments:
            let next = (segment + 1) % segments
            try out.face(3 if cone else 4)
            try out.corner(segment)
            try out.corner(segments if cone else segments + segment)
            if not cone:
                try out.corner(segments + next)
            try out.corner(next)
        return try out.finish()

    pub static func torus(radius: f64 = 1.0, tube: f64 = 0.3, segments: i64 = 16) -> interop.Reference[Mesh]!:
        try parameters(radius, segments)
        if segments < 4 or not (tube > 0.0 and tube < radius):
            error(errors.invalid, "Torus tube must be smaller than its radius")
        let rows = segments
        var out = try MeshBuilder()
        defer out.close()
        for i in 0..<segments:
            let phi = (f64)i * (2.0 * math.pi) / (f64)segments
            for j in 0..<rows:
                let theta = (f64)j * (2.0 * math.pi) / (f64)rows
                let r = radius + math.cos(theta) * tube
                _ = try out.point(Vector3(r * math.cos(phi), math.sin(theta) * tube + tube, r * math.sin(phi)))
        for i in 0..<segments:
            for j in 0..<rows:
                try out.face(4)
                try out.corner(i * rows + j)
                try out.corner(i * rows + (j + 1) % rows)
                try out.corner(((i + 1) % segments) * rows + (j + 1) % rows)
                try out.corner(((i + 1) % segments) * rows + j)
        return try out.finish()

## A grid's columns, filled a band of rows at a time.
struct GridWork:
    let size: f64
    let steps: usize
    let positions: Float3[]
    let offsets: i32[]
    let corners: i32[]

## Row z's points and, below the last row, its faces: the builder's layout (points
## row by row, each face's corners a, a + side, a + side + 1, a + 1).
func grid_rows(context: void*, first: usize, end: usize, worker: usize):
    let work = (GridWork*)context
    let side = work.steps + 1
    let scale = (f64)work.steps
    for z in first..<end:
        let depth = ((f64)z / scale - 0.5) * work.size
        for x in 0..<side:
            work.positions[z * side + x] = Float3.of(Vector3(((f64)x / scale - 0.5) * work.size, 0.0, depth))
        if z == work.steps:
            continue
        for x in 0..<work.steps:
            let face = z * work.steps + x
            let a = (i32)(z * side + x)
            work.offsets[face] = (i32)(face * 4)
            work.corners[face * 4] = a
            work.corners[face * 4 + 1] = a + (i32)side
            work.corners[face * 4 + 2] = a + (i32)side + 1
            work.corners[face * 4 + 3] = a + 1

## The most divisions a grid takes; the other primitives take 64.
let most_grid_divisions: i64 = 2048

func parameters(size: f64, divisions: i64, most: i64 = 64) -> !:
    if not (size > 0.0 and size <= 100000.0) or divisions < 1 or divisions > most:
        if most == 64: error(errors.invalid, "primitive size must be positive and divisions in 1..64")
        error(errors.invalid, "grid size must be positive and divisions in 1..2048")