OmniWalk Setup Wizard

Welcome to the OmniWalk Setup Wizard Operations Manual. This guide provides a comprehensive technical breakdown of the integrated onboarding utility designed to dynamically audit worlds, configure input projection pipelines, bind physical material tables, inject pre-tuned locomotion archetypes, and launch real-time telemetry instantly.

Locating the utility inside the Unreal Editor is straightforward. Navigate to the top menu bar and select Window → OmniWalk → OmniWalk Setup Wizard. The wizard operates in two distinct, production-hardened modes:

Slate UI Anatomy

The Slate tab is carefully structured into collapsable segments with helpful descriptions, key parameters, and safety feedback logs, ensuring that developers are fully aligned at each stage.

Core Setup Pipeline

By default, the Setup Wizard plans and creates four essential starter Blueprints that inherit from our native C++ classes, saving them in a target folder you choose (e.g. /Game/OmniWalkSetup):

When clicking Generate Playable First-Person Setup or Generate Playable Third-Person Setup, the wizard completes a series of non-destructive operations:

• Creates all starter Blueprints in your designated root path (avoiding duplicate naming conflicts).
• Links the custom Player Controller and Pawn subclasses to the GameMode CDO and compiles it programmatically in the Editor context.
• Spawns a functional APlayerStart in your persistent level (intelligently reusing an existing one if present to prevent spawning overlapping spawners).
• Overrides the level GameMode to the generated BP_OW_ThirdPersonGameMode (or First-Person) inside the world's AWorldSettings, so pressing Play (PIE) instantly spawns you with fully operational gravity-relative locomotion.

Advanced Locomotion Tools

The Setup Wizard features an expandable Advanced Locomotion Tools section, exposing five dynamic Slates designed to automate common onboarding snags. Let's explore their inner C++ logic, parameters, and visual behavior.

// FOmniWalkSetupWizardUtility C++ Logic
FOmniWalkSelectionTagResult FOmniWalkSetupWizardUtility::AutoConfigureEnhancedInputForSelection()
{
    TArray SelectedAssets = GetSelectedAssetsOfClass(UBlueprint::StaticClass());
    int32 ModifiedCount = 0;

    for (UObject* Asset : SelectedAssets)
    {
        UBlueprint* BP = Cast(Asset);
        if (BP && BP->GeneratedClass && BP->GeneratedClass->IsChildOf(ACharacter::StaticClass()))
        {
            ACharacter* CDO = Cast(BP->GeneratedClass->GetDefaultObject());
            if (CDO)
            {
                if (UOmniWalkPro* Pro = CDO->FindComponentByClass())
                {
                    Pro->bUseInternalInputFix = true;
                    Pro->bProjectGravityFromSurface = true;
                    FBlueprintEditorUtils::MarkBlueprintAsModified(BP);
                    ModifiedCount++;
                }
            }
        }
    }
    return FOmniWalkSelectionTagResult(true, ModifiedCount);
}

// FOmniWalkSetupWizardUtility C++ Logic
FOmniWalkCollisionAuditResult FOmniWalkSetupWizardUtility::AuditLevelCollisions(bool bFixSettings)
{
    UWorld* World = GEditor->GetEditorWorldContext().World();
    if (!World) return FOmniWalkCollisionAuditResult(false, 0);

    int32 FoundCount = 0;
    for (TActorIterator It(World); It; ++It)
    {
        AStaticMeshActor* Actor = *It;
        if (Actor && Actor->GetStaticMeshComponent())
        {
            UStaticMeshComponent* SMC = Actor->GetStaticMeshComponent();
            if (SMC->GetCollisionEnabled() == ECollisionEnabled::NoCollision)
            {
                FoundCount++;
                if (bFixSettings)
                {
                    SMC->SetCollisionEnabled(ECollisionEnabled::QueryAndPhysics);
                    SMC->SetCollisionProfileName(UCollisionProfile::BlockAll_ProfileName);
                    Actor->MarkPackageDirty();
                }
            }
        }
    }
    return FOmniWalkCollisionAuditResult(true, FoundCount);
}

FGlobalTabmanager::Get()->TryInvokeTab(FTabId("OmniWalkDebugger"));

C++ Automated Unit Testing

All Setup Wizard operations and advanced tools are verified by a comprehensive automated test suite inside OmniWalkSetupWizardTests.cpp.

The FOmniWalkSetupWizardAdvancedExtensionsTest dynamically spawns pure C++ actor instances in offline editor worlds, programmatically selects them, and validates the advanced locomotion preset parameters, raw input projection switches, and level collision audits:

IMPLEMENT_SIMPLE_AUTOMATION_TEST(
	FOmniWalkSetupWizardAdvancedExtensionsTest,
	"OmniWalk.Editor.SetupWizard.AdvancedExtensions",
	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)

bool FOmniWalkSetupWizardAdvancedExtensionsTest::RunTest(const FString& Parameters)
{
	UWorld* World = FAutomationEditorCommonUtils::CreateNewMap();
	AOmniWalkExampleCharacter* ExampleCharacter = World->SpawnActor(
		AOmniWalkExampleCharacter::StaticClass(), FVector::ZeroVector, FRotator::ZeroRotator);

	// Select actor programmatically
	GEditor->SelectActor(ExampleCharacter, true, true);

	// Verify locomotion preset application
	FOmniWalkPresetResult PresetResult = FOmniWalkSetupWizardUtility::ApplyLocomotionPresetToSelection(EOmniWalkPreset::WallRunner);
	TestTrue(TEXT("Preset applied successfully"), PresetResult.bSuccess);

	// Verify input configuration fix
	FOmniWalkSelectionTagResult InputResult = FOmniWalkSetupWizardUtility::AutoConfigureEnhancedInputForSelection();
	TestEqual(TEXT("Character modified by input config"), InputResult.TaggedCount, 1);

	return true;
}

C++ API Reference

Below is the C++ API signature for the advanced wizard extensions declared in OmniWalkSetupWizardUtility.h:

// Selection Input Projection Fix
static FOmniWalkSelectionTagResult AutoConfigureEnhancedInputForSelection();

// Level Collision Channel & Presets Auditor
static FOmniWalkCollisionAuditResult AuditLevelCollisions(bool bFixSettings);

// Material Response Table Creator & CDO Binder
static FOmniWalkResponseTableResult ConfigureOrCreateSurfaceResponseTable(const FString& TargetFolder, bool bCreateIfMissing);

// Locomotion Preset Selection Writer
static FOmniWalkPresetResult ApplyLocomotionPresetToSelection(EOmniWalkPreset Preset);

// Live Telemetry Tab Invoker
static void LaunchTelemetryDebugger();

Troubleshooting

Folder Generation Fails

Symptom: Pressing "Generate" returns a directory write error.

Cause: The target folder might reside in a read-only subdirectory, or your project relies on Source Control (Perforce/Git) with checked-in locks.

Fix: Ensure the project directory has write permissions. If using Git/P4, check out the target directory context prior to clicking generate.

Input Config Ineffectual

Symptom: Checking WASD input fix has no effect on selected characters.

Cause: Character Blueprints must have their parent classes set to subclasses containing a UOmniWalkPro component. If the Blueprint inherits from standard engine ACharacter, the injector will skip modifications.

Fix: Double check character parents, or reparent the character to AOmniWalkableCharacter prior to running the advanced input injector.

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.