3rd Person Camera

Copyright © 2015-2026 Thomas Enzenebner

Version 1.2

Thank you for buying the 3rd Person Camera Asset!

If you have any questions, suggestions, comments or feature requests, please send an email or join Discord.

Visit the 3rd Person Camera forum thread.

Beta access: enzenebner.com/beta

Upgrade Guide

Update to 1.2 from previous versions

• Back up custom changes, then remove the existing 3rdPersonCamera folder before importing. Runtime, input, and Cinemachine scripts now live under Scripts/Runtime, Scripts/Input, and Scripts/Integrations.
• Custom input implementations must use CameraInputFreeForm.LookingBackwardsPressed instead of the removed MiddleMouseButtonPressed field.
• Follow now explicitly requires FreeForm on the same GameObject. Unity adds it automatically when Follow is added.

Update to 1.0.8 from previous versions

Before upgrading, remove the old "3rdPersonCamera" folder before importing as some files were moved.

Update to 1.0.5.8 from previous versions

When upgrading from a previous version add the relevant CameraInputSampling script to the game object. The scripts will throw an error when the CameraInputSampling components are not found and CustomInput is not activated.

How to Use 3rd Person Camera

The Prefabs folder contains these ready-to-use camera GameObjects:

• 3rdPersonCamera_Adventure: LookAt follow camera that allows temporary FreeForm input
• 3rdPersonCamera_Cinemachine: Cinemachine3 virtual camera with FreeForm gameplay controls
• 3rdPersonCamera_Follow: camera that aligns with the target's forward direction
• 3rdPersonCamera_FreeForm: 360-degree orbit camera with zoom
• 3rdPersonCamera_FreeFormAndTargeting: orbit camera with lock-on targeting
• 3rdPersonCamera_Shooter: FreeForm over-the-shoulder camera

The demo package contains eight demo scenes:

• Adventure
• Ball
• Car
• Car with Lock-On
• Cinemachine Showcase
• FreeForm
• Shooter
• SoulsLike

Base components

There are six basic camera components, plus Targetable for focusable scene objects:

• CameraController The main script required by the other camera components
• FreeForm Orbital script to look around 360 degrees with a given distance and user input
• Follow Enables automatic camera movement without user input
• OverTheShoulder Using this in default mode, the camera is able to move left or right with a given input without changing the direction to the target.
• DisableFollow Helper script to disable follow on certain conditions
• LockOnTarget Enables locking on GameObjects with a Targetable component. Lock-on keeps the target in the middle of the screen without user input.
• Targetable Makes a GameObject available to the LockOnTarget component

Input System

Input System Package Setup

Step 1:

• Navigate to Project Settings > Player.
• Under Other Settings > Active Input Handling, select Both or Input System Package (New).
• When prompted to restart, do so

Step 2:

• Go to Window > Package Manager.
• Select Packages: Unity Registry.
• Install Input System 1.7 or newer.

Step 3:

• The included 3rdPersonCamera/Settings/Input/TPC_Input.inputactions asset generates TPC_Input.cs in 3rdPersonCamera/Scripts/Input/.
• If Unity does not generate or register the file, restart Unity. If needed, open TPC_Input.inputactions, make a change, and save it again.

Input System Package Usage

Add one CameraInputSampling component to the same GameObject as the camera components. It always samples FreeForm input and automatically samples LockOnTarget and OverTheShoulder when those components are present.

The component exposes mouse/controller sensitivity, Y-axis inversion, and mouse hiding mode. Default bindings are in 3rdPersonCamera/Settings/Input/TPC_Input.inputactions and can be edited there. The LookingBackwards action defaults to R on keyboard and left-stick press on gamepad. Standalone Windows keeps a hidden cursor anchored in place; standalone Linux supports the same behavior through X11 or XWayland and falls back to Unity mouse deltas when needed.

Legacy Input system

Add the corresponding input sampling components to the same GameObject as the camera components.

There are 3 input sampling components

• CameraInputSampling_FreeForm Needed when FreeForm is used
• CameraInputSampling_LockOn Needed when LockOnTarget is used
• CameraInputSampling_Shoulder Needed when OverTheShoulder is used

Custom Input

Enable Custom Input on each component that should not use a supplied sampler, then call its matching method:

• FreeForm.UpdateInput(CameraInputFreeForm)
• LockOnTarget.UpdateInput(CameraInputLockOn)
• OverTheShoulder.UpdateInput(CameraInputShoulder)

The current input values can be read with the corresponding GetInput() method.

Basic Setup

Add the following scripts to the main camera GameObject:

