BorrowedTorch.Camera
2.5.1
Prefix Reserved
dotnet add package BorrowedTorch.Camera --version 2.5.1
NuGet\Install-Package BorrowedTorch.Camera -Version 2.5.1
<PackageReference Include="BorrowedTorch.Camera" Version="2.5.1" />
<PackageVersion Include="BorrowedTorch.Camera" Version="2.5.1" />
<PackageReference Include="BorrowedTorch.Camera" />
paket add BorrowedTorch.Camera --version 2.5.1
#r "nuget: BorrowedTorch.Camera, 2.5.1"
#:package BorrowedTorch.Camera@2.5.1
#addin nuget:?package=BorrowedTorch.Camera&version=2.5.1
#tool nuget:?package=BorrowedTorch.Camera&version=2.5.1
BorrowedTorch.Camera
A camera for MonoGame: quaternion orientation, a floating origin for large worlds, pluggable controllers for free flight and path animation, and a spline path with arc-length parameterization that also emits the geometry needed to draw itself.
Install
dotnet add package BorrowedTorch.Camera
Targets net10.0-windows. Depends on BorrowedTorch.Math, BorrowedTorch.ShapingFunctions (the easing curves of
waypoints) and BorrowedTorch.Animations (the time line a path is played on). It does not bring MonoGame: reference
the MonoGame your game runs on - DesktopGL, WindowsDX or BorrowedTorch's compute fork, any release from 3.8.1.303 on.
Quick start
using BorrowedTorch.Cameras;
using BorrowedTorch.Cameras.Controllers;
var camera = new Camera(position: new Vector3(0, 5, 20), target: Vector3.Zero, up: Vector3.Up)
{
AspectRatio = GraphicsDevice.Viewport.AspectRatio,
FieldOfViewDegrees = 60f,
NearPlane = 0.1f,
FarPlane = 5000f
};
var free = new FreeCameraController();
camera.Controller = free;
// Update, once per frame:
free.Look(mouseDelta.X, mouseDelta.Y);
if (keyboard.IsKeyDown(Keys.W)) free.Move(Vector3.Forward);
if (keyboard.IsKeyDown(Keys.D)) free.Move(Vector3.Right);
camera.Update((float)gameTime.ElapsedGameTime.TotalSeconds);
// Draw:
effect.View = camera.View;
effect.Projection = camera.Projection;
effect.World = Matrix.CreateTranslation(objectPosition - camera.Offset); // see "Floating origin"
Camera
Camera holds a world Position and a unit Orientation quaternion. Forward, Right and Up are cached
world-space basis vectors, and View and Projection are rebuilt by Update, which runs the attached controller first
and then refreshes whatever changed.
LookAt(worldTarget, worldUp)faces a point. A target at the camera's own position leaves the orientation unchanged, and a target straight alongworldUpstill yields a valid orientation.ProjectionKindisPerspective(the default), through a lens ofFieldOfViewDegrees, orOrthographic, along parallel lines: a viewOrthographicHeightworld units tall at every depth (10 to start with) and that timesAspectRatiowide, so what is further off keeps its size on screen - for 2D games, plans and elevations. Both map view depthNearPlane..FarPlaneto 0..1, the orthographic one linearly.IsOrthographicsays which. Under orthographicFieldOfViewDegreesshapes nothing the camera builds and is kept for what still wants a perspective lens, such as a sky drawn behind the scene. A change of kind or height is taken by the nextUpdate, as the lens's other parameters are.var side = new Camera(position: new Vector3(0, 2, 30), target: new Vector3(0, 2, 0), up: Vector3.Up) { ProjectionKind = ProjectionKind.Orthographic, OrthographicHeight = 12f, // world units from the bottom of the screen to the top AspectRatio = GraphicsDevice.Viewport.AspectRatio };ScreenPointToRay(pixel, viewport)returns a world-spaceRayfrom the near plane through the pixel: under perspective the rays fan out from the eye, under orthographic each runs alongForwardfrom the pixel's own point on the near plane. It is computed from the current pose and projection parameters, so it needs noUpdateafter they change.ViewHeightAt(depth)is the height the view spans, in world units, at a depth in front of the camera:2 depth tan(fov / 2)under perspective andOrthographicHeightat every depth under orthographic. What keeps a size on screen - a gizmo, a handle, an icon - takes a share of it; over the viewport's height in pixels it is a pixel's size there.TowardViewer(worldPoint)is the unit direction from a point back toward the viewer along the line it is seen by: towardPositionunder perspective,-Forwardeverywhere under orthographic - for what faces the viewer, such as billboards, rings and drag planes.Jittershifts the whole image on screen by a fraction of a pixel, in normalized device coordinates (a pixel is2 / widthby2 / height), for temporal anti-aliasing:ProjectionisUnjitteredProjectiontranslated by it in clip space, taken at once without anUpdate, so it can be set for one pass of a frame and back for the next.UnjitteredProjectionis the projection alone, perspective or orthographic - for motion vectors and anything drawn over the image that has to stay put. Either kind takes the jitter alike.ScreenPointToRayignores it. A non-finite jitter throwsArgumentException.Validation.
FieldOfViewDegreesmust lie strictly between 0 and 180, andAspectRatio,NearPlane,FarPlaneandOrthographicHeightmust be positive and finite; each setter throwsArgumentOutOfRangeExceptionotherwise, as does aProjectionKindthat is not one of the two. A near plane not less than the far plane throwsInvalidOperationExceptionfromUpdate.Orientationrejects NaN and zero quaternions and stores a normalized copy.
Floating origin
Far from the origin, single-precision world coordinates jitter. The camera keeps an Offset that snaps in whole cells
of 1000 units as the camera moves, and builds View from RebasedPosition, which is Position - Offset. Build your
world matrices relative to the same offset, Matrix.CreateTranslation(worldPosition - camera.Offset), and rendering
stays precise anywhere. Position, LookAt and ScreenPointToRay all use true world coordinates; only rendering needs
the offset.
Controllers
A controller drives one camera at a time. Attach with camera.Controller = controller or controller.ApplyTo(camera);
both take the same path. The camera detaches its previous controller, the new one adopts the camera's current state
once, and a controller assigned to a second camera is detached from the first. Set Controller = null to drive the
camera by hand.
FreeCameraController
Six-degrees-of-freedom flight. The orientation is a quaternion turned about the camera's own axes, so yaw, pitch and roll stay consistent however the camera is banked.
| Member | Meaning |
|---|---|
Look(deltaYaw, deltaPitch) |
Mouse-style deltas scaled by LookSensitivity radians per unit: positive yaw looks right, positive pitch looks down. |
Move(delta) |
Movement in the camera's local frame: X right, Y up, -Z forward, so Vector3.Forward moves forward. Calls within a frame add up and the sum is capped at unit length: a half-deflected stick moves at half MoveSpeedUnitSec, while stacked or diagonal inputs never exceed it. |
Roll(direction) |
Positive rolls clockwise at RollSpeedRadSec. |
SnapTo(forward) |
Smoothly turns to face forward with roll levelled against world up, covering 95% of the turn within AxisSnapConvergenceSec. Any look or roll input cancels the snap. |
Defaults: 20 units per second, 2.5 rad/s roll, 0.0025 look sensitivity, 0.18 s snap.
AnimatedCameraController
Moves the camera along a CameraPath at a constant cruise speed, easing in and out and holding wherever its waypoints
ask to (see Easing and holds). The run is played on an AnimationTimeline from
BorrowedTorch.Animations, moved on by each frame's share of the run, so a run whose length changes mid-play goes on
from the same point of it.
| Member | Meaning |
|---|---|
Path |
The path to follow. Never null; assign a new instance to replace it. |
Timing |
What sets how long a run takes: Duration (default) or Speed. |
DurationSec |
Seconds for one full traversal, easing and holds included, by Duration timing. Default 8. |
SpeedUnitsPerSec |
The cruise speed by Speed timing, kept when the path changes length mid-run. Default 5. |
OpenPathAnimationMode |
What an open path does at its ends: Stop (default), Loop or PingPong. Closed paths always wrap. |
EntryBlendDurationSec |
On attachment the camera eases from where it was onto the path over this many seconds; 0 jumps. Default 2. |
SnapToNearestOnEntry |
On attachment, start from the point of the path nearest the camera rather than from its beginning. Default on. |
Play(), Pause(), Seek(distance), SeekNormalized(fraction) |
Transport. Play at the end of a stopped open path restarts from the beginning. |
AddWaypoint(camera, mode, lookAt) |
Appends a waypoint at a camera's current pose, for building a path from a free camera. |
IsPlaying, PathDistance |
Current state. |
var animated = new AnimatedCameraController { DurationSec = 12f, OpenPathAnimationMode = CameraAnimationMode.PingPong };
animated.AddWaypoint(camera); // Fixed: keeps the camera's orientation
animated.AddWaypoint(camera, CameraWaypointOrientationMode.LookAtTarget, Vector3.Zero);
animated.AddWaypoint(camera, CameraWaypointOrientationMode.TangentFollow); // looks down the track
camera.Controller = animated;
animated.Play();
CameraPath
A centripetal Catmull-Rom spline through waypoints, re-parameterized by arc length, so equal distance steps move equal
world distances. At the default resolution a camera's speed stays within 0.15% of constant from frame to frame, even
through a tight turn between long segments, and Length matches the arc length to one part in 100,000. Orientation is
slerped between the resolved orientations of the two waypoints bracketing the sample.
Waypoints
CameraWaypoint factories: CreateFixed(position, orientation), CreateLookAtTarget(position, target),
CreateTangentFollow(position) and CreateFixedFromCamera(camera). Edit the path through AddWaypoint,
InsertWaypoint, SetWaypoint, RemoveWaypointAt and ClearWaypoints; Waypoints is a read-only view.
Every edit, and any change to Closed or WorldUp, marks the path dirty. The lookup tables are rebuilt lazily on the
next query, so there is no Rebuild to forget; call it only to pay the cost at a moment of your choosing.
Closedloops the path. It takes effect with at least three waypoints, andIsClosedreports the effective state.WorldUpis the up reference for look-at and tangent-follow orientations.LengthandSegmentCountdescribe the current path.- The constructor's
samplesPerSegment(default 32) sets the resolution of the arc-length table. Placement error falls more than tenfold each time it doubles, until single-precision rounding takes over at around 64; higher values mostly cost rebuild time.
Sampling
| Method | Returns |
|---|---|
SampleByPathDistance(distance), SampleByPathDistanceNormalized(fraction) |
A CameraPathPoint with Position, unit Tangent, Orientation and DistanceUnits. |
PositionByPathDistance(distance), PositionByPathDistanceNormalized(fraction) |
Position only. |
ClosestDistance(worldPosition) |
Path distance of the nearest point on the path: a coarse scan of the cached samples, then a golden-section refine. |
GetWaypointOrientation(index) |
A waypoint's resolved orientation, also for a lone waypoint. |
Distances are clamped to [0, Length]. A path with a single waypoint samples to that waypoint's position and
orientation.
Easing and holds
A waypoint can ease the camera out of and into it with any BaseShapingFunction from BorrowedTorch.ShapingFunctions,
read as the camera's speed over time, and keep it there a while:
EaseInshapes the departure: the first half of the segment to the next waypoint. The camera sets off from rest and its speed follows the curve, as a share of cruise speed, up to cruise where the curve reaches 1:Linearpicks up speed steadily,QuadraticEaseIngently at first,QuadraticEaseOutquickly at first.EaseOutshapes the arrival: the second half of the segment from the previous waypoint, at 1 minus the curve, so the camera slows from cruise to rest at the waypoint:Linearsteadily,QuadraticEaseOutsettling gently at the end,QuadraticEaseInbraking late.HoldSeckeeps the camera at the waypoint for that many seconds before it leaves: at the first waypoint before it sets off, at the last of an open path before the run ends.
// settle, wait two seconds, then move off
path.SetWaypoint(2, path.Waypoints[2] with { EaseOut = new QuadraticEaseOut(), HoldSec = 2f, EaseIn = new QuadraticEaseIn() });
Everywhere else the camera keeps a constant cruise speed, which every curve meets at cruise speed, so the speed never
jumps between halves. An eased half takes as long as its average speed needs to cover it: twice the cruise time for
Linear, three times for a quadratic ease-in leaving, four for a cubic, one and a half for a quadratic ease-out. A
curve that dips below 0 or rises past 1 on the way, such as a back or elastic ease, takes the speed past rest or cruise
for a while: leaving, it backs the camera up before it sets off, or runs it faster than cruise; arriving, it carries
the camera a little past the waypoint and back, or runs it faster. A half takes at most a hundred times the cruise
time, which every curve of the shaping functions library is well within - an elastic ease, the longest, takes about 70
- and a curve that all but stays at rest is held to it, meeting cruise with a jump. Replace a waypoint after changing its function's parameters, so the path retimes itself.
Holds are plain seconds, which the cruise speed does not change. With DurationSec set, the holds take their seconds
and travelling takes the rest, at least a tenth of the duration: holds that alone fill it make the run that much longer.
A closed path holds at its first waypoint once per lap, at the start of it. On a ping-pong turn the end waypoint's hold
is passed both ways, so the camera waits there twice as long.
| Method | Returns |
|---|---|
TravelTime(cruiseSpeed) |
Seconds one run takes at that cruise speed, easing and holds included: Length / cruiseSpeed without. |
CruiseSpeed(durationSec) |
The inverse: the cruise speed at which a run takes that long. AnimatedCameraController uses this. |
DistanceAtTime(seconds, cruiseSpeed) |
Path distance that many seconds into a run. |
TimeAtDistance(distance, cruiseSpeed) |
The inverse, for starting partway along; at a waypoint that holds, the time the camera arrives. |
SpeedAtTime(seconds, cruiseSpeed) |
The camera's speed then, read off the speed curve itself: 0 while holding, negative backing up. |
WaypointDistance(index) |
Where along the path a waypoint lies, exactly. |
WaypointArrivalTime(index, cruiseSpeed) |
When a run reaches a waypoint, before its hold - exact, also where an ease-out creeps in. |
WaypointDepartureTime(index, cruiseSpeed) |
When it leaves: the arrival plus the hold. |
EaseStretch(curve, arriving) (static) |
How many times the cruise time a half eased by a curve takes: the inverse of its average speed. |
Drawing a path
Set IsVisualized = true and read VisualGeometryBuffers each frame; it is refreshed lazily whenever the path or the
options changed. The buffers are plain data for your own line renderer:
| Buffer | Content |
|---|---|
Polyline |
Points along the curve, in order. |
Waypoints |
Waypoint positions. |
Gizmos |
GizmoCount orientation frames spaced evenly by arc length, each with Position, Right, Up and Forward. |
WaypointGizmos |
One orientation frame per waypoint. |
Tune with VisualOptions, a struct; assign a modified copy:
path.VisualOptions = path.VisualOptions with { IsAdaptive = true, ChordTolerance = 0.02f, GizmoCount = 24 };
IsAdaptive subdivides where the curve strays from its chord by more than ChordTolerance, bounded by
MaxSubdivisionDepth; otherwise PolylineSamples points are spaced evenly by arc length. Read the buffers through the
property rather than caching the instance, since that read is what triggers the rebuild.
CameraPathVisualizer.Build(path, buffers, options) fills buffers of your own.
Conventions
MonoGame's right-handed frame: +X right, +Y up, and the camera looks down -Z, so Vector3.Forward is (0, 0, -1).
Orientation maps local axes to world axes: camera.Forward == Vector3.Transform(Vector3.Forward, camera.Orientation).
Building and testing
dotnet test
The xUnit suite in Tests/ covers the camera, both projection kinds, both controllers, the path and the visualizer,
and needs no graphics device.
dotnet run -c Release --project Benchmarks
The BenchmarkDotNet suite in Benchmarks/ times what a path costs a game: PositionByPathDistance and
SampleByPathDistance per query, ClosestDistance, Rebuild and adaptive visualization. Append
-- --filter *Sample* to run a subset.
Changelog
2.5.1
- Depends on
BorrowedTorch.Animations1.1.0 instead of 1.0.0. No API changes.
2.5.0
- Compiled against MonoGame 3.8.1.303 instead of 3.8.0.1641, as every BorrowedTorch library that does not need the compute fork now is. A game needs MonoGame 3.8.1.303 or newer - DesktopGL, WindowsDX or BorrowedTorch's compute fork; 3.8.0 no longer loads it.
Camera.TowardViewer, path tangents and fixed waypoint orientations normalize throughBorrowedTorch.Math'sSafeNormalize, with the cutoff they had: shorter than 1e-6 counts as no direction. A waypointOrientationbetween 1e-6 and 1e-3 long is now normalized; it used to be replaced by identity.- A looping
AnimatedCameraControllerwraps its path distance withBorrowedTorch.Math'sWrap(0.3.0), which keeps it below the path's length where the old in-house version could round up to the length itself. The entry blend eases with MonoGame'sMathHelper.SmoothStepinstead of a copy of it. No public API changes.
2.4.0
Camera.ProjectionKindandCamera.OrthographicHeight: an orthographic projection beside the perspective one, a view that many world units tall at every depth (see Camera).Projection,UnjitteredProjection,JitterandScreenPointToRayfollow the kind; under orthographic the rays run parallel, alongForward, from each pixel's own point on the near plane. Perspective to start with, so nothing changes until it is set.Camera.ViewHeightAt(depth)andCamera.TowardViewer(worldPoint): the view's height at a depth and the direction back toward the viewer, under either kind - for what keeps a size on screen or faces the viewer.
2.3.0
- No longer depends on a MonoGame package: the library is compiled against MonoGame 3.8.0.1641 without passing it on,
so a game brings its own - DesktopGL, WindowsDX or BorrowedTorch's compute fork
(
BorrowedTorch.MonoGame.Framework.Compute.WindowsDX), any release from 3.8.0.1641 on. 2.2.0 and earlier brought the old compute forkMonoGame.Framework.Compute.WindowsDX.NoMemoryLeakwith them. A game that got MonoGame only through this package now references one itself. The API is unchanged.
2.2.0
Requires BorrowedTorch.Animations 1.0.0.
AnimatedCameraControllerplays its path onBorrowedTorch.Animations'AnimationTimelinerather than playback of its own; its members and modes are unchanged. A frame long enough to pass both ends of a ping-pong now turns round at each, where it used to land on the start; a frame of negative or non-finite seconds moves nothing.
2.1.0
Camera.JitterandCamera.UnjitteredProjection: a sub-pixel shift of the projection for temporal anti-aliasing, applied at once, and the projection without it (see Camera). Zero to start with, so nothing changes until it is set.
2.0.0
Breaking:
- A waypoint's easing curves are read as the camera's speed over time rather than its progress, so a curve picked is the
speed the camera keeps to (see Easing and holds). Leaving a waypoint (
EaseIn) the camera sets off from rest and its speed follows the curve up to cruise; arriving (EaseOut) it slows from cruise to rest at 1 minus the curve.Linearnow picks up or sheds speed steadily where it used to be the same as no easing; a quadratic ease-in leaving takes three times the cruise time rather than twice, a cubic four rather than three; and an ease-out picked to leave by now sets off from rest. Paths eased under 1.6.0 play differently and take longer. - The camera joins cruise travel at exactly cruise speed, with any curve. Under 1.6.0 it met it a little fast, by 5% with a cubic ease, and with a jump wherever a curve was steeper than eight there.
Added:
AnimatedCameraController.TimingandSpeedUnitsPerSec: a run timed by a set cruise speed instead of a duration, kept as the path changes length mid-run.CameraPath.WaypointDistance,WaypointArrivalTimeandWaypointDepartureTime, read off the path's own tables, so exact where finding a waypoint by position and timing it by distance comes out a little off - most where an ease-out creeps into it.CameraPath.SpeedAtTime, the camera's speed at a moment of a run, read off the speed curve.CameraPath.EaseStretch, how many times the cruise time a half segment eased by a curve takes, for whatever needs to show the timing.
1.6.0
Requires BorrowedTorch.ShapingFunctions 1.6.1.
- Waypoint easing:
CameraWaypoint.EaseInandEaseOuttake a shaping function each, easing the camera out of and into the waypoint over the half segments next to it, with the cruise speed kept everywhere else. - Waypoint holds:
CameraWaypoint.HoldSeckeeps the camera at a waypoint for that many seconds. See Easing and holds. CameraPath.TravelTime(cruiseSpeed)gives the duration of a run at a set speed andCruiseSpeed(durationSec)the speed for a set duration, easing and holds included;DistanceAtTimeandTimeAtDistancemap between time into a run and distance along the path.AnimatedCameraControlleradvances through the run's time rather than its distance. Without easing or holds, playback is unchanged;Seekand the snap to the nearest point on entry start the run at the matching point of its timing, holding first at a waypoint that holds.
1.5.1
Fixes:
AnimatedCameraControllerinStopmode no longer stops itself when a zero-length frame followsPlay()at the start of the path.- The end of a closed path, as sampled by
SampleByPathDistance(Length),SampleByPathDistanceNormalized(1)or a pausedSeek(Length), has the first waypoint's orientation instead of the second's. - Path tangents, and with them
TangentFolloworientations, no longer fall back toVector3.Forwardon segments shorter than about half a unit. ScreenPointToRaybuilds the ray from the camera's pose and projection instead of inverting the view-projection matrix. The direction is now accurate to 1e-7 rad; it used to be off by 4e-4 rad with the camera 200 units from the floating-origin offset under the default clip planes, and by more further out. The origin stays on the near plane whatever the viewport's depth range.CameraPath.Waypointscan no longer be cast back to the underlying list and edited without a rebuild.CameraWaypoint.CreateFixedFromCamerathrowsArgumentNullExceptionon a null camera.- Travel along a path is constant-speed. Distance used to map to the spline linearly between table samples, so the
camera's speed rippled with the curve's: by up to 4% from frame to frame around a tight turn at the default
resolution, and 10% for a slow camera. Distance now maps through a cubic Hermite that matches the exact rate at both
ends of each sample interval, keeping speed within 0.15% and position within 2e-4 units of exact arc-length placement
on the same path.
Lengthis integrated rather than summed from chords, and accurate to one part in 100,000 instead of one in 10,000. - Tangents come from the spline's analytic derivative instead of a finite difference.
Also: a test suite, a benchmark suite and a 128×128 package icon. SampleByPathDistance evaluates the spline once
instead of three times and is about 13% faster; Rebuild is about twice as slow (11 µs for an eight-waypoint path) to
build the finer table, and ClosestDistance about 6% slower. Waypoint orientations are resolved once per rebuild rather than on every
GetWaypointOrientation call, adaptive visualization evaluates each seed point once, and gizmo frames come from a
single rotation matrix.
1.5.0
Requires BerylliumMath 0.2.0.
Fixes:
CameraPathno longer throws whenRebuildwas not called after an edit or after togglingClosed; it rebuilds itself.- A lone tangent-follow waypoint no longer throws when visualized, and a lone look-at waypoint shows its resolved orientation.
ClosestDistancerefines within the true neighbouring samples, so it no longer misses the nearest point on long segments, and it handles the seam of a closed path.Camera.Controller = nulldetaches instead of throwing, andApplyToand the property setter both sync the controller exactly once.LookAttowards a target straight along the up vector yields a valid orientation instead of NaN.- Ping-pong no longer leaves a reversed direction behind when the mode changes.
Breaking:
CameraPath.Waypointsis read-only; use the editing methods.CameraPath.VisualOptionsis a property; assign a copy.AnimatedCameraController.Pathcannot be null, andAddWaypointthrows on a null camera.- Projection parameters and
Orientationare validated in their setters. FreeCameraController.Movecaps the summed input at unit length instead of normalizing it.- Nullable reference types are enabled;
Camera.ControllerisBaseCameraController?.
Also: cached basis vectors and path samples, a cheaper view matrix and picking path, and XML documentation shipped in the package.
License
MIT
| Product | Versions Compatible and additional computed target framework versions. |
|---|---|
| .NET | net10.0-windows7.0 is compatible. |
-
net10.0-windows7.0
- BorrowedTorch.Animations (>= 1.1.0)
- BorrowedTorch.Math (>= 0.3.0)
- BorrowedTorch.ShapingFunctions (>= 1.6.1)
NuGet packages (3)
Showing the top 3 NuGet packages that depend on BorrowedTorch.Camera:
| Package | Downloads |
|---|---|
|
BorrowedTorch.TransformGizmo
A screen-sized move / rotate / scale gizmo for MonoGame: drawing, picking and dragging, with per-target flags for which modes are offered, whether move and rotate work in world or local space, and which axes rotate turns about. |
|
|
BorrowedTorch.SceneGizmo
A world-orientation gizmo for MonoGame: a small X / Y / Z widget pinned to a screen corner that turns with the camera, with hover highlight and axis picking for snapping the view. |
|
|
BorrowedTorch.Engine
Kindling, Borrowed Torch's game engine: what a game's own code builds against - its features registering components, systems, keys and UI handlers - for the Kindling editor and player to run |
GitHub repositories
This package is not used by any popular GitHub repositories.