dymokomi/luce-geocore
Source of release 0.7.5
0.7.5 / 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")