• CameraController
• FreeForm
• CameraInputSampling_FreeForm (Legacy Input) or CameraInputSampling (New Input System)

The most important option is which Transform to follow. Set this in Target.

Then set Collision Layer to the world layers that should block the camera (usually Default).

When your target has a collider, which it likely has, it's important to set the Player Layer. The target's colliders must be on a separate layer (for example, Player) so 3rd Person Camera can differentiate between player and the surrounding world and resolve self-collisions.

The rest can be tweaked in a number of ways: (Instead of reading this document, the same descriptions can found in each tooltip!)

Cinemachine 3 Integration

The optional Cinemachine integration uses 3rd Person Camera for gameplay and Cinemachine for camera selection, blends, Timeline, lens settings, Impulse, and other cinematic tools. It supports Cinemachine 3.x and is left out of compilation when Cinemachine is not installed.

In Cinemachine Showcase - DemoScene, entering the blue trigger pad starts a Cinemachine fly-through. Leaving the pad cancels the shot and blends back to the TPC gameplay camera.

Setup

1. Install Cinemachine 3.x from Package Manager.
2. Add a Cinemachine Brain to the Unity Camera that renders the scene.
3. Drag 3rdPersonCamera_Cinemachine from the Prefabs folder into the scene, or choose 3rd Person Camera from a Cinemachine Camera's Position Control dropdown.
4. Assign the player to the Cinemachine Camera's Tracking Target. The integration keeps CameraController.Target synchronized, so the Cinemachine target is authoritative.
5. Put the desired gameplay components (FreeForm, Follow, LockOnTarget, OverTheShoulder, and DisableFollow) on the same Cinemachine Camera object. Input sampling stays on that object as usual.

The preset has Standby Update set to Always. This keeps lower-priority cameras tracking their targets so blends start from a current pose. Standby cameras continue automatic tracking but ignore gameplay input. Only cameras that Cinemachine considers live consume gameplay input.

The component owns both position and rotation for the gameplay camera. Leave Rotation Control set to None unless a Cinemachine rotation component should intentionally override the final orientation. Do not combine it with another Position Control component.

Switching and Timeline

Use Cinemachine Camera priorities, activation, mixers, or Timeline tracks normally. The preset is a virtual camera and does not contain a Unity Camera or AudioListener.

Turn off Third Person Control Enabled when Timeline or custom code must animate that Cinemachine Camera's transform directly. In this pass-through mode the 3rd Person Camera components remain suspended and do not fight Cinemachine. Turning the option back on reinitializes gameplay tracking from the current Cinemachine pose.

Fly-Through Occlusion

Add 3rd Person Camera Occlusion as an extension on a Cinemachine Camera whose position is authored by Spline Dolly, Timeline, animation, or custom code. Cinemachine continues to own the raw pose. The extension sphere-casts from the resolved LookAt/Tracking point and asks its required CameraController to apply TPC's existing occlusion logic. Configure Collision Layer, Collision Distance, Thickness Check, Max Thickness, and Unoccluded Zoom Out Speed on that CameraController. Correction is immediate; Unoccluded Zoom Out Speed controls the smooth return to the authored pose.

Adding 3rd Person Camera as Position Control makes TPC generate the camera position and rotation, replacing a Cinemachine-authored position such as Spline Dolly. To keep Cinemachine in control of the fly-through, add only the 3rd Person Camera Occlusion extension. It adds a CameraController, prevents that controller from driving the transform, and delegates only the final occlusion correction to it. The authored raw pose remains unchanged. This extension is target-aware. For targetless collision that only pushes a camera out of intersecting geometry, use Cinemachine Decollider.

CameraController component

BASIC SETTINGS

• Target (Transform)

  • Sets the transform the camera follows. Use InitFromTarget(Transform) when switching targets at runtime.

• Desired Distance (float)

  • The distance how far away the camera should be away from the target

• Collision Distance (float)

  • Offset for the camera to not clip in objects

• Offset Vector (Vector3)

  • Changes the pivot point that the camera rotates around

• Camera Offset Vector (Vector3)

  • Offsets the camera without changing the pivot point

• DisableZooming (bool)

  • Prevents any input to zoom in/out

• Zoom Out Step Value (float)

  • The amount each mouse-wheel event changes the desired distance

• Occluded Zoom In Speed (float)

  • The speed, how fast the camera can zoom in automatically to the desired distance.

• Unoccluded Zoom Out Speed (float)

  • The speed, how fast the camera can zoom out automatically to the desired distance.

• Camera Offset Change Speed (float)

  • How fast the offset can change.

