Introduction

OmniWalk is a high-performance C++ locomotion system for Unreal Engine 5.4+ that enables true arbitrary-surface traversal. It solves the three core problems of magneboot movement: surface detection, gravity direction, and stable camera control. The result is predictable walking on walls, ceilings, spheres, and complex interiors without world-axis constraints.

Quick Start

This is the shortest reliable path to working wall-walk movement. It assumes a standard UE Character.

Step 1 — Add the Component

Add UOmniWalkPro to your Character (Blueprint or C++). This is the surface/adhesion engine.

Step 2 — Use the OmniWalk Controller

Set your PlayerController to AOmniWalkPlayerController and ensure the camera uses the OmniWalk camera manager.

Step 3 — Map Input on the Gravity Plane

Use the helper node or the controller function below. Do not map input twice.

// C++ example (Character)
AOmniWalkPlayerController* PC = Cast<AOmniWalkPlayerController>(GetController());
if (PC)
{
    const FVector Local(ForwardAxis, RightAxis, 0.0f);
    const FVector World = PC->GetGravityRelativeDirection(Local);
    AddMovementInput(World, 1.0f);
}

Step 4 — Dismount Input (Optional)

Bind a Dismount action and call RequestDismount. OmniWalk can auto-bind for you via bAutoBindDismountInput, and Enhanced Input users can assign a mapping context + action asset.

Character Setup

There are two ways to add OmniWalk to your third-person character. Choose the approach that best fits your project structure.

Approach 1: Inherit from AOmniWalkableCharacter

This is the recommended path for new characters. You inherit from AOmniWalkableCharacter (which itself inherits from ACharacter) and get all the interface implementations for free.

Step 1: Create Your Character Header

// MyThirdPersonCharacter.h
#pragma once

#include "CoreMinimal.h"
#include "OmniWalkableCharacter.h"  // Instead of ACharacter
#include "MyThirdPersonCharacter.generated.h"

UCLASS()
class MYGAME_API AMyThirdPersonCharacter : public AOmniWalkableCharacter
{
    GENERATED_BODY()

public:
    AMyThirdPersonCharacter();

protected:
    virtual void BeginPlay() override;
    
    // Optional: Implement interface callbacks for custom behavior
    virtual void OnOmniWalkSurfaceAttached_Implementation(
        const FVector& SurfaceNormal) override;
    virtual void OnOmniWalkSurfaceDetached_Implementation() override;
    
    UPROPERTY(VisibleAnywhere, Category = "Camera")
    USpringArmComponent* CameraBoom;
    
    UPROPERTY(VisibleAnywhere, Category = "Camera")
    UCameraComponent* FollowCamera;
};

Step 2: Implement in CPP

// MyThirdPersonCharacter.cpp
#include "MyThirdPersonCharacter.h"
#include "OmniWalkPro.h"
#include "GameFramework/SpringArmComponent.h"
#include "Camera/CameraComponent.h"

AMyThirdPersonCharacter::AMyThirdPersonCharacter()
{
    // OmniWalkPro is already added by parent class, but you can 
    // configure it here if needed
    if (UOmniWalkPro* OmniWalk = FindComponentByClass<UOmniWalkPro>())
    {
        OmniWalk->bDebugDismount = true;
        OmniWalk->TraceDistance = 300.0f;
    }
    
    // Setup standard 3rd person camera
    CameraBoom = CreateDefaultSubobject<USpringArmComponent>(TEXT("CameraBoom"));
    CameraBoom->SetupAttachment(GetRootComponent());
    CameraBoom->TargetArmLength = 300.0f;
    CameraBoom->bUsePawnControlRotation = true;
    
    FollowCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("FollowCamera"));
    FollowCamera->SetupAttachment(CameraBoom);
    
    // OmniWalk handles rotation, so disable controller rotation
    bUseControllerRotationYaw = false;
}

void AMyThirdPersonCharacter::BeginPlay()
{
    Super::BeginPlay();  // Important: Calls interface implementations
}

void AMyThirdPersonCharacter::OnOmniWalkSurfaceAttached_Implementation(
    const FVector& SurfaceNormal)
{
    // Optional: Play landing effect, change animation, etc.
    UE_LOG(LogTemp, Log, TEXT("Attached to wall! Normal: %s"), 
        *SurfaceNormal.ToString());
}

