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
                    
This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package.
<PackageReference Include="BorrowedTorch.Camera" Version="2.5.1" />
                    
For projects that support PackageReference, copy this XML node into the project file to reference the package.
<PackageVersion Include="BorrowedTorch.Camera" Version="2.5.1" />
                    
Directory.Packages.props
<PackageReference Include="BorrowedTorch.Camera" />
                    
Project file
For projects that support Central Package Management (CPM), copy this XML node into the solution Directory.Packages.props file to version the package.
paket add BorrowedTorch.Camera --version 2.5.1
                    
#r "nuget: BorrowedTorch.Camera, 2.5.1"
                    
#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package.
#:package BorrowedTorch.Camera@2.5.1
                    
#:package directive can be used in C# file-based apps starting in .NET 10 preview 4. Copy this into a .cs file before any lines of code to reference the package.
#addin nuget:?package=BorrowedTorch.Camera&version=2.5.1
                    
Install as a Cake Addin
#tool nuget:?package=BorrowedTorch.Camera&version=2.5.1
                    
Install as a Cake Tool

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 along worldUp still yields a valid orientation.

  • ProjectionKind is Perspective (the default), through a lens of FieldOfViewDegrees, or Orthographic, along parallel lines: a view OrthographicHeight world units tall at every depth (10 to start with) and that times AspectRatio wide, so what is further off keeps its size on screen - for 2D games, plans and elevations. Both map view depth NearPlane..FarPlane to 0..1, the orthographic one linearly. IsOrthographic says which. Under orthographic FieldOfViewDegrees shapes 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 next Update, 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-space Ray from the near plane through the pixel: under perspective the rays fan out from the eye, under orthographic each runs along Forward from the pixel's own point on the near plane. It is computed from the current pose and projection parameters, so it needs no Update after 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 and OrthographicHeight at 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: toward Position under perspective, -Forward everywhere under orthographic - for what faces the viewer, such as billboards, rings and drag planes.

  • Jitter shifts the whole image on screen by a fraction of a pixel, in normalized device coordinates (a pixel is 2 / width by 2 / height), for temporal anti-aliasing: Projection is UnjitteredProjection translated by it in clip space, taken at once without an Update, so it can be set for one pass of a frame and back for the next. UnjitteredProjection is 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. ScreenPointToRay ignores it. A non-finite jitter throws ArgumentException.

  • Validation. FieldOfViewDegrees must lie strictly between 0 and 180, and AspectRatio, NearPlane, FarPlane and OrthographicHeight must be positive and finite; each setter throws ArgumentOutOfRangeException otherwise, as does a ProjectionKind that is not one of the two. A near plane not less than the far plane throws InvalidOperationException from Update. Orientation rejects 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.

  • Closed loops the path. It takes effect with at least three waypoints, and IsClosed reports the effective state.
  • WorldUp is the up reference for look-at and tangent-follow orientations.
  • Length and SegmentCount describe 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:

  • EaseIn shapes 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: Linear picks up speed steadily, QuadraticEaseIn gently at first, QuadraticEaseOut quickly at first.
  • EaseOut shapes 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: Linear steadily, QuadraticEaseOut settling gently at the end, QuadraticEaseIn braking late.
  • HoldSec keeps 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.Animations 1.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 through BorrowedTorch.Math's SafeNormalize, with the cutoff they had: shorter than 1e-6 counts as no direction. A waypoint Orientation between 1e-6 and 1e-3 long is now normalized; it used to be replaced by identity.
  • A looping AnimatedCameraController wraps its path distance with BorrowedTorch.Math's Wrap (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's MathHelper.SmoothStep instead of a copy of it. No public API changes.

2.4.0

  • Camera.ProjectionKind and Camera.OrthographicHeight: an orthographic projection beside the perspective one, a view that many world units tall at every depth (see Camera). Projection, UnjitteredProjection, Jitter and ScreenPointToRay follow the kind; under orthographic the rays run parallel, along Forward, from each pixel's own point on the near plane. Perspective to start with, so nothing changes until it is set.
  • Camera.ViewHeightAt(depth) and Camera.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 fork MonoGame.Framework.Compute.WindowsDX.NoMemoryLeak with 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.

  • AnimatedCameraController plays its path on BorrowedTorch.Animations' AnimationTimeline rather 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.Jitter and Camera.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. Linear now 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.Timing and SpeedUnitsPerSec: a run timed by a set cruise speed instead of a duration, kept as the path changes length mid-run.
  • CameraPath.WaypointDistance, WaypointArrivalTime and WaypointDepartureTime, 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.EaseIn and EaseOut take 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.HoldSec keeps 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 and CruiseSpeed(durationSec) the speed for a set duration, easing and holds included; DistanceAtTime and TimeAtDistance map between time into a run and distance along the path.
  • AnimatedCameraController advances through the run's time rather than its distance. Without easing or holds, playback is unchanged; Seek and 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:

  • AnimatedCameraController in Stop mode no longer stops itself when a zero-length frame follows Play() at the start of the path.
  • The end of a closed path, as sampled by SampleByPathDistance(Length), SampleByPathDistanceNormalized(1) or a paused Seek(Length), has the first waypoint's orientation instead of the second's.
  • Path tangents, and with them TangentFollow orientations, no longer fall back to Vector3.Forward on segments shorter than about half a unit.
  • ScreenPointToRay builds 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.Waypoints can no longer be cast back to the underlying list and edited without a rebuild.
  • CameraWaypoint.CreateFixedFromCamera throws ArgumentNullException on 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. Length is 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:

  • CameraPath no longer throws when Rebuild was not called after an edit or after toggling Closed; it rebuilds itself.
  • A lone tangent-follow waypoint no longer throws when visualized, and a lone look-at waypoint shows its resolved orientation.
  • ClosestDistance refines 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 = null detaches instead of throwing, and ApplyTo and the property setter both sync the controller exactly once.
  • LookAt towards 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.Waypoints is read-only; use the editing methods.
  • CameraPath.VisualOptions is a property; assign a copy.
  • AnimatedCameraController.Path cannot be null, and AddWaypoint throws on a null camera.
  • Projection parameters and Orientation are validated in their setters.
  • FreeCameraController.Move caps the summed input at unit length instead of normalizing it.
  • Nullable reference types are enabled; Camera.Controller is BaseCameraController?.

Also: cached basis vectors and path samples, a cheaper view matrix and picking path, and XML documentation shipped in the package.

License

MIT

Product Compatible and additional computed target framework versions.
.NET net10.0-windows7.0 is compatible. 
Compatible target framework(s)
Included target framework(s) (in package)
Learn more about Target Frameworks and .NET Standard.

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.

Version Downloads Last Updated
2.5.1 66 11/18/2026
2.5.0 61 11/18/2026
2.4.0 151 11/16/2026
2.3.0 124 11/14/2026
2.2.0 97 11/9/2026
2.1.0 99 11/3/2026
2.0.0 106 10/30/2026
1.6.0 104 10/29/2026
1.5.2 142 10/14/2026