• Camera Offset Min Distance (float)

  • The minimum distance the camera offset can decrease to.

• Hide Skinned Mesh Renderers (bool)

  • Prevents the target's skinned mesh renderers from obscuring the view at close range.
  • A renderer whose materials all expose a _Fade property fades over the last world unit of camera distance. Other renderers retain the hide/show fallback. The demo package includes the Third Person Camera/Character Fade shader.

COLLISION LAYER SETTINGS

• Collision Layer (LayerMask)
  • Set this layermask to specify with which layers the camera should collide
• Player Layer (LayerMask)
  • Set this to your player layer so ground checks will ignore the player collider

FEATURES

• Occlusion Check (bool)
  • Automatically reposition the camera when the character is blocked by an obstacle.
• Smart Pivot (bool)
  • Uses a pivot when the camera hits the ground and prevents moving the camera closer to the target when looking up.
• Thickness Check (bool)
  • Allows obstacles at or below Max Thickness to be ignored without reporting a blocking occlusion

SMOOTH TARGET MODE

• Smooth Target Mode (bool)
  • Enable to smooth out target following, to hide noisy position changes that should not be picked up by the camera immediately or to enable smooth transitions to other targets that are changed during runtime
• Smooth Target Value (Vector3)
  • The speed at which the camera lerps to the actual target position for each axis. 0 means no smoothing!

THICKNESS CHECK SETTINGS

• Max Thickness (float)
  • Adjusts the thickness check. The higher, the thicker the objects can be and there will be no occlusion check. Warning: Very high values could make Occlusion checking obsolete and as a result the followed target can be occluded

SMART PIVOT SETTINGS

• Smart Pivot only on ground (bool)
  • Smart pivot is only activated on stable grounds
• Floor Normal Up (Vector3)
  • Default ground up for smart pivot
• Max Floor Dot (float)
  • Only hit results from maxFloorDot to 1 will be valid

STATIC PIVOT ROTATION SETTINGS

• Pivot Rotation Enabled (bool)
  • Enable pivot rotation feature to rotate the camera in any direction without the camera moving or rotation around. Used in LockOn and Follow.
• Smooth pivot (bool)
  • When enabled the pivot will smoothly slerp to the new pivot angles
• Custom Pivot (bool)
  • Enable overriding the pivot with the public variable 'pivotAngles'
• Pivot Angles (Vector3)
  • Custom override vector in Euler angles to modify the current pivot rotation

EXTRA SETTINGS

• Max Raycast Hit Count (int)
  • The maximum amount of raycast hits that are available for occlusion hits. Can be tweaked for performance. Don't set amount less than 2 when your geometry has many polygons as this can make repositioning unreliable.
• Max Thickness Raycast Hit Count (int)
  • The maximum amount of raycast hits that are available for thickness hits. Can be tweaked for performance. Use an even amount to account for back-front face and don't use less than 2.

Public variables

• bool PlayerCollision
  • Set to true to hide the target model when Hide Skinned Mesh Renderers is enabled
• CameraControllerState fields
  • Use GetControllerState() to read the current distance, rotations, positions, and collision state

Public methods (needed for runtime changes)

• UpdateOffsetVector(Vector3)
  • Updates the offset vector during runtime and fixes vectors which are too small
• UpdateCameraOffsetVector(Vector3)
  • Updates the camera offset vector during runtime
• InitFromTarget(Transform)
  • Assigns and initializes a target during runtime
• ref CameraControllerState GetControllerState()
  • Returns the live controller state by reference
• ApplyControllerState(CameraControllerState)
  • Restores a previously captured controller state
• GetSmoothedTargetPosition()
  • Returns the current smoothed target position
• GetCameraPosition(...) (static overloads)
  • Calculates a camera position from an explicit rotation or a CameraControllerState

FreeForm component

This script handles orbital rotation, zoom input, and the input state used by the other gameplay camera components. It requires CameraController; Follow and LockOnTarget also require FreeForm on the same GameObject.

BASIC SETTINGS

• Camera Enabled (bool)
  • Enables/Disables the camera rotation updates. Useful when you want to lock the camera in place or to turn off the camera, for example, when hovering an interface element with the mouse
• Min/Max distance (float)
  • Sets a min/max distance for zooming in or out
• Minimum/Maximum Angle (float)
  • Limits how far the camera can look down or up

STATIONARY SETTINGS

• enum StationaryModeType:
  • Free: no limits in angle
  • Fixed: can't move axis
  • Limited: limited in angles
  • Rotate when Limited: limited by angles, when over threshold rotate the camera