void AMyThirdPersonCharacter::OnOmniWalkSurfaceDetached_Implementation()
{
    // Optional: Play jump effect, etc.
    UE_LOG(LogTemp, Log, TEXT("Detached from surface"));
}

Approach 2: Implement IOmniWalkable Interface

Use this approach when you have an existing character class you can't change the inheritance of, or when you're using a custom character base from another plugin or marketplace asset.

Step 1: Add Interface to Your Header

// MyExistingCharacter.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "IOmniWalkable.h"  // Add this include
#include "MyExistingCharacter.generated.h"

UCLASS()
class MYGAME_API AMyExistingCharacter : public ACharacter, public IOmniWalkable
{
    GENERATED_BODY()

public:
    AMyExistingCharacter();

    //~ Begin IOmniWalkable Interface
    virtual UCharacterMovementComponent* GetOmniWalkMovementComponent_Implementation() const override;
    virtual UCapsuleComponent* GetOmniWalkCapsuleComponent_Implementation() const override;
    virtual FVector GetOmniWalkLocation_Implementation() const override;
    virtual FVector GetOmniWalkUpVector_Implementation() const override;
    virtual FVector GetOmniWalkForwardVector_Implementation() const override;
    virtual FVector GetOmniWalkRightVector_Implementation() const override;
    virtual bool IsOmniWalkLocallyControlled_Implementation() const override;
    virtual FRotator GetOmniWalkControlRotation_Implementation() const override;
    virtual FVector ConsumeOmniWalkMovementInput_Implementation() override;
    virtual void AddOmniWalkMovementInput_Implementation(const FVector& WorldDirection, float ScaleValue) override;
    virtual void SetOmniWalkRotation_Implementation(const FQuat& NewRotation) override;
    virtual FQuat GetOmniWalkRotation_Implementation() const override;
    virtual void OmniWalkLaunch_Implementation(const FVector& LaunchVelocity, bool bXYOverride, bool bZOverride) override;
    virtual bool IsOmniWalkJumpPressed_Implementation() const override;
    virtual UInputComponent* GetOmniWalkInputComponent_Implementation() const override;
    virtual APlayerController* GetOmniWalkPlayerController_Implementation() const override;
    //~ End IOmniWalkable Interface

protected:
    UPROPERTY(VisibleAnywhere, Category = "OmniWalk")
    UOmniWalkPro* OmniWalkComponent;
    
    UPROPERTY(VisibleAnywhere, Category = "Camera")
    USpringArmComponent* CameraBoom;
    
    UPROPERTY(VisibleAnywhere, Category = "Camera")
    UCameraComponent* FollowCamera;
};

Step 2: Implement All Interface Methods

// MyExistingCharacter.cpp
#include "MyExistingCharacter.h"
#include "OmniWalkPro.h"
#include "GameFramework/PlayerController.h"
#include "GameFramework/SpringArmComponent.h"
#include "Camera/CameraComponent.h"

AMyExistingCharacter::AMyExistingCharacter()
{
    // CRITICAL: You must add the OmniWalkPro component yourself
    OmniWalkComponent = CreateDefaultSubobject<UOmniWalkPro>(TEXT("OmniWalkPro"));
    
    // Setup camera
    CameraBoom = CreateDefaultSubobject<USpringArmComponent>(TEXT("CameraBoom"));
    CameraBoom->SetupAttachment(GetRootComponent());
    CameraBoom->TargetArmLength = 300.0f;
    CameraBoom->bUsePawnControlRotation = true;
    
    FollowCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("FollowCamera"));
    FollowCamera->SetupAttachment(CameraBoom);
    
    bUseControllerRotationYaw = false;
}

//~ Begin IOmniWalkable Implementation
UCharacterMovementComponent* AMyExistingCharacter::GetOmniWalkMovementComponent_Implementation() const
{
    return GetCharacterMovement();
}

UCapsuleComponent* AMyExistingCharacter::GetOmniWalkCapsuleComponent_Implementation() const
{
    return GetCapsuleComponent();
}

FVector AMyExistingCharacter::GetOmniWalkLocation_Implementation() const
{
    return GetActorLocation();
}

