CamSequencer
2.0.0A Camera COMP that sequences camera moves.
Two sequencers inside — one for the camera, one for the Look At target. Free flight, orbit, picking, zoom, viewport mode, the dutch tilt, surface collision.
The camera →
FOR TOUCHDESIGNER
Camera moves,
Camera moves,
as presets.
CamSequencer is a Camera COMP with two sequencers inside. Frame a shot and press Append. Move, append again. Then scrub one number — or drive it from a CHOP, or a gamepad — and the camera travels your shots with the easing, splines and rotation blending you chose.
It is one of four components on the same engine. GeoPilot flies the body — a drone, an aircraft, a person on foot, a car — OpSequencer sequences any operator at all, and MixSequencer sequences the blends between them.
The family
Four components, one engine
They all keep the same thing: a table of presets, and one number that walks it. Learn the Seq page once and you know all four. What differs is what each one points at.
GeoPilot
1.1.0A Geometry COMP that flies itself.
The body, not the camera: a drone, an aircraft, a person on foot or a car. Walking, driving, forces and assisted flight, over ground contact that finds the floor.
The body →OpSequencer
The engineThe same preset engine, pointed at any operator.
Drag the parameters you care about onto it and they become preset columns. Everything the other three do with presets, they do because this does.
Any operator →MixSequencer
In developmentStep-sequenced weight scenes.
Each step is a blend of presets rather than one of them. Any-to-any sequencing, in any order, turns out to be the special case where every step picks exactly one.
The matrix →The body carries the car, the head carries the eyes
Until 2.0, CamSequencer flew the camera itself — and its flight models grew up flying a camera and turned out to be bodies all along. So they moved. Walking, driving, forces, assisted flight, aerobatics and ground contact are GeoPilot's now, where they fly anything rather than only a lens, carrying the same mapping, the same pages and the same measured numbers.
The two then compose, and there are only two ways to join them: wire the camera under the pilot, or point its Source at the pilot's head bus and map by channel name. Neither needs a line of Python. Nothing forces you to use both — GeoPilot never needs a camera, and CamSequencer never needs a body.
Quick start
Four steps to a moving camera
No CHOP network, no expressions, no keyframes to babysit. The component is the camera.
1
Drop it in
Drag camSequencer.tox into your project and point your Render TOP at it. It is a Camera COMP — it renders like any other.
2
Append shots
Frame the camera, press Append. Move it, press Append again. Each press captures the full pose and lens as a preset row.
3
Scrub Select
Whole numbers recall a preset exactly. Fractions blend into the next one. The sequence wraps, so the last shot flows back into the first.
4
Drive it
Export a CHOP to Select, animate it, or plug in a controller and fly the camera yourself — capturing new presets from the pad.
The Seq page
One number moves the camera
Every control below is a real parameter. Drag the left view to orbit the director's camera; the right view is what the sequenced camera actually renders.
Select is continuous
There is no timeline and no keyframe track. Select is one float. At
2.0 the camera sits exactly on preset 2; at 2.5 it is halfway into
preset 3. Past the end it wraps back to 0, so a slowly ramping LFO is a permanent camera move.
Because it is only a number, everything can drive it at once — a CHOP export, a Python call, a click in the preset list, a bumper on a gamepad. Nothing is bound or exported behind your back.
Easing per preset, or one for all
Each preset row carries its own EASE cell, and the blend into a preset uses
that preset's easing — so a shot can ease in gently while the next one snaps.
Flip Override and the Easing menu wins for every segment instead, which is the
faster way to audition a feel across a whole sequence. Thirty-one curves ship, from
Linear to InOutElastic, plus a CustomEase slot for a
curve you draw yourself.
Rotation Blend
The 350-degree problem
Two poses ten degrees apart can be written as 0 and 350. Eased channel by
channel, that is a 350-degree whip. Quaternions let you say which one you meant.
Three modes, one menu
- Euler (legacy) — every rotation channel eased on its own. What the sequencer always did, kept so existing projects do not change under you.
- Slerp (shortest) — a quaternion blend along the shortest arc. A 0 → 350 yaw turns −10, not +350.
- Slerp (preserve winding) — a quaternion blend that keeps a sweep past 180 degrees going the long way round, for when the whip was the point.
Single angle parameters — roll, or a lone rotation axis — take the shortest arc in the Slerp modes too.
It finds the triples itself
Rotation columns are detected by name, in any case and any spelling the parameter uses:
Rx Ry Rz, Rotx Roty Rotz, Rotate…. You do not tag anything.
Spline Interpolation and Rotation Blend never fight: rotation triples are held out of the spline and always resolved by the rotation mode, so a smooth positional curve and a correct turn are not a trade-off.
With a Look At target set, the target fixes the camera's aim — rotation presets still swing the camera around its pivot and set roll.
Viewport mode
It sequences the palette cameraViewport too
That camera has no tx/ty/tz — its pose is a matrix plus a tumble pivot. Drop this
component inside one and it records the pose and the pivot, so a recalled preset tumbles
around the point you saved it with.
- Two ways in — drop it inside a cameraViewport, or point Camera Viewport at one.
- Its own presets — viewport mode reads a separate table. A mode switch never touches the other one.
- Follow Viewport — this camera renders the viewport's view, so one Render TOP works in either mode.
How the pose actually gets there
The Viewport page mirrors the viewport's pose in both directions without echo, and the camera sequencer reads and writes that mirror. The viewport's Transform DAT is borrowed while linked and handed back when you leave — if it already points elsewhere, the link is refused with a warning rather than silently taken.
Control page
Fly the camera, then keep the shot
Everything the pad does is applied to the live camera; presets only change when you press Capture. The tour below runs a fixed sequence — the control in use lights up on the diagram as you watch what it does to the shot.
Fly modes
- Free-fly — FPS / drone. Forward and Strafe move along the camera's own axes, Rise is world up, Yaw and Pitch turn in place. Pitch stops short of straight up and down.
- Look At — a target locks the aim and nothing else. The left stick still flies anywhere at full speed; you can pass the subject or go straight through it. The right stick has no view left to turn, so it works on the subject instead: Yaw takes you round it at your current radius, Pitch reels you in and lets you back out.
- Orbit — pinned to a sphere: every axis is an angle round, an angle above, or the distance. It needs a real pivot — a Look At or a picked point — and flies free when there is none rather than tumbling around nothing.
Which stick you touch decides what you are doing. That leaves one thing only Orbit can do: arc over the top at a fixed radius. Rise is a translation, so it grows your distance as it lifts you — 5.05 units becomes 6.61 in a second.
The pivot is whichever exists first: the viewport's tumble pivot, then the Look At target, then a point Orbit Distance ahead of the camera.
Picking — what you are looking at
- Orbit is held, never latched. On press, the point you are looking at becomes the pivot; while held you tumble around it; let go and you are free again from wherever that left you. The pivot lives as long as the button, so there is nothing to reset.
- Look At Pick tethers the aim to the object under the crosshair. Press again to release.
- Teleport jumps to the point you are looking at, Teleport Distance off the surface along its normal, orientation kept.
- Surface Collision stops you Stand-off short of whatever you are moving into — new in 2.0.
A Render Pick CHOP samples the centre pixel of your Render TOP for world position, surface normal and the object hit — which is why it sees POPs, GPU displacement and instancing, where a Ray SOP would only ever see CPU-side geometry.
The old Wall Collision walked; this one flies. The probe fires along the direction you are actually moving, so descending into terrain lands on it exactly the way flying into a wall always did, and a climb can meet a ceiling. Stand-off is measured perpendicular to the surface rather than along the ray, and the slide keeps the part of your motion that runs along it.
It guards flown motion only, and deliberately: a preset recall, a Teleport or a hand on the parameters stays sovereign and goes exactly where you put it.
Stand-off can never be zero
The floor is 0.05, and it is not arbitrary. A camera allowed to land exactly on a
surface picks the far side of it on the next frame and walks straight through. Keep
Stand-off above your Near clip too, or the surface is clipped away the moment you arrive.
Surface Collision costs one extra pick render per frame while you are actually moving; with it off,
picking costs nothing at all until a button asks for it.
Roll stayed here in 2.0 — as the dutch tilt it always was. The bank of a moving body,
leaning into its turns, is GeoPilot's now, and a camera wired under a
banking pilot composits the two through the wire. That is a shot the single-rz world
could not make. Turbulence stayed too: it is shot dressing, not physics, and it no longer needs a
flight model switched on to work.
GeoPilot 1.1.0 · a component of its own
A Geometry COMP that flies itself
Map a game controller by learning, and the component's own transform becomes a drone, an aircraft, a person on foot or a car. Parent your geometry inside it, or wire your model underneath — it is a Geo COMP. It flies anything, and it never needs a camera.
Switch models on the demo below and the controls change with it, the way the pages do in the component. Under Driving, turn Grip on and watch the corner open out — the wheel is still asking for the same radius. Under Walking, wait for the walker to stop: the head stops with it, because the bob rides on distance covered rather than on a clock.
Five models, one menu
- Off — the sticks move the body directly. A tripod on rails, which is what you want when the shot is the point.
- Assisted — the angle model. Banks into its turns, steers by rolling, settles the nose back toward the horizon, carries glide momentum. Cosmetic and predictable, which is often exactly what a camera move wants.
- Forces — thrust, lift, drag, weight and control moments. It owns the pose outright and lets the angles be whatever falls out. Arcade, Standard and Sim airframes.
- Walking — a person on foot: walk, sprint, crouch and jump, with head bob riding on distance covered rather than on a clock.
- Driving — a car: throttle and brake on Forward, the steering wheel on Strafe, and the driver's head free on Yaw and Pitch.
One menu, because only one of them can move the body. Ground contact runs underneath all of them as a layer, never as a mode — which is what lets a flying body follow terrain with no walking model in sight.
Walking and driving are not flying with bits removed
On foot, Forward and Strafe are the feet: they run on the ground plane and never along the gaze, so looking down does not walk you into the floor. Rise and Zoom do nothing at all — levitating is not something feet do, and the way off the ground is Jump.
In a car, Strafe stops meaning strafe and becomes the wheel. Yaw and Pitch stop being the heading and become the driver's head, free to look about the cabin while the car goes on going where the wheels point, and returning to the road by itself when you let go. A walker's facing and heading are one thing; a driver's are two, and that is the whole shape of the model.
Under Grip the tyres have a finite hold: ask a corner for more than they have and the car understeers onto the radius they can actually keep, opening a slip angle you can catch on the stick. A stated 6.0 corner opens out to 6.996 rather than sliding on rails.
The camera couples — it never lives inside
The coupling is a spectrum rather than a switch, and the wire is the setup:
- Rigid — wire a camera under the pilot. TouchDesigner composits the transforms natively; you are in the car.
- Chase — the camera trails the body on a spring, looking up the road past it. Model-agnostic: chase a walker, chase the plane.
- Aim Only — a tripod panning to follow the car.
- Free — no relationship at all. A valid answer.
A coupled camera keeps its own presets, and they live in the body's frame — so "over the left shoulder" composes with wherever the body went. The body carries the car, the head carries the eyes, and the wire composits the two.
Two CHOP buses, so the rest of the patch can watch
The pilot publishes what it does not consume. null_headbus carries the axes and
button pulses a coupled camera should have — point a CamSequencer's Source at it and map by
channel name, with nothing to learn.
null_statebus carries what the body is doing: speed, grounded, airborne,
bank, model index. HUDs, engine audio, camera shake — anything in your network can react to the
body without a line of Python coupling.
Recalls are sovereign
A preset recall, or a hand on the transform, beats every model. A jump larger than the motion could explain drops the carried momentum and the model takes up the pose it finds — the car adopts the recalled heading and drives on from there.
That order is deliberate, and it is the whole philosophy of the thing: this is a rig for sequencers before it is a simulator. The body's own memory is an ordinary OpSequencer pointed at its transform, so easing, per-parameter overrides, Spline and Mix apply to a body exactly as they apply to anything else.
Measured, not felt
- Driving — reaches Top Speed in exactly Accelerate seconds, and a stated Turn Radius of 6.0 traces at 6.000 — identically at 30, 60 and 120 fps.
- Walking — the jump arc lands within 0.04% of Jump Height at every frame rate, and a fall can never pass through the floor. Drops of 2000 units land.
- Forces — turn rate matches
g·tan(φ)/vto 0.03%, a formula that appears nowhere in the code. A loop conserves energy to 0.20%. - Aerobatic — a full loop round-trips its orientation at dot 1.000004, so presets record and recall through the top of it.
The stall deserves its own line: it is the lift curve, not a speed test. Zoom-climb, run out of speed at the top, and the nose drops on its own. Nobody wrote that recovery.
Learn mapping
Nothing is hard-wired to a pad layout
Press Learn, move the control. An Xbox pad, a DualShock, a MIDI surface and an OSC app all map the same way, because you teach it rather than match it.
- Any CHOP is the source — the internal Joystick CHOP by default, or a MIDI In, OSC In, Keyboard In, or one you build.
- An axis is a stick or a pair — one bipolar control, or two one-way ones: the triggers for Rise, the bumpers for Scrub.
- Every control keeps its own rest — a trigger resting at
−1works beside a stick resting at0, in the same mapping.
How an axis learn resolves
Pressing Learn snapshots every source channel; the first to travel more than 0.3
from its snapshot is mapped as +. A button is finished there. An axis keeps
listening: press the opposite control and it becomes −, or release and move
the same one again — or wait out Learn Timeout — to keep it bipolar.
Two rules came from real hardware. A release back to rest never counts as a move, so a trigger pair is never mistaken for a stick; and a control that keeps twitching after it crossed the threshold only counts again once it has actually returned to rest.
Action+ channel− channelrest
Forwardly—0.00
Yawrx—0.00
Riser2l2−1.00
Scrubb6b50.00
Captureb1—0.00
Preset Channelsb9 b10 b11 b12
The rest of the family
Any operator, not just a camera
CamSequencer is the camera-shaped one. OpSequencer is the same engine pointed at any TouchDesigner operator — drag the parameters you care about onto it and they become preset columns.
You choose the columns
Drop an operator on the panel, or point the OP parameter at one. Then drag
parameters straight from its parameter dialog onto the panel — each becomes a column in the
preset table. Pulse, momentary and sequence parameters are skipped, because they cannot hold a
value worth recalling.
ALT + drop starts fresh and captures every parameter of the operator at once, for when you would rather subtract than add.
Menus, toggles and strings cannot be blended, so they switch at the midpoint of a transition rather than being dropped.
Angles that know they are angles
The demo above defaults to Periodic Columns on. Turn it off and watch
Hue travel from 350° to 10°: instead of crossing zero and landing 20 degrees away,
it sweeps backwards through every other colour on the wheel.
rotate, roll, angle*, hue* and a lone
rotation axis are detected as degrees; phase* as 0..1. Anything else you add
yourself as name or name:period — Twist Offset:1.
Rotation triples get the same treatment through Rotation Groups: name the base
and Spinx Spiny Spinz blends as a quaternion like any other rotation.
OpSequencer
One target operator, any number of preset states.
Presets are a tableReadable, editable in place, and version-controllable as a plain DAT.
SelectDrive it from an LFO, Timer or Beat CHOP for automatic sequencing. It wraps.
31 curves + CustomEaseCustomEase reads the CHOP wired into the component — an S-curve by default.
Spline InterpolationA periodic cubic through every preset. Around 6× cheaper on big tables than it was.
Rotation Blend + GroupsQuaternion blending, and you can name your own x/y/z tuplet bases.
Periodic ColumnsHue, phase, rotate and roll take the shortest arc across the wrap.
AnyToAnyMorph Preset A → Preset B directly, driven by Select from 0 to 1.
BindOff stops the sequencer writing to the operator, keeping the values it left.
The listClick to recall, drag to reorder, middle-click a header to drop that column.
Nothing is lostReset and Prune stash the table first;
RestorePresets() brings it back.One engine, four shapes
Learn the Seq page once and you know all of them. CamSequencer is it pointed at a camera, GeoPilot at a body, MixSequencer at the blends between presets — and OpSequencer at whatever you like.
MixSequencer 1.0.0 · in development
When a step is a blend, not a preset
A sequencer of mixes. Each step is a weight vector over another sequencer's presets; the playhead scrubs the steps and crossfades between them with that step's own easing, and the result rides out as one channel per preset — straight into any sequencer's Weights CHOP.
Any-to-any is the one-hot case
Give a step a single 1.0 and it recalls that preset. A run of those steps is a cue
list in any order you like, whose transitions are ordinary Mix-mode crossfades — following exactly
the same arc as the pairwise A→B mode, verified to 1e-6. Nothing is lost by getting
there the general way.
Paint several weights into a step and the same playhead sequences blends instead. Sit a step at 0.5 / 0.5 and the sequence morphs through it like any other step. An all-zero step writes nothing at all, which makes it an explicit hold.
One playhead, several components
The output is just a CHOP, so one matrix can drive several sequencers at once — a CamSequencer's mix and a GeoPilot body's inner sequencer together. One playhead then recalls a whole multi-component shot: where the body is, and where the camera is looking, in one number.
And nothing in it owns a clock. Drive Step Select from an LFO, a Timer, a Beat CHOP or your own hand — the same as every other playhead in the family.
Not released yet
MixSequencer is on its feature branch and being built now, so there is no download for it on this page. It is here because it is the fourth shape the engine takes, and because the family is easier to understand with it in view than without.
What is in each box
Feature catalog
CamSequencer 2.0.0 — eight parameter pages. GeoPilot 1.1.0 — ten, five of them the model pages that moved across at the split.
Sequencing
The Seq page. Every control drives both inner sequencers at once.
Append / Replace / Insert / RemoveCapture, overwrite, splice or drop a preset from the current camera state.
SelectThe playhead. Whole numbers recall, fractions blend, and it wraps.
31 easing curvesPer-preset in the
EASE column, or one for all with Override.Spline InterpolationA closed periodic cubic through every preset. Solved once for all columns.
Rotation BlendEuler, quaternion shortest-arc, or quaternion with the winding preserved.
AnyToAnyBlend between any two chosen presets, A and B, instead of neighbours.
Look At sequencerA second sequencer moves the target while the camera keeps aiming at it.
CallbacksA callbacks DAT fires as presets are recalled, including the A/B edges.
Presets
Where the shots live, and how they move with your project.
External preset tablesCreate clones the table next to the component, so presets are relocatable and externalizable.
Per-mode tablesCamera Presets, Viewport Presets and Look At Presets, each independent.
Live listsClick a row to recall it, drag rows to reorder, middle-click a header to drop that column.
Prune Stale ColumnsReports columns whose parameter no longer exists, and can drop them.
Nothing is lostReset and Prune stash the table first;
RestorePresets() brings it back.0-based indexesThe number in the list is the number Select uses. They renumber immediately.
Control
Fly the camera from a controller — or any CHOP at all.
Learn everythingMove the control to map it. No pad profiles, no channel-name contract.
Axis pairsOne bipolar stick, or two one-way controls, each with its own resting value.
Free-fly and OrbitPivot-aware in both normal and viewport mode.
Zoom that fitsDrives FOV, Focal Length or Ortho Width — whichever the projection really uses.
Reset PivotZeroes the camera's pivot without moving the view, so a turn is a turn in place.
Sequencer from the padNext, Prev, Capture, direct preset buttons and a rate-mode Scrub axis.
Expressions surviveOnly constant-mode parameters are written. An expression or bind you put on one is left alone.
ActiveMutes every mapped control without losing the mapping.
Picking
A centre-pixel Render Pick through the render this camera renders through.
Hold to orbitPress, and what you are looking at becomes the pivot for as long as you hold.
Look At PickTethers the aim to the object hit. Press again to release.
TeleportJump to the surface, standing off along its normal, orientation kept.
CollisionStops short of what is ahead. Frustum only, and honest about it.
Auto-detected Render TOPLeave it empty and the first Render TOP pointed at this camera is used.
Off the critical pathWith collision off, picking costs nothing until a button asks for it.
GeoPilot · the body
A Geo COMP of its own. Five model pages, ground contact and a coupling surface.
WalkingWalk, sprint, crouch and jump. The jump is height and rise time; gravity is derived, never dialled.
DrivingThrottle and brake on Forward, the wheel on Strafe, the driver's head free. Arcade or Grip tyres.
ForcesThrust, lift, drag, weight and moments. Arcade, Standard and Sim airframes. The stall is emergent.
AssistedThe angle model: bank into turns, bank-steer, auto-level, glide momentum.
AerobaticOrientation carried as a matrix, so a loop is more of the same rotation, not a special case.
Ground contactA downward probe render finds the floor — POPs and displacement included. A layer, not a mode.
Slope align and Max SlopeLean with the road, and refuse a climb the way collision refuses a wall.
CouplingRigid, chase spring, aim-only or free. The wire is the setup.
Head and state busesTwo CHOPs: the axes a camera should have, and what the body is doing. No Python coupling.
Body presetsAn inner OpSequencer on its own transform — and recalls beat the physics, always.
One mapping, five modelsThe same learn protocol as CamSequencer. Teach it once and every model is mapped.
Capture fan-out and Select Sync1.1.0: one press grows body and look tables together; one playhead can recall the whole shot.
Python
Everything the UI does, you can call
Promoted on the component, so op('camSequencer1') reaches all of it.
# ── The sequence ───────────────────────────────────────────────
cam = op('camSequencer1')
cam.par.Select = 2.5 # halfway from preset 2 into preset 3
cam.Capture() # append a preset from the current state
cam.Step(+1) # next whole preset, wrapping
cam.GoTo(0) # recall preset 0
# ── Flying and picking ─────────────────────────────────────────
cam.Learn('Forward') # start a learn; move the control to map it
cam.StopLearn()
cam.OrbitStart(); cam.OrbitEnd() # the held pivot, from code
cam.LookAtPick() # tether the aim to the object hit
cam.Teleport()
cam.ResetPivot()
cam.RenderTop # the Render TOP actually in use
# ── Viewport mode ──────────────────────────────────────────────
cam.Viewport # the linked cameraViewport, or None
cam.InViewportMode, cam.Linked
cam.PullFromCamera() # read the viewport's pose into the mirror pars
cam.PushToCamera() # write the mirror pars back to the viewport
cam.ApplyMode()
What's new
Release notes
CamSequencer 2.0.0
2026-08
CURRENT
- The bodies moved out. Everything that was a body rather than a camera — the Assisted, Forces, Walking and Driving models, Aerobatic, ground contact, wall collision and head bob — is now GeoPilot, a Geometry COMP that flies anything with the same mapping, the same pages and the same measured numbers. This is a breaking change, and it is the reason for the major version.
- Surface Collision replaces Wall Collision. The old one walked; this one flies — the probe fires along the direction you are actually moving, so descending into terrain lands on it the way flying into a wall always did, and a climb can meet a ceiling. Perpendicular stand-off, with a slide that keeps the motion running along the surface.
- What stayed is the camera-authoring kit — free flight, orbit, Look At, picking, zoom, viewport mode, the sequencer. Roll stayed as the dutch tilt it always was; the bank of a moving body is GeoPilot's now, and a camera wired under a banking pilot composits both through the wire.
- Turbulence stayed too, on the Control page — it is shot dressing, not physics, and it no longer needs a flight model switched on to work.
GeoPilot 1.1.0
2026-08
NEW COMPONENT
- A Geometry COMP that flies itself — five control models over ground contact, a learn-mapped controller, an inner sequencer for the body's own presets, and two CHOP buses publishing what it does not consume.
- Coupling is a spectrum — rigid by wire, a chase spring, aim-only, or free. A coupled camera's presets live in the body's frame, so "over the left shoulder" composes with wherever the body went.
- 1.1.0 — one press, whole shot. Capture Body Preset grows the body and look tables together, indices in step; Select Sync binds the two playheads so one number recalls both, fractional blends included. Both opt-in, because body and look are separate tables on purpose.
- The numbers came across intact — Driving reaches Top Speed in exactly Accelerate seconds and traces a stated 6.0 turn radius at 6.000; Walking's jump lands within 0.04% of Jump Height; a full aerobatic loop round-trips its orientation at dot 1.000004.
1.5 – 1.15
2026-08
- The flight models grew up. Airplane Feel, the energy model and the force model became one Flight Model menu — because only one of them can move the camera, and a menu cannot be in two states at once. The energy model was retired when the force model did all of it from the forces themselves.
- A walking simulator, then a driving one: feet on the ground plane with an exact-parabola jump, then a car with the wheel on Strafe and the driver's head free. Both over a ground page that finds the floor with a probe render rather than a ray, so it sees POPs and displacement.
- Per-parameter easing — one curve per cell, chosen from the list, with an easing strip in the panel.
- All of it now lives in GeoPilot. It is listed here because this is where it shipped.
1.4.0
2026-08
- Flight page — Airplane Feel: bank into turns, with separate times for rolling in and rolling out; Bank Steers for a real coordinated turn, calibrated at your own Bank Angle; Auto-Level Roll, Level Pitch, Control Smoothing, Speed-Scaled Turning, Glide and Turbulence. Each one stands down where a Look At or an orbit already owns the angles.
- Roll — a Roll axis with its own speed, an optional gated modifier so one control can serve two jobs, and Level Horizon to take the bank straight back out.
- Look At flies free — a target now locks the aim and nothing else. The left stick goes anywhere at full speed; the right stick takes you round the subject and reels it in. Level Heading keeps a target above or below you from quietly baking a climb into "forward".
- Orbit needs a pivot — Fly Mode = Orbit requires a Look At or a picked point, and flies free when there is none. Strafe and Rise became the arc and the elevation at constant radius, so every axis on the sphere means one thing.
- Dolly Speed — closing on a subject is a shorter journey than crossing a room, and now has its own speed.
- Look At Pick aims at what you picked, not at the object's origin — carried with the object's live geometry, so a subject moved by a SOP stays framed.
1.3.0
2026-08
- Control page — fly the camera from a joystick, gamepad or any CHOP. Learn-mapped controls, so any pad layout works; axes are a stick or a pair of one-way controls, with per-control resting values. Free-fly or Orbit, pivot-aware, in normal and viewport mode; Zoom drives FOV, focal length or ortho width as the projection dictates; Reset Pivot.
- Picking through the Render TOP — hold Orbit to tumble around what you are looking at, Look At Pick to tether the aim to the object hit, Teleport to jump there, Collision to stop short of it.
- Sequencer from the same pad — Next, Prev, Capture, preset buttons and a rate-mode Scrub axis.
1.2.0
2026-08
- Viewport mode — sequence a palette cameraViewport, by dropping the component inside one or by setting Camera Viewport. Position, rotation, tumble pivot and FOV are recorded, and quaternion rotation blending applies. Follow Viewport renders the viewport's view through this camera.
- Viewport mode has its own Viewport Presets table; Camera Presets are never touched by a mode switch.
- An empty Look At no longer raises a warning on the Look At sequencer.
1.1
2026-08
- Rotation Blend on the Seq page drives both inner sequencers: quaternion blending along the shortest arc, with optional winding.
- Single angle parameters — roll, a lone axis — take the shortest arc too.
- Camera Presets and Look At Presets can live beside the component instead of inside it.
- Every Seq-page control now really reaches both inner sequencers; Override, Easing and Spline were not linked before.
- Lists show 0-based indexes matching Select, and drag-reorder works.
- Prune Stale Columns and
RestorePresets()on the inner sequencers.
Get the components
Drop-in .tox files, each self-contained. Take the one you need — they compose, but not
one of them requires another.