• Stationary Mode Horizontal (StationaryModeType)
  • Sets a stationary mode for the horizontal axis
• Stationary Mode Vertical (StationaryModeType)
  • Sets a stationary mode for the vertical axis
• Stationary Max Angle Horizontal (float)
  • Maximum angle for the horizontal axis
• Stationary Max Angle Vertical (float)
  • Maximum angle for the vertical axis

EXTRA SETTINGS

• Smoothing (bool)
  • Enables smoothing for the camera rotation when looking around - Beware, introduces interpolation lag
• Smooth speed (float)
  • The speed at which the camera will lerp to the final rotation
• Smoothing Type (SmoothingType)
  • Default preserves the legacy calculation; Exponential provides frame-rate-independent smoothing
• Force Target Direction (bool)
  • Allows input to set the target's Y rotation to the camera's Y rotation
• Stabilize rotation (bool)
  • Sets the z-axis rotation to 0 and stabilizes the rotation. Only use when the z-axis is drifting.
• Custom Input (bool)
  • Inform the script of using a custom input script to set the CameraInputFreeForm model
• Looking Backwards Enabled (bool)
  • Rotates the view 180 degrees while CameraInputFreeForm.LookingBackwardsPressed is true. The legacy sampler uses middle mouse; the Input System action defaults to R or left-stick press.

Follow component

This script handles following the target without any manual camera input. Useful for games that handle non-humanoid targets like racing or flying games. It requires CameraController and FreeForm.

BASIC SETTINGS

• EnableFollow (bool)
  • Enables/Disables the follow mode
• FollowMode (enum)
  • TargetForward: Always aligns with the target forward.
  • LookAt: Adventure camera which tries to look at the target and moving as little as possible.
• FollowAlignAxis (enum)
  Useful when Follow should only control one axis while the other remains persistent or is overridden by user input. Only usable with FollowMode.TargetForward!
  • Both: Both axis will be updated from the Follow component.
  • Horizontal: Only Y-axis will be updated. X-axis is persistent.
  • Vertical: Only X-axis will be updated. Y-axis is persistent.
• Rotation Speed (float)
  • How fast the camera should align to the transform.forward of the target
• Tilt Vector (Vector3)
  • Applies an additional world-space vector to tilt the camera.
  • In LookAt mode the tilt rotates the view in place through pivot rotation, so CameraController.PivotRotationEnabled must be enabled.
• Disable Time (float)
  • The default time in seconds the script will be disabled when the player has input in FreeForm

PREEMPTIVE SWEEPING

• EnablePreemptiveSweeping (bool)
  • Used for LookAt mode. Starts turning toward the target's forward direction when the path behind a moving target is about to be blocked, before the normal occlusion response moves the camera.
• SweepHoldTime (float)
  • How long the camera continues its preemptive turn after the obstruction is no longer detected.
• SweepSpeed (float)
  • How fast the camera should align to the target.forward when sweeping.

SLOPE ALIGNING

• Align on Slopes (bool)
  • Enables/Disables automatic alignment of the camera when the target is moving on upward or downward slopes
• Rotation speed slopes (float)
  • The speed at which the camera lerps to the adjusted slope rotation
• Align direction downwards (bool)
  • Set the camera to rotate downwards instead of upwards when the target hits a slope
• Ground Layer Mask (LayerMask)
  • The layer which should be used for the ground/slope checks. Usually just the Default layer.

BACKWARD MOTION ALIGNING

• Look Backwards (bool)
  • Enables/Disables looking backwards
• Check Motion for Backwards (bool)
  • Enables/Disables automatic checking when the camera should look back
• Backwards Motion Threshold (float)
  • The minimum magnitude of the motion vector when the camera should consider looking back
• Angle Threshold (float)
  • The minimum angle when the camera should consider looking back

LockOnTarget component

This script handles locking onto targets. It requires the CameraController and FreeForm components.

When Follow is also present and enabled, acquiring a lock-on target temporarily suspends it so both components do not compete for the camera rotation. Clearing the target or disabling LockOnTarget restores Follow; a Follow component that was already disabled remains disabled.

BASIC SETTINGS

• Follow Target (Targetable)
  • When not null, the camera will align itself to focus the Follow Target.
• CastRadius (float)
  • The radius/units around the target in which targets will be acquired.
• Target Layer (LayerMask)
  • The layers from which lock-on targets can be acquired
• Rotation Speed (float)
  • How fast the camera should align to the Follow Target
• Tilt Vector (Vector3)
  • Applies an additional vector to the target position to tilt the camera.
• Normalize Height (bool)
  • Ignores the resulting height difference from the direction to the target.
