#ky678/renky/system/graph — coordinate systems for a renderer (MoonBit, zero dependencies)
Only the coordinate-system layer of a renderer: every space, every transform between them, and the
conventions that glue them together. No third-party packages (only moonbitlang/core).
#Conventions (one place, no surprises)
| Item | Choice |
|---|---|
| Handedness / axes | Right-handed, Y-up; camera looks down -Z, +X right, +Y up |
| Scalars / angles | Double, radians (Float only for GPU upload helpers) |
| Matrices | column vectors v' = M v, fields mRC, Mat4::to_col_major is GL/WebGPU/Vulkan layout |
| Quaternion | Hamilton, a * b applies b first |
| Euler | all 12 orders, intrinsic R = R_A(a) R_B(b) R_C(c), canonical branch on extraction |
| Clip / NDC depth | DepthMode: NegOneToOne (OpenGL), ZeroToOne (D3D/Vulkan/Metal/WebGPU), ReversedZ; finite or infinite far plane |
| Viewport / pixels | origin top-left, y down, pixel centres at +0.5 |
| Cube map | faces +X,-X,+Y,-Y,+Z,-Z (OpenGL table), v down; equirect u = 0.5 + atan2(x,-z)/2π |
| Spherical | azimuth 0 = -Z, +π/2 = -X; elevation from the horizon |
| Geodesy | WGS-84; ECEF → local ENU/NED → render frame (east=+X, up=+Y, north=-Z) |
#Spaces and what converts between them
model ──Rigid/Mat4 TRS──▶ world ──view (Camera)──▶ view ──Projection──▶ clip ──÷w──▶ NDC ──Viewport──▶ screen
▲ ▲ │
└─ tangent / TBN └─ convention (Z-up, Y-down, left-handed … ⇄ native) ◀── pick_ray / unproject ┘
geodetic (lat,lon,h) ⇄ ECEF ⇄ ENU/NED ⇄ render world Web-Mercator ⇄ tile / pixel / quadkey
direction ⇄ cube face (u,v) ⇄ equirect ⇄ octahedral texel ⇄ uv, wrap modes, bilinear footprint
cartesian ⇄ spherical / cylindrical / polar camera-relative (floating-origin) view matrixFiles: vec*.mbt quat.mbt mat3.mbt mat4.mbt euler.mbt transform.mbt (algebra) ·
projection.mbt viewport.mbt camera.mbt geometry.mbt (pipeline, rays, planes, frusta, AABB) ·
geodetic.mbt mercator.mbt curvilinear.mbt (earth & curvilinear systems) ·
texture.mbt tangent.mbt (UV, cube, octahedral, TBN, barycentrics) · convention.mbt (other engines' frames).
#Run
From the module root (renky/):
moon test -p ky678/renky/system/graph # 75 tests; also --target wasm | js | native
python3 system/graph/tools/mutation_check.py # injects 71 bugs; every one must be caught
moon run system/graph/cmd/demo --target native > demo.ppm # software-rendered scene (docs/demo.png)
moon run system/graph/cmd/benchmark --target native --release # micro-benchmarksUse it: moon add ky678/renky, then import { "ky678/renky/system/graph" } and refer to it as @graph.
#How the tests avoid being decorative
- External oracles (tools/gen_golden.py → golden_data_test.mbt): numpy textbook pipelines (gluPerspective, XMMatrixPerspectiveFovRH, glOrtho, reversed-Z, D3D viewport), scipy (Rotation, Euler, rotvec), PROJ/pyproj (EPSG:4979→4978, EPSG:4326→3857, topocentric ENU), PROJ Geod for metres/degree, OSM tile formulas, Bing quadkey example.
- Independent re-derivations: a reference triangle rasteriser is compared pixel-by-pixel with analytic ray casting through pick_ray; frustum culling vs clip-space inequalities; closed-form inverses vs general inverse.
- Mutation testing: tools/mutation_check.py (71 mutants — sign flips, swapped operands, dropped terms) — all killed. It found and led to fixing three real gaps (no tests for AABB transform, ray-plane, frustum near/far).
Aabb
Axis-aligned bounding box.
Aabb::corner
Corner i in 0..7 (bit0 -> x, bit1 -> y, bit2 -> z select max).
Aabb::transform
Exact world-space AABB of this box under an affine matrix (Arvo): cost of one 3x3
multiply, no corner enumeration.
Axis
Bilinear
The 2x2 texel neighbourhood and weights of a bilinear fetch at uv.
Result texel = (1-fx)(1-fy) T[x0,y0] + fx(1-fy) T[x1,y0] + (1-fx)fy T[x0,y1] + fx fy T[x1,y1].
Camera
pub(all) struct Camera {
pose : Rigid
projection : Projection
viewport : Viewport
} derive(Eq, Debug)Camera::look_at
Camera::new
Camera::orbit
fn Camera::orbit(target : Vec3, distance : Double, yaw : Double, pitch : Double, projection : Projection, viewport : Viewport) -> CameraOrbit / FPS style: yaw, pitch give the viewing direction as a Spherical direction
(yaw 0, pitch 0 looks down -Z; +yaw turns left about +Y; +pitch looks up). The eye sits
distance behind target along that direction.
Camera::pick_ray
World-space picking ray through a window position (unit direction).
Camera::resize
Change the viewport and keep the picture undistorted by updating the projection aspect.
Camera::screen_to_world
Window position + window depth (as read back from the depth buffer) -> world.
Camera::screen_to_world_at_distance
World point under window position (sx, sy) at distance in front of the camera plane.
Camera::view_proj_rte
World -> clip with the eye moved to the origin ("camera-relative / floating origin"
rendering). Pair with model matrices whose translation has eye subtracted in DOUBLE
precision (Mat4::relative_to) before the single rounding to float: this removes the
jitter of huge world coordinates.
Camera::world_to_ndc
World -> NDC. None if behind the eye plane (perspective).
Camera::world_to_screen
World -> window: (x px, y px, window depth). None if behind the camera.
Convention
Which world axes mean "right", "up" and "forward" (the direction a camera / character looks).
Convention::basis_change
Signed permutation matrix M such that v_to = M * v_from: right stays right, up stays up,
forward stays forward. det(M) = -1 when the two conventions differ in handedness (a mirror);
remember to flip triangle winding in that case.
Convention::convert_mat4
Re-express a 4x4 transform: M4 * T * M4^-1 (M4 is its own inverse transpose; orthogonal).
Convention::convert_quat
Re-express an orientation: the same physical rotation, described in the other axes.
Axis -> M * axis * det(M), angle unchanged (a mirror reverses the sense of rotation).
Convention::convert_vec3
Re-express a point / direction given in self convention in to convention.
Convention::is_right_handed
Handedness of the world: right-handed when right x up points BACKWARD (= -forward).
Convention::is_valid
Valid when right/up/forward use three different coordinate axes.
Convention::native
This library / OpenGL / glTF / three.js / Maya: right +X, up +Y, forward -Z (right-handed).
Convention::ros
ROS REP-103 / Source engine style: forward +X, left +Y (right -Y), up +Z (right-handed).
Convention::unreal
Unreal Engine: forward +X, right +Y, up +Z (left-handed).
Convention::y_up_left_handed
Unity, Direct3D-style left-handed world: right +X, up +Y, forward +Z.
Convention::z_up_right_handed
Blender, 3ds Max, SketchUp, most CAD: right +X, up +Z, forward +Y (right-handed).
CubeCoord
Face + coordinates inside that face image (u right, v down, both in [0, 1]).
Cylindrical
Cylindrical coordinates about the +Y axis.
Cylindrical::new
DepthMode
How NDC depth is laid out.
- ZeroToOne: near -> 0, far -> 1 (Vulkan / D3D / Metal / WebGPU native)
- NegOneToOne: near -> -1, far -> 1 (OpenGL default)
- ReversedZ: near -> 1, far -> 0 (best float precision; use with a GREATER depth test and clear depth to 0). With an infinite far plane this is the recommended modern setup.
DepthMode::from_unit
Inverse of to_unit.
Ellipsoid
Ellipsoid::from_ecef
ECEF -> Geodetic (Bowring start + fixed-point iteration on latitude; ~1e-6 m or better for any point from deep
underground to beyond geostationary orbit; poles and the equator are handled). The Earth's
exact centre has no unique latitude: (0, 0, -a) is returned.
Ellipsoid::geocentric_latitude
Geocentric latitude (angle from the equatorial plane to the position vector) for a
point ON the ellipsoid surface at geodetic latitude lat.
Ellipsoid::geodetic_latitude
Inverse of geocentric_latitude.
Ellipsoid::grs80
GRS 80 (NAD83, ETRS89, CGCS2000 differs slightly in f).
Ellipsoid::meridional_radius
Meridional radius of curvature M(lat) (north-south): metres per radian of latitude.
Ellipsoid::prime_vertical_radius
Radius of curvature in the prime vertical, N(lat): distance from the surface to the polar
axis along the normal.
Ellipsoid::sphere
A perfect sphere (f = 0) -- the model used by simple globes and Web Mercator.
Ellipsoid::to_ecef
Geodetic -> ECEF (closed form).
EulerOrder
EulerOrder::axes
Axis indices (0=X, 1=Y, 2=Z) of the three rotations in order.
Frame
Orthonormal frame: tangent (T), bitangent (B), normal (N). Right-handed when
cross(T, B) == N, left-handed (mirrored UVs) when cross(T, B) == -N.
Frame::from_normal
Right-handed frame whose normal is n (normalised internally); T, B arbitrary but stable.
Frame::handedness
+1 for a right-handed frame, -1 for mirrored (the glTF tangent.w value).
Frame::to_local
Parent space -> local (T, B, N) coordinates (the frame is orthonormal: transpose = inverse).
Frame::to_mat3
Matrix with columns T, B, N (local -> parent).
Frustum
The six planes of a view frustum with normals pointing INSIDE.
Frustum::classify_aabb
Box classification. Outside is exact-safe (box is certainly invisible); Inside is
certain; Intersecting may include a few boxes that are actually just outside a corner.
Frustum::from_view_proj
Extract frustum planes from clip = view_proj * world; handles every DepthMode.
The planes are expressed in the space that view_proj takes as INPUT (world space when
view_proj = P * V; model space when P * V * M).
Geodetic
Geodetic position: latitude / longitude in RADIANS, height above the ellipsoid in metres.
Geodetic::from_degrees
LocalFrame
A local Cartesian frame anchored at origin (ECEF metres) whose orthonormal axes
(columns of axes, expressed in ECEF) define the local coordinates.
LocalFrame::dir_to_local
Rotate a free vector (e.g. velocity, direction) from ECEF to local axes.
LocalFrame::ecef_to_render_enu
Rigid transform ECEF -> RENDER space for a scene centred on an ENU frame: east -> +X,
up -> +Y, north -> -Z (the library's Y-up, -Z-forward world). Use the returned pose's
to_mat4() as a view/world matrix for geospatial content, or inverse() to go back.
LocalFrame::enu
East-North-Up tangent frame at geodetic position g (local x = east, y = north, z = up).
LocalFrame::ned
North-East-Down tangent frame (aerospace convention: x = north, y = east, z = down).
LocalFrame::to_ecef
Local frame coordinates -> ECEF.
LocalFrame::to_local
ECEF -> local frame coordinates.
LonLat
Mat3
Mat3::from_axis_angle
Rodrigues rotation about axis (normalised internally).
Mat3::from_euler
Matrix for R_A(a) * R_B(b) * R_C(c).
Mat3::from_trs2d
Translate * Rotate * Scale (scale applied first).
Mat3::inverse
General inverse; None when singular (det == 0) or not finite.
Mat3::look_rotation
Orientation matrix (columns = right, up, back) whose local -Z is forward and whose
local +Y is closest to up. Degenerate inputs fall back to a valid orthonormal basis.
Mat3::mul_dir2
Direction transform (ignores translation).
Mat3::mul_point2
Affine point transform (assumes last row = 0 0 1).
Mat3::normal_matrix
(M^-1)^T, the matrix that transforms surface normals. None when singular.
Mat3::project_point2
Projective (homography) point transform with divide by w. None if w == 0.
Mat3::rotation2d
Counter-clockwise rotation about the origin (y-up frame).
Mat3::to_col_major
Column-major 9 values (GLSL mat3 / WGSL mat3x3 memory order, tightly packed).
Mat3::to_euler
Recover (a, b, c) such that Mat3::from_euler(order, a, b, c) reproduces m.
Ranges: Tait-Bryan: a, c in [-PI, PI], b in [-PI/2, PI/2]; proper: a, c in [-PI, PI],
b in [0, PI] (a ~ in (-PI, PI] up to the sign convention). At gimbal lock the
decomposition is not unique; one valid solution is returned (the matrix still round-trips).
Mat4
Mat4::affine_inverse
Inverse of an affine matrix (last row 0 0 0 1) via the 3x3 block: ~3x cheaper than
inverse. None if the 3x3 block is singular. The last row is NOT checked.
Mat4::decompose
Split an affine TRS matrix into (translation, rotation, scale). A negative determinant
(mirroring) is reported as a negative X scale. Returns None for projective matrices,
zero scale, or when shear is present (columns not mutually orthogonal).
Mat4::from_trs
Translate * Rotate * Scale (scale applied first). The standard model-matrix recipe.
Mat4::inverse
General 4x4 inverse (Laplace expansion on 2x2 minors). None if singular / not finite.
Prefer affine_inverse / rigid_inverse when the matrix structure is known.
Mat4::is_affine
True when the last row is exactly (0, 0, 0, 1).
Mat4::look_at
View matrix (world -> view) of an eye at eye looking at target, up = approximate
up. Right-handed, camera looks down -Z, +Y up, +X right.
Mat4::mul_dir
Transform a direction (w = 0): translation ignored. For normals use normal_matrix.
Mat4::mul_point
Transform a point assuming an AFFINE matrix (last row 0 0 0 1): w stays 1, no divide.
Fastest path for model/view matrices.
Mat4::normal_matrix
Matrix for transforming surface normals of a model matrix: inverse-transpose of the 3x3
block. Correct under non-uniform scale and mirroring. None if singular.
Result is NOT normalised; normalise the transformed normal.
Mat4::project_point
Full homogeneous transform of a point (w = 1) followed by the perspective divide.
None if the resulting w == 0. NOTE: points behind the eye (w < 0) are returned
mirrored -- use Camera::world_to_ndc for visibility-aware projection.
Mat4::relative_to
Model matrix expressed relative to origin (translation reduced in double precision).
Equivalent to translation(-origin) * m but without a full matrix multiply.
Mat4::rigid_inverse
Inverse of a rigid transform (rotation + translation only): R^T, -R^T t. Cheapest and
exact; the caller guarantees orthonormality (e.g. camera pose, bone transforms).
Mat4::to_col_major
16 values in column-major order (GLSL / WGSL / Metal / Vulkan upload order).
Mat4::to_col_major_f32
Column-major single-precision values for GPU upload.
Mat4::to_mat3
Upper-left 3x3 block (rotation * scale for an affine matrix).
Mat4::transform_points
Transform count points stored as packed xyz triples in src (affine matrix, w = 1)
writing to dst (may alias src). No per-point allocation.
Mat4::transform_points_f32
Single-precision variant of transform_points, math done in double then rounded once.
Plane
Plane dot(normal, p) + d = 0; normal should be unit for signed_distance to be metric.
Plane::from_points
Plane through three points (normal = (b-a) x (c-a), counter-clockwise => facing viewer).
Polar
2D polar coordinates: angle counter-clockwise from +X (y-up frame).
Polar::from_cartesian
Radius >= 0, angle in (-PI, PI]; the origin maps to angle 0.
Projection
A projection volume. left/right/bottom/top are the extents in VIEW-space units measured
at the NEAR plane (perspective) or of the box (orthographic). far may be
@double.infinity for perspective projections.
Projection::aspect
Width / height of the projection window.
Projection::fov_y
Vertical field of view (radians) of a perspective projection (0 for orthographic).
Projection::frustum
fn Projection::frustum(left : Double, right : Double, bottom : Double, top : Double, near : Double, far : Double, depth : DepthMode) -> ProjectionOff-centre perspective frustum (glFrustum): extents on the near plane. Used for
asymmetric FOV (VR eyes), tiled/sub-rect rendering, lens shift, portals.
Projection::inverse_mat4
Closed-form inverse (clip -> view), much cheaper and more accurate than a general
4x4 inverse. The result of inverse * clip has a w component that must be divided out
for perspective (use Mat4::project_point).
Projection::linear_depth
Distance in front of the camera plane (positive), from an NDC depth value. This is the
"linearized depth" used for fog, SSAO, soft particles, etc.
Projection::ndc_depth
NDC depth of a view-space z (negative in front of the camera).
Projection::orthographic
fn Projection::orthographic(left : Double, right : Double, bottom : Double, top : Double, near : Double, far : Double, depth : DepthMode) -> ProjectionProjection::orthographic_centered
fn Projection::orthographic_centered(width : Double, height : Double, near : Double, far : Double, depth : DepthMode) -> ProjectionCentered orthographic box of the given width / height.
Projection::perspective
fn Projection::perspective(fov_y : Double, aspect : Double, near : Double, far : Double, depth : DepthMode) -> ProjectionSymmetric perspective from vertical field of view (radians) and width/height aspect.
far may be @double.infinity.
Projection::perspective_fov
fn Projection::perspective_fov(angle_left : Double, angle_right : Double, angle_down : Double, angle_up : Double, near : Double, far : Double, depth : DepthMode) -> ProjectionAsymmetric perspective from four half-angles (radians, all measured outward from the view
axis and normally positive): the VR/OpenXR "field of view" form.
Projection::project_view
View-space point -> NDC. None for perspective points on/behind the eye plane
(z_view >= 0), where the projection is not defined for rendering.
Projection::to_mat4
The 4x4 projection matrix (column vectors, v_clip = P * v_view).
Projection::unproject_ndc
NDC -> view-space point (exact inverse of project_view).
Projection::view_ray
View-space ray through an NDC xy position: (origin, unit direction).
- perspective: origin = eye (0,0,0)
- orthographic: origin lies on the near plane, direction = -Z
Projection::view_z_from_ndc
View-space z (negative in front) from an NDC depth value.
Projection::with_aspect
Same vertical extent, new aspect ratio (keeps relative horizontal lens shift).
Projection::with_depth
Quat
Quat::angle_to
Smallest rotation angle (radians, [0, PI]) between two orientations.
Quat::approx_eq
True when both quaternions represent the same rotation (q and -q are equal).
Quat::from_axis_angle
axis need not be unit length; a zero axis gives identity.
Quat::from_euler
Quaternion for R_A(a) * R_B(b) * R_C(c) with (A,B,C) = order.
Quat::from_mat3
Quaternion from a proper rotation matrix (Shepperd's method, numerically stable).
Quat::from_rotation_vector
exp-map: rotation vector (axis * angle) -> quaternion. Stable for tiny angles.
Quat::from_to
Shortest-arc rotation taking direction a onto direction b (inputs need not be unit).
Quat::integrate
Advance orientation by a WORLD-space angular velocity omega (rad/s) over dt seconds.
Quat::look_rotation
Orientation whose local -Z axis points along forward and whose local +Y is as close
as possible to up (the camera / OpenGL "look" convention). Degenerate up is handled.
Quat::nlerp
Normalised linear interpolation along the shortest arc.
Quat::normalize
Re-normalise (call after many accumulated multiplications). Zero -> identity.
Quat::rotate
Rotate a vector (direction or point about the origin).
Quat::slerp
Spherical interpolation along the shortest arc (constant angular speed).
Quat::to_axis_angle
(unit axis, angle in [0, PI]). Identity -> (+X, 0).
Ray
Ray::intersect_aabb
Slab test. Returns (t_enter, t_exit) with t_exit >= max(t_enter, 0); t_enter is clamped to 0
when the origin is inside. None on a miss.
Ray::intersect_plane
Distance t >= 0 along the ray to the plane; None if parallel or behind the origin.
Ray::intersect_sphere
Nearest distance t >= 0 to a sphere surface hit (entry, or exit if starting inside).
Rigid
Rigid body pose: rotation + translation only (no scale). Forms a group: composition and
inverse are exact. Use for camera poses, bones, physics bodies, frames.
Rigid::from_mat4
Extract from a rigid matrix (orthonormal 3x3, affine). Not validated.
Rigid::look_at
Pose (local -> world) of an object at eye whose local -Z looks at target with +Y
toward up. For a camera this is the camera-to-world transform.
Spherical
Spherical coordinates (radius, azimuth, elevation) -- see the module comment.
Spherical::from_cartesian
Radius >= 0, azimuth in (-PI, PI], elevation in [-PI/2, PI/2]. At the poles (and the
origin) azimuth is reported as 0; at the origin elevation is also 0.
Spherical::new
Transform
Translation * Rotation * Scale. to_mat4 gives the model matrix.
A negative scale component represents mirroring.
Transform::mul_point
local -> parent
Vec2
Vec2::angle
Angle of the vector from +X, counter-clockwise, in (-PI, PI].
Vec2::cross
z-component of the 3D cross product (signed parallelogram area).
Positive when o is counter-clockwise from self (in a y-up frame).
Vec2::normalize
Unit vector; the zero vector is returned unchanged.
Vec2::rotate
Rotate counter-clockwise by angle radians.
Vec2::try_normalize
Unit vector, or None when the length is zero / not finite.
Vec3
Vec3::angle_to
Unsigned angle in [0, PI] between two vectors (robust for tiny angles).
Vec3::any_perpendicular
A vector perpendicular to self (unit length when self is non-zero).
Vec3::from_yaw_pitch
Unit direction for yaw (azimuth) and pitch (elevation).
Vec3::get
Component by index 0..2 (aborts otherwise).
Vec3::normalize
Unit vector; the zero vector is returned unchanged.
Vec3::project_onto
Component of self along onto (need not be unit). Zero if onto is zero.
Vec3::to_yaw_pitch
(yaw, pitch) of a direction (need not be unit).
Vec3::try_normalize
Unit vector, or None when the length is zero / not finite.
Vec4
Vec4::perspective_divide
Perspective divide: (x/w, y/w, z/w). None when w == 0 / non-finite result.
Viewport
Viewport::contains
Does the window position fall inside the viewport rectangle?
Viewport::from_logical
Viewport for a window given in LOGICAL (DPI-independent) units; the pixel size is the
logical size times scale, rounded to whole device pixels.
Viewport::ndc_to_screen
NDC (x, y, z) -> window coordinates (x px, y px, depth). mode tells how ndc z maps to
[0,1] before min/max depth are applied.
Viewport::new
Viewport::screen_to_ndc
Window coordinates + window depth -> NDC.
Viewport::screen_to_ndc_xy
Window xy -> NDC xy only.
CUBE_POS_X
let CUBE_POS_X : IntCube face indices (same order as OpenGL / D3D / Vulkan array layers).
MERCATOR_MAX_LAT
let MERCATOR_MAX_LAT : DoubleLatitude beyond which Web Mercator is clipped: atan(sinh(PI)) = 85.0511287798 deg.
MERCATOR_RADIUS
let MERCATOR_RADIUS : DoubleRadius of the sphere used by EPSG:3857 (WGS84 semi-major axis), metres.
bary_inside
True when all three barycentric weights are >= -eps.
barycentric_2d
Barycentric coordinates (wa, wb, wc) of p in triangle (a, b, c); sum is 1; all >= 0 iff
p is inside. None for a degenerate triangle.
barycentric_3d
Barycentric coordinates of the projection of p onto the plane of triangle (a, b, c).
bilinear_footprint
cube_from_direction
Direction -> (face, u, v) following the OpenGL cube-map selection table (also used by
D3D and Vulkan). dir need not be unit; zero gives face 0 centre. Ties between equal
major axes resolve X, then Y, then Z.
cube_to_direction
(face, u, v) -> UNIT direction through that point of the face (exact inverse of
cube_from_direction).
ecef_to_yup
Globe-centred render axes: ECEF (x, y, z) -> render (x, z, -y), i.e. north pole = +Y.
A proper rotation (determinant +1).
edge_function
Edge function: > 0 when p is to the LEFT of the directed edge a -> b (Y-up frame).
equirect_from_direction
Direction -> equirectangular UV. The image centre (0.5, 0.5) looks down -Z (forward);
u increases toward +X (turning right), v increases DOWNWARD (v = 0 is straight up).
flip_v
Switch between top-left (v down) and bottom-left (v up) conventions.
ground_resolution
fn ground_resolution(lat : Double, zoom : Double, tile_size : Double) -> DoubleGround resolution: metres per pixel at a latitude (true ground distance, not Mercator units).
lonlat_to_tile
Integer tile (x, y) containing a position at integer zoom (clamped to the pyramid).
lonlat_to_world_pixel
lon/lat -> world pixel coordinates (origin NW corner, y down).
mercator_to_world_pixel
EPSG:3857 metres -> world pixels (and back); handy for mixing meter-based and tile-based math.
mip_level_count
fn mip_level_count(width : Int, height : Int) -> IntNumber of mip levels of a full chain down to 1x1.
mip_lod
Level of detail from screen-space UV derivatives (what textureSample computes):
lod = log2(max(|d(uv * size)/dx|, |d(uv * size)/dy|)). May be negative (magnification).
mod_floor
fn mod_floor(a : Int, n : Int) -> IntFloor division remainder that is always in [0, n) for n > 0.
orthonormal_basis
Branchless orthonormal basis from a UNIT vector (Duff et al. 2017, "Building an
Orthonormal Basis, Revisited"): continuous except at n = (0, 0, -1) and free of
singularities for every other direction.
perspective_correct
Perspective-correct barycentrics. screen_bary are the weights measured in 2D window/NDC
space; w0, w1, w2 are the clip-space w of the three vertices (= view-space depth for a
perspective projection). The result are the weights in the 3D triangle, to be used to
interpolate any attribute (UV, normal, colour, view-space position).
pixel_center
Centre of pixel (ix, iy) in window coordinates.
quadkey_to_tile
fn quadkey_to_tile(key : String) -> (Int, Int, Int)?Parse a quadkey back into (x, y, zoom). None for any character other than 0-3.
safe_acos
fn safe_acos(x : Double) -> Doubleacos that tolerates |x| slightly above 1 from rounding error.
safe_asin
fn safe_asin(x : Double) -> Doubleasin that tolerates |x| slightly above 1 from rounding error.
sign_nz
fn sign_nz(x : Double) -> Double+1.0 for x >= 0 (including +0 and -0), -1.0 otherwise. Never returns 0.
tangent_frame
Tangent frame of a triangle from its positions and UVs, for normal mapping.
T points along increasing u (dP/du), B along increasing v (dP/dv, which is DOWN in the
top-left UV convention -- negate B, or flip_v the UVs, for a Y-up normal map).
T and B are orthonormalised against the supplied vertex normal n; the handedness of
the UV mapping is preserved in B. None for degenerate (zero-area UV) triangles.
texel_center_uv
UV of the CENTRE of texel (i, j).
tile_bounds
(west, south, east, north) lon/lat bounds of a tile.
tile_to_lonlat
North-west corner of tile (x, y) at zoom (x, y may be fractional for sub-tile positions).
tile_to_quadkey
fn tile_to_quadkey(x : Int, y : Int, zoom : Int) -> StringBing-style quadkey of a tile ("" at zoom 0).
triangle_area2
Twice the signed area of triangle (a, b, c): positive when counter-clockwise in a Y-UP frame
(NDC). In window space (Y down) the same triangle is negative.
uv_to_texel
UV -> continuous texel coordinates (texel i spans [i, i+1)). Pixel centre = i + 0.5.
web_mercator_forward
lon/lat -> EPSG:3857 metres (x east, y NORTH). Latitude is clamped to +-MERCATOR_MAX_LAT.
world_pixel_to_lonlat
world_pixel_to_mercator
world_size_px
fn world_size_px(zoom : Double, tile_size : Double) -> DoubleSide of the whole-world square in pixels at (possibly fractional) zoom.
wrap_coord
Wrap a normalised coordinate into [0, 1].
wrap_texel
Wrap an integer texel index into [0, n).
Install
Download ziprenky: system/graph (zero-dependency coordinate systems for rendering), system/algorithms/omniring, and system/algorithms/vlab (228 numbered linear-algebra algorithms over twelve combinable inner-product spaces, 152 self-proving tests). Axiom: a self-contained finite-field skeleton plus eight ring/semiring structures, heat (tropical) degenerations, homology, and a closed computational loop. No third-party dependencies.
graphicscoordinate-systemsfinite-fieldtropicalcohomologyf-splittingp-adicclass-groupverified
Apache-2.0
Updated last month
42 downloads