FVector AMyExistingCharacter::GetOmniWalkUpVector_Implementation() const
{
    return GetActorUpVector();
}

FVector AMyExistingCharacter::GetOmniWalkForwardVector_Implementation() const
{
    return GetActorForwardVector();
}

FVector AMyExistingCharacter::GetOmniWalkRightVector_Implementation() const
{
    return GetActorRightVector();
}

bool AMyExistingCharacter::IsOmniWalkLocallyControlled_Implementation() const
{
    return IsLocallyControlled();
}

FRotator AMyExistingCharacter::GetOmniWalkControlRotation_Implementation() const
{
    if (const APlayerController* PC = GetController<APlayerController>())
    {
        return PC->GetControlRotation();
    }
    return GetActorRotation();
}

FVector AMyExistingCharacter::ConsumeOmniWalkMovementInput_Implementation()
{
    return ConsumeMovementInputVector();
}

void AMyExistingCharacter::AddOmniWalkMovementInput_Implementation(
    const FVector& WorldDirection, float ScaleValue)
{
    AddMovementInput(WorldDirection, ScaleValue);
}

void AMyExistingCharacter::SetOmniWalkRotation_Implementation(const FQuat& NewRotation)
{
    SetActorRotation(NewRotation);
}

FQuat AMyExistingCharacter::GetOmniWalkRotation_Implementation() const
{
    return GetActorQuat();
}

void AMyExistingCharacter::OmniWalkLaunch_Implementation(
    const FVector& LaunchVelocity, bool bXYOverride, bool bZOverride)
{
    LaunchCharacter(LaunchVelocity, bXYOverride, bZOverride);
}

bool AMyExistingCharacter::IsOmniWalkJumpPressed_Implementation() const
{
    return bPressedJump;
}

UInputComponent* AMyExistingCharacter::GetOmniWalkInputComponent_Implementation() const
{
    return InputComponent;
}

APlayerController* AMyExistingCharacter::GetOmniWalkPlayerController_Implementation() const
{
    return GetController<APlayerController>();
}
//~ End IOmniWalkable Implementation

Approach Comparison

Blueprint Setup (Both Approaches)

If you prefer Blueprint-only workflow, you can also use OmniWalk through Blueprint classes:

Next Steps

After setting up your character, complete the integration:

Character Setup Tiers

OmniWalk supports multiple integration paths, but they offer different levels of reliability and support. Choose the tier that matches your project's constraints.

Tier 1 Setup: AOmniWalkExampleCharacter

Option A: C++ Inheritance (Recommended)

// MyCharacter.h
#pragma once
#include "OmniWalkExampleCharacter.h"
#include "MyCharacter.generated.h"

UCLASS()
class MYGAME_API AMyCharacter : public AOmniWalkExampleCharacter
{
    GENERATED_BODY()
public:
    AMyCharacter();
    
protected:
    // Override callbacks for custom behavior
    virtual void OnOmniWalkSurfaceAttached_Implementation(
        const FVector& SurfaceNormal) override;
};

// MyCharacter.cpp
AMyCharacter::AMyCharacter()
{
    // Customize OmniWalk settings
    if (OmniWalkPro)
    {
        OmniWalkPro->bAutoEnableWallSlide = true;
        OmniWalkPro->WallSlideSpeed = 300.0f;
        OmniWalkPro->bDebugDismount = true; // For debugging
    }
    
    // Customize camera
    SpringArm->TargetArmLength = 350.0f;
    SpringArm->CameraRotationLagSpeed = 15.0f;
}

void AMyCharacter::OnOmniWalkSurfaceAttached_Implementation(
    const FVector& SurfaceNormal)
{
    Super::OnOmniWalkSurfaceAttached_Implementation(SurfaceNormal);
    
    // Add your custom logic here
    UE_LOG(LogTemp, Log, TEXT("Landed on surface: %s"), *SurfaceNormal.ToString());
}

Option B: Blueprint-Only (For Designers)

Input Flow Comparison

Understanding how input flows through each character type is crucial for proper setup. The two characters use fundamentally different input handling approaches.

ExampleCharacter Input Flow

BPThirdPersonChar Input Flow (Internal Fix Enabled)

BPThirdPersonChar Input Flow (External Node)

Tier 2 Setup: Adapter-Based (Existing Characters)