• Disable Time (float)
  • The default time in seconds the script will disable 'Smooth Pivot' when the player has input in FreeForm

TARGETABLES SORTING SETTINGS

• Default Distance (float)
  • A default distance value to handle targetables sorting. Increase when game world and distances are very large.
• Angle Weight (float)
  • A weight value to handle targetables sorting. Increase to prefer angles over distance
• Distance Weight (float)
  • A weight value to handle targetables sorting. Increase to prefer distance over angles

EXTRA SETTINGS

• Forward from target (bool)
  • Use the forward vector of the target to find the nearest Targetable. Default is the camera forward vector
• Custom Input (bool)
  • Inform the script of using a custom input method to set the CameraInputLockOn model
• Max Allocated Targets (int)
  • The amount of maximum targets that will be acquired for the sphere overlap cast.

Targetable component

Every focusable target needs a Targetable component.

• Offset (Vector3)
  • Set an offset for the target when the transform.position is not fitting.

DisableFollow component

Disables Follow when FreeForm input is received, then re-enables it based on target motion, elapsed time, or mouse button release.

BASIC SETTINGS

• Activate Motion Check (bool)
  • Enables motion check with its motionThreshold
• Activate Time Check (bool)
  • Enables timed checks and resets to follow after timeToActivate seconds are elapsed
• Activate Mouse Check (bool)
  • Enables reactivation of follow when mouse buttons are released
• Time To Activate (float)
  • Time in seconds when follow is reactivated. It will also not reactivate when the user still has input.
• Motion Threshold (float)
  • Distance which has to be crossed to reactivate follow

OverTheShoulder component

This script switches the camera between aim and release positions based on CameraInputShoulder. The supplied input configurations use the right mouse button for aiming by default.

BASIC SETTINGS

• Aim offset length (float)

  • The signed distance applied along Slide Axis while aiming

• Aim distance (float)

  • The distance from the target when aiming

• Release distance (float)

  • The distance from the target when released

• Base Offset (Vector3)

  • The base offset serves as starting and endpoint when releasing.

• Slide Axis (Vector3)

  • You can tweak the axis on which the camera slides on, usually it will be just operating on the x axis to slide left and right from the targeted character but it can be changed to any direction in case gravity changes for example. The intended design is to use normalized values between -1 and 1 The difference to the "Additional Axis Movement" vector is that the slide axis goes back and forth when aiming/releasing were the additional axis is fixed.

• Additional Axis Movement (Vector3)

  • This axis can be used to have additional offsets when aiming. Unlike the slide axis this axis is intended for non-normalized values much like the base offset. It can be used to make the camera zoom high above the character for example when aiming.

EXTRA SETTINGS

• Custom Input (bool)
  • Inform the script of using a custom input method to set the CameraInputShoulder model

FreeForm Camera Input Sampling component (Legacy)

This script handles input sampling and automatically updates the needed input model of FreeForm

INPUT SETTINGS

• Camera Mode (enum)
  • OnInput requires a configured input to look around; Always keeps FreeForm input active

MOUSE SETTINGS

• Mouse Input (List)
  • A list of integer mouseButton values to enable freelook, default is left/right mouse button
• Mouse Sensitivity (Vector2)
  • Adjusts the sensitivity of looking around with the mouse
• Mouse Invert Y (bool)
  • Inverts the Y-Axis

KEYBOARD INPUT SETTINGS

• Keyboard Input (List)
  • A list of KeyCodes to enable freelook

CONTROLLER INPUT SETTINGS

• Controller Enabled (bool)
  • Enables controller support
• Gamepad/Button Input (List)
  • A list of button strings to enable freelook
• Controller Invert Y (bool)
  • Inverts the Y-axis
• Controller Sensitivity (Vector2)
  • Adjusts the sensitivity of looking around with the controller

LOCK MOUSE SETTINGS

• Lock And Hide Mouse Cursor (bool)
  • When looking around the mouse cursor will be locked
• Keyboard Input Toggle (List)
  • A list of keys that toggle the locked mouse cursor
• Keyboard Input Cancel (List)
  • A list of keys that release the locked mouse cursor

EXTRA SETTINGS

• Mouse Input Force Direction (List)
  • A list of integer mouseButton values to enable forcing character/target rotation

When Looking Backwards Enabled is active on FreeForm, the legacy sampler uses the middle mouse button for the backward view.

Public variables:

• InputSamplingEnabled (bool)
  • Hidden in inspector, enables input sampling

LockOn Camera Input Sampling component (Legacy)

This script handles input sampling and automatically updates the needed input model of LockOnTarget

