dymokomi/luce-3d
Source of release 0.9.2
0.9.2 / tests / geometry / main.lucb
from luce_gpu import gpu
import interop
from luce_std import math
import memory
import ownership
from luce_window import window
from luce_3d import graphics as three
from luce_3d.graphics import append_curve_segments
from luce_geocore.kernel import arc_curves, empty_set, curves_type, adopt_set
from luce_geocore.core.growing import Growing
from luce_3d.graphics import SphereGeometry, BufferGeometry, Vertex, Vector3, Matrix4, MeshLambertMaterial, Color, Scene, Group, Mesh, Object3D, Geometry, Material, PerspectiveCamera, Renderer
struct Tracker: memory.Allocator:
var upstream: memory.Allocator
var live: usize
var remaining: usize?
pub func allocate(size: usize, alignment: usize) -> u8[]?:
if size == 0: return self.upstream.allocate(size, alignment)
if let remaining = self.remaining:
if remaining == 0:
return none
self.remaining = remaining - 1
let block = self.upstream.allocate(size, alignment) else return none
self.live += 1
return block
pub func resize(block: u8[], size: usize) -> bool:
return self.upstream.resize(block, size)
pub func release(block: u8[]):
if block.length == 0: return
assert(self.live > 0)
self.live -= 1
self.upstream.release(block)
func restore(previous: memory.Allocator):
memory.heap = previous
func near(left: f64, right: f64):
assert(math.abs(left - right) < 0.00000001)
func sample_vertex(sphere: SphereGeometry*, index: i64) -> Vertex!:
let value = sphere.vertex(index)
defer value.release()
return try value.get()
func sample_index(sphere: SphereGeometry*, offset: i64) -> i64!:
let value = sphere.index(offset)
defer value.release()
return try value.get()
func geometry() -> !:
var sphere = try SphereGeometry(2.0, 32, 16)
defer sphere.close()
assert(sphere.vertex_count() == 561 and sphere.index_count() == 2880)
let bounds = sphere.bounds()
near(bounds.minimum.x, -2.0)
near(bounds.maximum.y, 2.0)
for row in 0..<17:
let first = try sample_vertex(&sphere, row * 33)
let last = try sample_vertex(&sphere, row * 33 + 32)
assert(first.position == last.position and first.normal == last.normal)
assert(first.u == 0.0 and last.u == 1.0)
for offset in 0..<sphere.vertex_count():
let point = try sample_vertex(&sphere, offset)
near(point.position.length(), 2.0)
near(point.normal.length(), 1.0)
assert(point.u >= 0.0 and point.u <= 1.0 and point.v >= 0.0 and point.v <= 1.0)
var offset: i64 = 0
while offset < sphere.index_count():
let a = (try sample_vertex(&sphere, try sample_index(&sphere, offset))).position
let b = (try sample_vertex(&sphere, try sample_index(&sphere, offset + 1))).position
let c = (try sample_vertex(&sphere, try sample_index(&sphere, offset + 2))).position
# Every triangle is nondegenerate and faces outward, including both poles.
assert(b.subtract(a).cross(c.subtract(a)).dot(a.add(b).add(c)) > 0.00000001)
offset += 3
let outside = sphere.vertex(-1)
defer outside.release()
assert(not outside.is_success())
let missing = sphere.index(sphere.index_count())
defer missing.release()
assert(not missing.is_success())
var rejected = false
var invalid: SphereGeometry? = SphereGeometry(0.0) catch failure:
assert(failure.code == three.invalid)
rejected = true
recover none
assert(rejected and invalid == none)
var points = [Vertex(Vector3(-1.0, -1.0, 0.0), Vector3(0.0, 0.0, 1.0)),
Vertex(Vector3(1.0, -1.0, 0.0), Vector3(0.0, 0.0, 1.0)),
Vertex(Vector3(0.0, 1.0, 0.0), Vector3(0.0, 0.0, 1.0))]
var indices: i64[3] = [0, 1, 2]
var buffer = try BufferGeometry(points, indices)
defer buffer.close()
points[0] = points[1]
indices[0] = 2
let copied = buffer.vertex(0)
defer copied.release()
assert((try copied.get()).position.x == -1.0)
let copied_index = buffer.index(0)
defer copied_index.release()
assert((try copied_index.get()) == 0)
indices[0] = 3
rejected = false
var bad: BufferGeometry? = BufferGeometry(points, indices) catch failure:
rejected = true
assert(failure.code == three.invalid)
recover none
assert(rejected and bad == none)
func transforms() -> !:
let matrix = Matrix4.compose(Vector3(1.0, 2.0, 3.0), Vector3(), Vector3(2.0, 3.0, 4.0))
assert(matrix.transform_point(Vector3(1.0, 1.0, 1.0)) == Vector3(3.0, 5.0, 7.0))
let child = Matrix4.compose(Vector3(2.0, 1.0, 0.0), Vector3(0.0, 0.0, math.pi / 2.0), Vector3(1.0, 1.0, 1.0))
let composed = matrix.multiply(child)
let expected = matrix.transform_point(child.transform_point(Vector3(1.0, 0.0, 0.0)))
let actual = composed.transform_point(Vector3(1.0, 0.0, 0.0))
near(actual.x, expected.x)
near(actual.y, expected.y)
near(actual.z, expected.z)
let normal = try matrix.transform_normal(Vector3(1.0, 1.0, 0.0))
near(normal.length(), 1.0)
near(normal.dot(matrix.transform_direction(Vector3(1.0, -1.0, 0.0))), 0.0)
var camera = try PerspectiveCamera(60.0, 2.0, 0.5, 100.0)
let projection = try camera.projection()
near(projection.focal, math.sqrt(3.0))
assert(projection.aspect == 2.0 and projection.near == 0.5)
try camera.set_position(Vector3(0.0, 5.0, 0.0))
try camera.look_at(Vector3())
let polar = try camera.projection()
near(polar.right.length(), 1.0)
near(polar.up.dot(polar.backward), 0.0)
var rejected = false
camera.set_aspect(0.0) catch failure:
assert(failure.code == three.invalid)
rejected = true
assert(rejected and camera.aspect() == 2.0)
func allocations(tracker: Tracker*) -> !:
var failures: usize = 0
var succeeded = false
for stage in 0..<20:
tracker.remaining = (usize)stage
var sphere: SphereGeometry? = SphereGeometry() catch failure:
assert(failure.code == memory.exhausted)
failures += 1
recover none
tracker.remaining = none
if let completed = sphere:
var value = completed
value.close()
succeeded = true
ownership.collect()
_ = ownership.finish_run(0)
assert(tracker.live == 0)
assert(succeeded and failures >= 6)
func scene_membership(tracker: Tracker*) -> !:
let parent = try interop.Reference[Group].adopt(new Group() in memory.heap, three.group_type, memory.heap)
defer parent.release()
let child = try interop.Reference[Group].adopt(new Group() in memory.heap, three.group_type, memory.heap)
defer child.release()
let parent_object = parent.as_interface[Object3D](parent.value())
defer parent_object.release()
let child_object = child.as_interface[Object3D](child.value())
defer child_object.release()
let parent_node = parent.value().node()
defer parent_node.release()
let child_node = child.value().node()
defer child_node.release()
# The shared ARC collector keeps a roots buffer. Initialize that runtime
# storage before injecting failure into the package's child-buffer growth.
parent_node.clone().release()
ownership.collect()
let baseline = tracker.live
tracker.remaining = (usize)0
var rejected = false
parent.value().add(child_object) catch failure:
assert(failure.code == memory.exhausted)
rejected = true
tracker.remaining = none
assert(rejected and tracker.live == baseline)
assert(parent_node.value().child_count() == 0 and child_node.value().parent_id() == 0)
try parent.value().add(child_object)
assert(child_node.value().parent_id() == parent_node.value().id())
rejected = false
child.value().add(parent_object) catch failure:
assert(failure.code == three.invalid)
rejected = true
assert(rejected)
rejected = false
parent.value().add(child_object) catch failure:
assert(failure.code == three.busy)
rejected = true
assert(rejected and parent_node.value().child_count() == 1)
child.close()
assert(try parent.value().remove(child_object))
assert(child_node.value().parent_id() == 0 and parent_node.value().child_count() == 0)
assert(not try parent.value().remove(child_object))
let remaining = try interop.Reference[Group].adopt(new Group() in memory.heap, three.group_type, memory.heap)
defer remaining.release()
let remaining_object = remaining.as_interface[Object3D](remaining.value())
defer remaining_object.release()
let remaining_node = remaining.value().node()
defer remaining_node.release()
try parent.value().add(remaining_object)
parent.close()
assert(parent_node.value().child_count() == 0 and remaining_node.value().parent_id() == 0)
## Curve lines: a poly circle's closed polyline, and a Bezier circle's hull
## (control polygon, handle arms, a cross per control point).
func curve_lines() -> !:
for kind in 0..<(i64)2:
let circle = try arc_curves(1.0, 0.0, 360.0, 16, kind, 2, 4)
let storage = try empty_set()
try storage.put(curves_type(), (void*)circle)
let set = try adopt_set(storage)
defer set.release()
var lines = Growing[Vector3]()
defer lines.close()
var hulls = Growing[Vector3]()
defer hulls.close()
try append_curve_segments(set.value(), Matrix4(), &lines, &hulls)
assert(lines.count == (32 if kind == 0 else 16 * 4 * 2))
assert(hulls.count == (0 if kind == 0 else (16 + 16 + 48) * 2))
for point in lines.view(): near_loose(point.length(), 1.0)
assert((try three.CurveLines.count(set)) == (16 if kind == 0 else 64))
func near_loose(left: f64, right: f64):
assert(math.abs(left - right) < 0.01)
pub func main(arguments: str[]) -> i32!:
try curve_lines()
let previous = memory.heap
var tracker = Tracker(previous, 0, none)
memory.heap = &tracker
defer restore(previous)
try geometry()
try transforms()
ownership.collect()
assert(tracker.live == 0)
try allocations(&tracker)
try scene_membership(&tracker)
ownership.collect()
_ = ownership.finish_run(0)
assert(tracker.live == 0)
print("ok geometry, transforms, camera, membership and allocation failures")
return 0