dymokomi/luce-3d
Source of release 0.9.3
0.9.3 / src / cameras / perspective.lucb
import interop
from luce_std import math
import errors
from luce_geocore.geocore import Vector3
pub struct Projection:
pub let position: Vector3
pub let right: Vector3
pub let up: Vector3
pub let backward: Vector3
pub let focal: f64
pub let aspect: f64
pub let near: f64
pub let far: f64
## The initial camera uses world-space position and look-at target. It is separate
## from scene membership; projection is rebuilt from validated lens parameters.
pub struct PerspectiveCamera:
var field_of_view: f64
var ratio: f64
var near_plane: f64
var far_plane: f64
var location: Vector3
var target: Vector3
pub func init(fov: f64 = 50.0, aspect: f64 = 1.0, near: f64 = 0.1, far: f64 = 1000.0) -> !:
try lens(fov, aspect, near, far)
self.field_of_view = fov
self.ratio = aspect
self.near_plane = near
self.far_plane = far
self.location = Vector3(0.0, 0.0, 5.0)
self.target = Vector3()
pub func position() -> Vector3:
return self.location
pub func set_position(position: Vector3) -> !:
if not position.is_finite():
error(errors.invalid, "camera position must be finite")
_ = try position.subtract(self.target).normalized()
self.location = position
pub func look_at(target: Vector3) -> !:
if not target.is_finite():
error(errors.invalid, "camera target must be finite")
_ = try self.location.subtract(target).normalized()
self.target = target
pub func aspect() -> f64:
return self.ratio
pub func set_aspect(aspect: f64) -> !:
try lens(self.field_of_view, aspect, self.near_plane, self.far_plane)
self.ratio = aspect
pub func set_projection(fov: f64, near: f64, far: f64) -> !:
try lens(fov, self.ratio, near, far)
self.field_of_view = fov
self.near_plane = near
self.far_plane = far
pub func projection(aspect: f64? = none) -> Projection!:
let ratio = aspect else self.ratio
try lens(self.field_of_view, ratio, self.near_plane, self.far_plane)
let backward = try self.location.subtract(self.target).normalized()
var right = Vector3(0.0, 1.0, 0.0).cross(backward)
if right.length() < 0.000001:
right = Vector3(0.0, 0.0, 1.0).cross(backward)
right = try right.normalized()
return Projection(self.location, right, backward.cross(right), backward,
1.0 / math.tan(self.field_of_view * math.pi / 360.0), ratio, self.near_plane, self.far_plane)
pub func close():
_ = self.location
pub let perspective_camera_type: interop.Type[PerspectiveCamera] = interop.Type[PerspectiveCamera]("PerspectiveCamera", PerspectiveCamera.close, closeable = true, main_thread = true)
func lens(fov: f64, aspect: f64, near: f64, far: f64) -> !:
if not (fov > 0.0 and fov < 179.0 and aspect >= 0.000001 and aspect <= 1000000.0 and near > 0.0 and far > near and far <= 1000000000.0):
error(errors.invalid, "a perspective camera needs finite fov (0,179), positive aspect and 0 < near < far <= 1e9")