For BP_ThirdPersonCharacter (Auto-Injection)

What the Adapter Does

Troubleshooting Adapter Issues

Migration: Tier 2 → Tier 1

If you're experiencing issues with the adapter approach, consider migrating to AOmniWalkExampleCharacter. Here's the process:

Auto Injection (No-Code)

OmniWalk can auto-inject the component at runtime. This is ideal for designers or rapid prototyping.

When to Avoid Auto Injection

In production codebases with custom Character subclasses, add the component explicitly so you can configure settings and input in one place.

Input Mapping

OmniWalk movement must be mapped onto the current gravity plane. The helper node handles this safely and consistently.

Preferred: Blueprint Helper Node

Dismount Input

OmniWalk exposes a dedicated dismount path so Jump stays Jump on vertical surfaces. Bind Dismount and call OmniWalk Request Dismount (or let UOmniWalkPro auto-bind it).

Manual Mapping (C++ or Blueprint)

Use the controller function directly if you want custom scaling or filtering:

// Map local input onto gravity plane
const FVector Local(ForwardAxis, RightAxis, 0.0f);
const FVector World = PC->GetGravityRelativeDirection(Local);
AddMovementInput(World, Scale);

Strafe vs Follow

OmniWalk exposes a single, prominent facing mode: Strafe Mode (Face Camera).

This replaces legacy orientation toggles. Older assets auto-migrate at runtime.

Surface Adhesion

OmniWalk samples surface normals beneath and around the capsule, blends the result, and drives gravity direction and orientation. The system includes wall detection to anticipate transitions at corners.

Wall Transitions

When you approach a wall, OmniWalk detects a forward hit and begins transitioning the gravity normal so your character stays glued.

Corner stability: SurfaceLossGraceSeconds keeps the last surface normal briefly when detection drops out, preventing unintended falls at 90° transitions.

// Simplified concept
if (MoveIntoWall < -0.5f && WallVsUp < 0.5f)
{
    TargetSurfaceNormal = Hit.ImpactNormal;
}

Performance

Use SurfaceTraceInterval / StableSurfaceTraceInterval and bAdaptiveMultiPoint to reduce trace cost when movement is steady, while keeping full fidelity during active traversal.

Transition Smoothing

Large-angle turns can be smoothed using LargeAngleMinTransitionTime (minimum duration) and LargeAngleSpeedMultiplier (overall speed scale).

Wall Sliding (Optional)

Use SetWallSliding to enable a gentle downward slide on vertical surfaces. The slide accelerates using WallSlideAcceleration and can be capped with WallSlideSpeed.

// Toggle wall slide
UOmniWalkPro* OW = FindComponentByClass<UOmniWalkPro>();
if (OW)
{
    OW->SetWallSliding(true, 300.0f);
    OW->SetWallSlideAcceleration(1400.0f);
}

Auto-Enable Wall Sliding (v1.0.1+)

New in v1.0.1: Wall sliding can automatically enable when the character lands on a wall-like surface. The system detects horizontal input and intelligently skips sliding when the player is actively moving left/right.

// In your character constructor or BeginPlay
if (UOmniWalkPro* OmniWalkPro = FindComponentByClass<UOmniWalkPro>())
{
    // Auto-enable slide when on walls
    OmniWalkPro->bAutoEnableWallSlide = true;
    
    // Slide physics
    OmniWalkPro->WallSlideSpeed = 300.0f;        // Max slide speed (cm/s)
    OmniWalkPro->WallSlideAcceleration = 1500.0f; // Slide acceleration (cm/s²)
    
    // Input-aware resistance - pressing "up" stops the slide
    OmniWalkPro->bWallSlideResistsInput = true;
}

Input-Aware Behavior

When bWallSlideResistsInput = true, the slide behavior responds to player input:

Gravity Volumes (Planets & Tubes)

While surface adhesion handles "walking on walls," Gravity Volumes solve the problem of jumping between them. When a character is airborne or transitions off a surface, OmniWalk checks for overlapping volumes to determine the "Down" direction.

Setup

Movement Mechanics

The example character includes three optional movement mechanics that work on any surface (floor, wall, ceiling) thanks to OmniWalk's gravity-relative system. All three are implemented in AOmniWalkExampleCharacter and inherited automatically by both FirstPerson and ThirdPerson subclasses.

