Rigonix Third Person Controller

About Rigonix Third Person Controller – Unity Editor Tool & Plugin

Rigonix Third Person Controller Unity Asset Overview

In my 8+ years building mechanics in Unity, building a production-ready third-person character controller from scratch remains one of the trickiest engineering challenges. You constantly balance capsule physics, slope limits, camera collisions, foot IK, and animation blending. The Rigonix Third Person Controller template approaches this problem with a clean state-machine architecture that decouples character motor calculations from input processing and visual presentation.

At its core, the template relies on a custom kinematic velocity calculation model layered over Unity’s CharacterController or Rigidbody system (depending on your setup). The architecture isolates state management into discrete, modular components: input listeners pass normalized vectors to an orbital camera system, which then calculates relative direction vectors for the motor script. Animation parameters, footstep VFX triggers, and surface-aware shaders are updated via light event delegates rather than heavy Update() polling loops. Here is the key takeaway: instead of wrestling with spaghetti code, you get a clearly structured codebase where adding custom states—like wall-running or ledge-grabbing—takes hours rather than days.

Core Technical Features & Highlights

Physics Engine & Locomotion State Machine

The movement core handles complex surface detection using multi-point raycasting and sphere-casting to resolve ground contact accurately. This prevents the classic "jittering" on staircases and uneven terrain. Slope sliding dynamics kick in automatically when surface angles exceed the defined slopeLimit parameter, offering smooth acceleration down steep drops.

Shader & Environmental Pipeline

Unlike basic controller templates that focus purely on C# movement scripts, Rigonix includes a dedicated suite of environment and character shaders built for both Universal Render Pipeline (URP) and HDRP. The custom Stylized Surface Shader includes features like dynamic rim lighting, distance-based vertex displacement, and surface-impact VFX triggers that sync automatically with footstep events.

Key Technical Highlights

• Decoupled Architecture: Built around a clean finite state machine using clean event hooks (OnStateEntered, OnStateExited).
• Multi-Pipeline Shaders: Out-of-the-box support for URP and HDRP render pipelines, complete with custom character outline and ground dust VFX shaders.
• Orbital Camera Rig: Smooth collision detection, customizable damping, framing offsets, and automatic wall-clipping prevention.
• Input System Agnostic: Works natively with Unity’s classic Input Manager as well as the modern New Input System (InputActionAsset).

Ideal Use Cases & Game Genres

Honestly, this template shines brightest when paired with games requiring tight spatial navigation and stylized or semi-realistic visuals. Because the camera rig and movement state machine are so tightly integrated, it fits several distinct genres:

• Action-Adventure & 3D Platformers: Perfect for titles requiring variable jump heights, ledge detection, sprint toggles, and tight air-control physics.
• Stylized Indie RPGs: Excellent baseline for titles featuring third-person exploration, interactive dialogue triggers, and custom gear/item visual swaps.
• Open World Explorers: The environmental slope sliding, variable speed interpolation, and surface-aware footstep audio/VFX make navigating large terrains feel responsive right away.

Quick-Start Unity Setup & Integration Guide

Integrating Rigonix into an existing Unity project takes only a few minutes once you understand its component lifecycle. Follow these practical steps to get your character running:

Step 1: Scene & Layer Configuration

Set up your project layers correctly. Create dedicated layers for Player, Ground, and CameraObstacle. Ensure your Physics Matrix under Project Settings > Physics disables collision between Player and CameraObstacle to prevent weird camera jerks during movement.

Step 2: Prefab Setup

Drop the Rigonix_Player_Base prefab into your hierarchy. Assign your custom character mesh beneath the main transform child node. Attach the RigonixMotor component to the root object and assign your ground layer mask.

Step 3: Extending States via Custom Script

Here is how you can quickly write a custom listener component to hook into the controller’s state machine and trigger gameplay logic whenever the character enters a sprint state:

using UnityEngine;
using Rigonix.Controller;

public class SprintVFXTrigger : MonoBehaviour
{
    [SerializeField] private RigonixMotor playerMotor;
    [SerializeField] private ParticleSystem sprintDustParticles;

    private void OnEnable()
    {
        if (playerMotor != null)
        {
            playerMotor.OnStateChanged += HandleStateChanged;
        }
    }

    private void OnDisable()
    {
        if (playerMotor != null)
        {
            playerMotor.OnStateChanged -= HandleStateChanged;
        }
    }

    private void HandleStateChanged(MovementState previousState, MovementState newState)
    {
        if (newState == MovementState.Sprinting)
        {
            if (!sprintDustParticles.isPlaying)
                sprintDustParticles.Play();
        }
        else if (previousState == MovementState.Sprinting)
        {
            sprintDustParticles.Stop();
        }
    }
}

Pros & Cons Assessment

Pros

• Clean C# Codebase: Well-commented, modular code with zero tight coupling between movement calculations and input collection.
• Complete VFX & Shader Pack: Includes ready-to-use ground dust particles, step impacts, and custom lighting shaders that save significant graphics development time.
• Smooth Camera Calculations: Orbital camera handles tight corners and indoor spaces surprisingly well without clipping inside geometry.
• Low CPU Overhead: Zero heavy GetComponent allocations inside Update() cycles; optimized for steady framerates.

Cons

• Initial State Machine Learning Curve: If you are used to monobehaviour-heavy single-file scripts, navigating the modular state architecture takes a moment to get used to.
• Custom Animator Setup Required: Replacing the default character avatar requires re-binding your Mecanim Animator controller parameters to match the expected state strings.

Developers Who Downloaded This Also Downloaded

Related Unity Templates Assets