BASIC SETTINGS

• Cycle cooldown (float)
  • The time in seconds after which next/previous cycling gets reset to the beginning or 0 index of available Targetables

INPUT MOUSE SETTINGS

• Mouse LockOn Input (List)
  • A list of integer mouseButton values to lock on a target, default is right mouse button
• Mouse - Cycle target Next (List)
  • A list of integer mouseButton values to cycle to the next locked on target
• Mouse - Cycle target Previous (List)
  • A list of integer mouseButton values to cycle to the previous locked on target

INPUT KEYBOARD SETTINGS

• Keyboard LockOn Input (List) A list of KeyCode values to lock on a target
• Keyboard - Cycle target Next (List) A list of KeyCode values to cycle to the next locked on target
• Keyboard - Cycle target Previous (List) A list of KeyCode values to cycle to the previous locked on target

INPUT CONTROLLER SETTINGS

• Gamepad/Button LockOn Input (List)

  • A list of button strings to lock on a target

• Gamepad/Button - Cycle target Next (List)

  • A list of button strings to cycle to the next locked on target

• Gamepad/Button - Cycle target Previous (List)

  • A list of button strings to cycle to the previous locked on target

  Public Variables:

  • InputSamplingEnabled (bool) Hidden in inspector, enables input sampling

Shoulder Camera Input Sampling component (Legacy)

This script handles input sampling and automatically updates the needed input model of OverTheShoulder

INPUT SETTINGS

• Input Mouse Aim Mode (List)
  • A list of Mouse button values to activate aiming - Default is right mouse button
• Input Keyboard Aim Mode (List)
  • A list of KeyCode values to activate aiming
• Input Gamepad Aim Mode (List)
  • A list of button strings to activate aiming
• Input Mouse Change Leaning (List)
  • A list of Mouse button values to toggle the side you are leaning to
• Input Keyboard Change Leaning (List)
  • A list of KeyCode values to toggle the side you are leaning to
• Input Gamepad Change Leaning (List)
  • A list of button strings to toggle the side you are leaning to
• InputSamplingEnabled (bool)
  • Hidden in inspector, enables input sampling

Additional setup for controller support: For an easier setup, use the preconfigured InputManager.asset.template from the 3rdPersonCamera/ProjectSettings folder. Replacing the project InputManager.asset will overwrite existing legacy input settings.

If you get this warning: "Controller Error - Right axis not set in InputManager. Controller is disabled!" you have to set the following axis in the InputManager: "Right_3": 3rd axis "Right_4": 4th axis "Right_5": 5th axis 0 gravity, 0.3 dead, 1 sensitivity are good standard values.

If you need other names you can change them in the script.

Common Demo Controls

• WASD for movement
• Left/right click to rotate a FreeForm camera
• Mouse wheel to zoom
• R to reset the car/ball; Space makes the ball jump
• Q and E to rotate the ball's forward direction
• Input System defaults: middle mouse locks on, Q/E cycle targets, R looks backward, right mouse aims, and Left Shift changes the aiming side. These bindings can be edited in TPC_Input.inputactions.

Version History

1.2

• Added optional Cinemachine 3 Position Control integration and a ready-to-use virtual camera prefab.
• Gameplay cameras now support Cinemachine standby tracking, blending, Timeline pass-through, and target warps.
• Added a stackable TPC occlusion extension for Cinemachine-authored fly-throughs.
• Added a Cinemachine Showcase demo scene.
• Improved occlusion ordering and thickness evaluation so triggers, thin obstacles, and later solid obstacles are handled independently. Thin-only hits no longer report a blocking occlusion, and close hits cannot produce a negative camera distance.
• Fixed Follow backward-motion detection to use actual target movement and to reset correctly when the target changes.
• Added the LookingBackwards Input System action and renamed the custom input field to CameraInputFreeForm.LookingBackwardsPressed. Default bindings are R and left-stick press; the legacy sampler continues to use middle mouse.
• Added SmoothingType to FreeForm. Default preserves legacy smoothing, while Exponential adds another option.
• Added frame rate independent accumulation for input across frames to improve Smoothing mode.
• Follow now explicitly requires FreeForm on the same GameObject.
• Follow.TiltVector now works in LookAt mode through pivot rotation without moving the camera position.
• Added preemptive corner sweeping to Follow LookAt mode, including configurable sweep speed and hold time.
• Improved preemptive sweep thickness checks so a wider sweep does not make thin obstacles block the camera, and fixed LookAt movement when no sweep is active.
• Added smooth close-range character fading for materials with a _Fade property, with the previous renderer hide/show behavior retained as a fallback.
• Replaced the legacy Built-in character fade shader with a URP Lit Shader Graph. _Fade now uses correct transparent alpha blending without preserved specular lighting.
• Added standalone Linux cursor anchoring and relative mouse input for X11/XWayland.
• Fixed LockOnTarget and Follow competing for rotation. Lock-on now suspends an active Follow and restores it when the target is released or lock-on is disabled.
• Reorganized runtime, input, and Cinemachine integration scripts under Scripts, refreshed the demo scene selector and lighting, and removed unused legacy CrossPlatformInput demo scripts.