Input Bindings

All mechanics use Enhanced Input actions created at runtime in SetupEnhancedInput() and added to the existing ExampleMappingContext.

Sprint

Hold the sprint key to multiply MaxWalkSpeed by SprintSpeedMultiplier. Speed is only boosted while the character is grounded and actively providing movement input. Releasing the key, stopping, or leaving the surface restores the default speed.

// Sprint logic in Tick()
if (bIsSprinting && bGrounded && HasMovementInput)
{
    CMC->MaxWalkSpeed = DefaultMaxWalkSpeed * SprintSpeedMultiplier;
}
else
{
    CMC->MaxWalkSpeed = DefaultMaxWalkSpeed;
}

Surface Slide

Press crouch while sprinting and moving above SlideMinSpeed to initiate a slide. The capsule shrinks to SlideCapsuleHalfHeight, velocity is boosted by SlideInitialBoost, and engine friction is disabled. Braking is handled manually at SlideBrakingDeceleration cm/s² along the surface plane.

Sliding ends when speed drops below SlideMinSpeed, the character leaves the surface, crouch is released, or sprint starts. Capsule height restoration checks for overhead obstructions via a sweep trace before expanding.

// Surface-relative braking in TickSlide()
FVector SurfaceNormal = OmniWalkPro->GetCurrentSurfaceNormal();
FVector VelOnSurface = FVector::VectorPlaneProject(Velocity, SurfaceNormal);
float SpeedOnSurface = VelOnSurface.Size();

float NewSpeed = FMath::Max(SpeedOnSurface - SlideBrakingDeceleration * DeltaTime, 0.0f);
if (NewSpeed < SlideMinSpeed)
{
    EndSlide();
    return;
}

// Reconstruct velocity: keep normal component, scale surface component
FVector NormalComponent = Velocity - VelOnSurface;
CMC->Velocity = NormalComponent + VelOnSurface.GetSafeNormal() * NewSpeed;

Coyote Jump

When the character walks off an edge (detaches from a surface without jumping), a brief grace window allows jumping for CoyoteTimeSeconds after leaving the surface. This is implemented via CanJumpInternal_Implementation(), which returns true during the coyote window even though the character is airborne. The existing jump binding (JumpAction → ACharacter::Jump) works unchanged.

// Coyote jump via UE5's CanJumpInternal hook
bool AOmniWalkExampleCharacter::CanJumpInternal_Implementation() const
{
    if (CoyoteTimer > 0.0f)
    {
        return true;  // Allow jump even though airborne
    }
    return Super::CanJumpInternal_Implementation();
}

Customization

All three mechanics live in AOmniWalkExampleCharacter (the shared base class). Both AOmniWalkFirstPersonCharacter and AOmniWalkThirdPersonCharacter inherit them with zero additional code. All properties are exposed as EditAnywhere under the OmniWalk | Movement category and can be tuned per-instance in the editor.

// Override defaults in a subclass constructor
AMyCharacter::AMyCharacter()
{
    SprintSpeedMultiplier = 2.0f;     // Faster sprint
    SlideInitialBoost = 500.0f;       // Longer slides
    SlideBrakingDeceleration = 300.0f; // Slower deceleration
    CoyoteTimeSeconds = 0.2f;          // More forgiving window
}

Mag-Boots System

New in v1.1: A unified State System to switch between movement behaviors dynamically. Toggle between standard walking, high-adhesion magnetic locking, and low-friction hovering.

Blueprint API

// Switch states at runtime
OmniWalkPro->SetMagBootState(EOmniWalkMagBootState::MagLock);
OmniWalkPro->SetMagBootState(EOmniWalkMagBootState::Hover);
OmniWalkPro->SetMagBootState(EOmniWalkMagBootState::Standard);
OmniWalkPro->SetMagBootState(EOmniWalkMagBootState::Off);

Spider Walk (Convex Traversal)

Characters can now seamlessly traverse 90-degree convex edges (Floor to Wall) without falling off.

Airborne Gravity Projection

Enables seamless orbiting jumps around small planetoids or tubes.

When enabled, OmniWalk continuously projects gravity from the surface below the character while they are in the air. This prevents the "launch tangent" issue where jumping on a small sphere causes the character to fly off into space as their Up vector diverges from the curvature.