1.1.3

- Added `FollowAlignAxis` to `Follow`. This setting controls which axis will be updated by the `Follow` component.
  It only works for FollowMode.TargetForward.

1.1.2

- Hotfix for 'AlignOnSlopes' feature missing the smart pivot rotation in `TargetForward` mode

1.1.1

- Fixed `AlignOnSlopes` feature to work with `LookAt` follow mode

1.1

- Camera offset vector behaviour has been improved and instead of just switching sides when
  it's colliding, it will smoothly realign to the center. Furthermore, it will try to lerp smoothly
  in almost every situation unless the camera will collide with something.
- Moved all relevant data to `CameraControllerState` to support better saving/loading.
  Use `GetControllerState` and `ApplyControllerState`. Keep in mind this only applies to
  state and not settings or the current `Target`!

1.0.8.1

- fixed a clamp bug in LockOnTarget
- renamed "InputManager.asset" to "InputManager.asset.template" to supress the warning
- removed default code generated file "TPC_Input" from base package

1.0.8

- Improved and rewrote every feature
- Added "Adventure" camera for "Follow":
    Use FollowMode "LookAt" to activate
- Added new Input system bindings:
    Remove the old "CameraInputSampling_xxx" scripts and add the "CameraInputSampling" component.
    Don't forget to change to the new Input System in the Player preferences.
    Control bindings can be found in "3rdPersonCamera\Settings\Input"
- Split demo scenes into its own .unityPackage
- Integrated the free KCC (KinematicCharacterController) for better character movement
  and easier out of the box usage
- Updated and reformated documentation

1.0.7.2

- The main transform.rotation has been split up in new Quaternions for camera rotation, pivot and smart pivot rotations:
  Not only is the smart pivot now smoothly integrated in the rest of the systems, the new pivot opens up another level of control. Rotations without the camera moving/rotating around.