// Enable for planetoid gameplay
OmniWalkPro->bProjectGravityFromSurface = true;
OmniWalkPro->AirborneProjectionDistance = 2000.0f;

Key Settings

These values define the feel of your traversal. Start here before deeper tuning.

Networking & Multiplayer

OmniWalk includes built-in network optimizations and security features for multiplayer games. Gravity state is replicated efficiently at 10Hz with client-side interpolation for smooth visuals.

Replication System

Gravity state is synced exclusively via the Client_SyncGravityState RPC at 10Hz (100ms intervals). This design minimizes network traffic while maintaining responsive gameplay.

Client-Side Interpolation

To prevent visual snapping when receiving network updates, the client smoothly interpolates from the current state to the replicated state over 100ms:

// In TickComponent - Client-side only
if (GetOwnerRole() < ROLE_Authority && ReplicationInterpAlpha < 1.0f)
{
    ReplicationInterpAlpha += DeltaTime * 10.0f; // 100ms interpolation
    
    CurrentSurfaceNormal = FMath::Lerp(
        CurrentSurfaceNormal, 
        LastReplicatedState.CurrentSurfaceNormal, 
        ReplicationInterpAlpha);
    CurrentSurfaceNormal.Normalize();
}

Security Features

RPC Rate Limiting

Server RPCs are rate-limited to prevent spam attacks. The default limit is 30 calls per second with a minimum 33ms cooldown between calls:

bool UOmniWalkPro::ValidateRPCCall(float& LastCallTime, int32& CallCount, float DeltaTime)
{
    // Max 30 calls per second
    if (CallCount >= OmniWalkConstants::MaxRPCRatePerSecond) 
        return false;
    
    // 33ms cooldown between calls
    if (CurrentTime - LastCallTime < 0.033f) 
        return false;
    
    LastCallTime = CurrentTime;
    CallCount++;
    return true;
}

RPC Bounds Validation

Server RPCs validate all parameters to prevent physics exploits. For example, wall slide speed must be within reasonable bounds:

bool UOmniWalkPro::Server_SetWallSliding_Validate(bool bEnable, float SlideSpeed)
{
    // Validate slide speed within reasonable bounds
    if (SlideSpeed < 0.0f || SlideSpeed > OmniWalkConstants::MaxWallSlideSpeed)
    {
        UE_LOG(LogOmniWalk, Warning, TEXT("Invalid SlideSpeed [%f]"), SlideSpeed);
        return false;
    }
    return true;
}

Client RPC Safety

Client RPCs include comprehensive null and validity checks to prevent crashes if the owner becomes invalid during execution:

void UOmniWalkPro::Client_SyncGravityState_Implementation(
    const FOmniWalkReplicationState& State)
{
    // Validate state data before applying
    if (!State.CurrentSurfaceNormal.IsNormalized())
    {
        UE_LOG(LogOmniWalk, Warning, TEXT("Invalid surface normals"));
        return;
    }
    
    // Safety checks for owner validity
    if (!GetOwner() || !IsValid(GetOwner()))
    {
        return; // Owner became invalid, skip update
    }
}

Constants Reference

All magic numbers used in the networking system are available in the OmniWalkConstants namespace:

namespace OmniWalkConstants
{
    constexpr float DefaultReplicationInterval = 0.1f;  // 10Hz
    constexpr float MaxWallSlideSpeed = 5000.0f;        // cm/s
    constexpr float MaxWallSlideAcceleration = 50000.0f; // cm/s²
    constexpr float MaxRPCRatePerSecond = 30.0f;        // calls/sec
}

Local Control Solver

AOmniWalkPlayerController builds a stable, gravity-relative view quaternion and keeps yaw/pitch consistent when the gravity up vector changes. The camera manager then applies this rotation directly to the view.

Wall Upright Assist

When gravity aligns to near-vertical walls, the controller can blend the view "Up" toward world up to keep movement intuitive. Use bKeepCameraUprightOnWalls and WallUprightStrength to tune how much roll is reduced.

// Conceptual flow (simplified)
FQuat ViewQuat = BuildViewQuaternion();    // gravity-relative
SetControlRotation(ViewQuat.Rotator());    // camera follows this rotation