- Raycast hit sorting has been improved which should solve most jitter issues (Haven't found them while testing)
- Thickness check improvements, more stable results
- Smart pivot ground check improvement where it would not trigger smart pivot on slopes. There is now also an option to have smart pivot only on grounds and/or walls
- Repositioning when colliding has been improved and getting back to the the desired distance should be more stable/smooth
- A new demo scene: car with lock on
- Introduced new parameters:
	Camera Controller
	- Smart Pivot only on ground
	- Pivot Rotation Enabled
	- Smooth pivot: pivot will smoothly slerp to new pivot
	- Custom Pivot: enable to use pivot angles for override
	- Pivot Angles
	Free Form
	- Stationary Mode Horizontal/Vertical
	- Stationary Modes (enum)
		* Free: no limits in angle
		* Fixed: can't move axis
		* Limited: limited in angles
		* Rotate when Limited: limited by angles, when over threshold rotate the camera
	- Stationary max angle Horizontal/Vertical
	Follow
	- Disable time: The default time in seconds the script will be disabled when the player has input in FreeForm
	LockOn
	- Disable time: When there is input in freeform, LockOn will disable the "smooth pivot" mode and enable it after the disable time

1.0.6.3

- fixed regression in input sampling where camera mode set to Always was not working
- added "Ignore X Rotation" to Follow so the player can look up/down in follow mode

1.0.6.2

- cleanup of prefabs

1.0.6.1

- added MouseCursorHelper for Windows platform to support cursor locking in place
  and not in the center of the screen
- added gamepad button sampling to FreeForm input sampling
- added public bool inputSamplingEnabled to all input sampling scripts
  with which sampling can be disabled (for example when hovering interface elements)
- added forceDirectionFeature to FreeForm input sampling, which handles
  forcing the direction of FreeForm with mouse buttons (for example, only force direction with right mouse button)
- added stabilizeRotation to FreeForm in case the z-rotation starts to drift

1.0.6.0

- added TPC_DEBUG to CameraController which enables debugging options for raycasts visualization.
  Either uncomment TPC_DEBUG in the script directly or define in Unity project settings
- improved unreliable raycast hit handling on edges and sorting for the best results
- improved distance handling on repositions

1.0.5.9

- Fixed a glitch for 0/0/0 offset vectors where the pivot point of the target is inside the collision sphere.
  The offset gets fixed in Awake of the CameraController, during runtime please use UpdateOffsetVector(Vector3) to prevent glitches.

1.0.5.8

- Input sampling of FreeForm, OverTheShoulder and LockOn has been split into seperate scripts
  and a data oriented model is now used for main scripts:
  * FreeForm uses struct CameraInputFreeForm
  * LockOnTarget uses struct CameraInputLockOn
  * OverTheShoulder uses struct CameraInputShoulder

  These scripts are updated with the UpdateInput(CameraInput...) method. This method should be used for
  custom input sampling scripts

- added CameraInputSampling_X components which samples inputs and automatically updates
  the according input model with UpdateInput(CameraInput...)
  These scripts can be used as a template for custom input sampling or adding additional inputs
- added component CameraInputSampling_FreeForm
- added component CameraInputSampling_Shoulder
- added component CameraInputSampling_LockOn

1.0.5.7

- fixed occurances where automatic zooming out failed and the camera would reposition itself too fast
- improved smart pivot transition
- improved camera offset clipping

1.0.5.6

- added headers and tooltips to components and fields to provide easier documentation
- changed smoothTargetValue in CameraController from float to Vector3 to have more control over axis

1.0.5.5

- added a stabilization for follow/lock on rotations to prevent wrong rotations in Z-axis
- added mouse/keyboard/gamepad input to LockOnTarget for locking on target and switching to next/previous
- improved lock on target mode with weighted distance and angle
- added input properties for aiming and switching sides to OverTheShoulder
- added "forwardFromTarget" to LockOnTarget which provides a more stable sampling of targets when cycling through targets is preferred
  the default mode takes the forward from camera - which gives the best results when cycling isn't needed and the target that is looked at is more important

1.0.5.4

- added forceCharacterDirection to FreeForm so the character turns automatically in the same direction the camera is facing.
  This works only for character controllers that use absolute directions for movement. The demo character controller
  uses relative movement, so it won't work right.
- fixed a sorting bug with occlusion hits
- improved thickness logic for clipping geometry that occurs often in prefab based level design

1.0.5.3

- improved jitter when camera was zooming out against a wall
- improved thickness handling

1.0.5.2

- added min/max distance to CameraController
- added namespace for demoscene scripts

1.0.5

- added an additional camera offset vector for skewed over-the-shoulder camera type of games like "The Division"
  that can either be fixed or controlled via the OverTheShoulder script
- added OverTheShoulder component
- added new scene to demonstrate Camera Offset called "DivisionCamera - DemoScene"
- changed PlayerLayer data type from integer to LayerMask for convenience and the possibility to have more player layers
- added "Smooth Target Mode" and "Smooth Target Value" that lerps to the target position for smoother translations/rotations
  to dampen noisy position changes for either physics or network based games
- added support for having no target when initializing or starting
- added mouse/keyboard inputs to FreeForm which uses a list of mouse buttons (Integer) and keyboard inputs (KeyCode)

1.0.4

- added smart DisableFollow script to utilize FreeForm + Follow
- added Ball demo scene
- added simple BallController script
- added namespace "ThirdPersonCamera" to scripts
- added more camera prefabs (Basic, Follow, FreeForm and Ultimate (Freeform/Follow/DisableFollow))
- improved smart pivot transition from sloped surfaces
- improved smoothness of alignToSlopes feature
- improved camera when offset clips into geometry
- restored Ethan crouch animation
- removed Ethan air->ground crouch animation

1.0.3

- added 2 new demo scenes (follow and follow+lock on)
- added support for follow mode
- added support for target locking
- split CameraController into CameraController and Freeform
- improved smart pivot and occurances of snapping
- improved thickness check
- changed hardcoded raycast layermasks to be configured in the editor

1.0.2

- changed collision sensitivity to be spherical
- removed camera position/rotation initialization, editor values are now taken
- improved smart pivoting and smart pivoting start and resets
- improved detection algorithm when multiple raycasts are hit
- added terrain to demoscene
- added RotateTo public method
- added x/y, playerCollision, Distance public get or/and set

1.0.1

- improved thickness checking
- improved smart pivoting on slopes
- added collision distance to improve clipping occurrences
- added automatic mouse cursor locking when looking around (currently unstable in WebGL)
- added interface handling to demo scene
- changed sensitivity handling
- removed unnecessary files
- added a script only package

1.0.0

- initial release