Example Level

OmniWalk ships with an automated example level and an editor utility to generate it.

The utility auto-creates /Game/OmniWalkExamples/BP_OW_CreateExampleLevel and spawns AOmniWalkExampleCharacter + AOmniWalkDemoGenerator.

/Game/OmniWalkExamples/
├─ OW_Example
└─ BP_OW_CreateExampleLevel

Debugger

The OmniWalk editor module adds a telemetry tab to visualize alignment strength, gravity vectors, and trace data.

Open it via Window → OmniWalk Debugger.

Extension Modules

These optional components extend OmniWalk beyond its locomotion core. Each module is independently attachable — add only what your project needs.

Troubleshooting

Common issues and solutions. Check here first if you're experiencing unexpected behavior.

Wall Movement Issues

Input Double-Transformation

Symptom: Character moves slowly or stutters when walking on walls.

Cause: Both the internal input fix and Blueprint input transformation are active simultaneously.

Fix: Set bUseInternalInputFix = false in the OmniWalkPro component details:

// In your character constructor or component settings
OmniWalkPro->bUseInternalInputFix = false;  // When using AddGravityRelativeMovement

Wall Movement Wrong Directions

Symptom: W/S keys move horizontally and A/D keys move vertically on walls.

Cause: Wall basis vectors were incorrectly constructed (cross product order).

Fix: This is fixed in v1.0.1+. Ensure you're using the latest version:

// Correct wall basis construction (v1.0.1+)
FVector WallUp = FVector::VectorPlaneProject(FVector::UpVector, GravityUp);
FVector WallRight = FVector::CrossProduct(WallUp, GravityUp);  // Correct order!

Wall Slide Not Working

Symptom: Character doesn't slide down vertical surfaces.

Cause: Wall sliding may not be enabled, or the surface isn't detected as wall-like.

Fix: Enable auto-wall-slide and check detection:

OmniWalkPro->bAutoEnableWallSlide = true;
OmniWalkPro->WallSlideSpeed = 300.0f;
OmniWalkPro->bWallSlideResistsInput = true;

Network & Multiplayer Issues

Client RPC Crashes

Symptom: Crash when gravity changes in multiplayer.

Cause: Owner became invalid during RPC execution (race condition).

Fix: Fixed in v1.0.1+ with comprehensive null checks. Ensure you have the latest version.

Jittery Movement in Multiplayer

Symptom: Character snaps or jitters when gravity updates.

Cause: No interpolation between network updates.

Fix: This is handled automatically in v1.0.1+ with 100ms client-side interpolation.

Input Issues

UI / Menu Interaction Broken

Symptom: Mouse cursor disappears or UI is unresponsive on BeginPlay.

Cause: Default "Game Only" input mode enforcement.

Fix: Disable the auto-input mode in the Player Controller:

// In AOmniWalkPlayerController defaults
bAutoSetGameInputMode = false;

Enhanced Input Not Working

Symptom: Look input doesn't respond with Enhanced Input.

Fix: Ensure you're using AOmniWalkPlayerController and the look mapping context is registered:

// In your GameMode or Level Blueprint
PlayerControllerClass = AOmniWalkPlayerController::StaticClass();

Double Input with Adapter-Based Character

Symptom: Character moves twice as fast or input feels "heavy".

Cause: Auto-injected components previously defaulted to bUseInternalInputFix = true.

Fix: Fixed in v1.0.1+. Auto-injected components now default to false.

Debug Tools

Enable debug visualization to diagnose issues:

// In your character BeginPlay or constructor
if (UOmniWalkPro* OW = FindComponentByClass<UOmniWalkPro>())
{
    OW->bDebugDismount = true;  // Shows surface detection, slide direction, etc.
}

Debug visualization is wrapped in WITH_EDITOR and only available in editor builds.

Still Having Issues?

Support & Legal

About

Disclaimers

OmniWalk ships as a C++ plugin for Unreal Engine 5.4+ and requires a C++ compile step on first install in a Blueprint-only project.

Always test your surfaces with representative collision meshes. Highly irregular normals can produce jitter without multi-point averaging.

Because setup varies across projects, engines, and input stacks, integration can take iteration; if you hit snags, reach out before considering a refund—most issues are solvable with a quick config pass.