Game Engine Integration

Table of Contents

• Introduction
• Requirements
• Prerequisites
• HapticService compatibility
• Unreal Engine
  • Install the Wwise integration
  • Stage the Razer Sensa runtime DLL
  • Initialize the Motion output at startup
  • Generate SoundBanks for Windows
  • Packaging
  • Verify in a packaged build
• Unity
  • Install the Wwise integration
  • Stage the Razer Sensa runtime DLL
  • Initialize the Motion output at startup
  • Generate SoundBanks for Windows
  • Build configuration
  • Verify in a packaged build
• Custom C++ (Wwise SDK)
• Runtime requirements on the player machine
• Known Issues
• Troubleshooting

---

Introduction

Once your Wwise project is wired up with the Razer Sensa HD Haptics sink (see Razer Sensa HD Haptics Wwise Plugin), the same project can be integrated into Unreal Engine, Unity, or a custom C++ engine through Audiokinetic's standard Wwise integrations. This guide covers the extra steps needed to ship a PC build that drives Razer Sensa HD-compatible devices.

Integrating the plugin into a game engine involves three steps beyond the standard Wwise integration flow:

1. Install Wwise into the engine project via the Audiokinetic Launcher.
2. Stage the Razer Sensa runtime DLL into the engine's plugin folder (required by the current v2025.1.0 Build0 package — see Known Issues).
3. Initialize the Motion output at startup by calling AddOutput with the Razer_Sensa audio device ShareSet. The Wwise Sound Engine does not create motion outputs automatically from bus configuration.

Note: Razer Sensa HD Haptics is supported on Windows x64 only. Console, macOS, Linux, and mobile builds will compile but will not produce haptic output.

Requirements

Item	Requirement
Build target	Windows x64
Wwise (authoring)	2025.1.6+ with Motion and Razer Sensa HD Haptics installed
Wwise (engine integration)	Exact same patch version as the authoring tool
Wwise license	Active Audiokinetic Wwise Motion license — required for SoundBank generation and for shipping any build that uses the Motion plug-in family (which Razer Sensa HD Haptics depends on)
Plugin download	Razer Sensa HD Haptics Wwise — Releases — download the latest plugin release archive
Razer runtime (player)	Razer Synapse 4 with the Chroma module installed
Razer Sensa device (player)	Any Razer Sensa HD-compatible peripheral (controller, headset, chair, etc.)
Supported engines	Unreal Engine 5.x · Unity 2022 LTS / 2023 / Unity 6 · custom C++ via Wwise SDK

Note: A valid Audiokinetic Wwise Motion license is required. Razer Sensa HD Haptics extends Audiokinetic's Motion framework, so any project that uses Sensa also uses Motion and is subject to Motion's licensing terms. Free evaluation in the Authoring app is permitted, but SoundBank generation and distribution require a paid license. See Audiokinetic licensing.

Note: Razer Synapse 4 is the user-space runtime that exposes Sensa-compatible devices to applications. The Chroma module is bundled with most Sensa device drivers and is required for full HD haptic playback. Without both installed on the player's machine, your game will run normally but haptic output is silently dropped.

Prerequisites

Before exporting to any engine, confirm that:

1. The Wwise project routes through Motion Factory Bus → Razer_Sensa (see Motion Device).
2. Both Motion (Audiokinetic) and Razer Sensa HD Haptics (WYVRN) are installed for the exact Wwise patch version your engine integration will use.
3. SoundBanks have been generated for the Windows platform from your authoring tool.
4. The events you intend to post are present in the generated SoundBanks (i.e. they're included in the SoundBank definition).
5. You have the Razer_Sensa.dll file at hand — extracted from the Authoring.Windows_x64.Release.tar.xz archive of the plugin package (see Known Issues).

HapticService compatibility

The Razer Sensa HD Haptics Wwise plugin is treated as a native implementation by WYVRN's HapticService runtime. When both this plugin and the WYVRN SDK's synesthesia layer are present in the same application, the Wwise plugin takes priority on the devices it supports — you don't need to disambiguate manually.

The exact device coverage depends on the HapticService version shipped with your application:

HapticService version	Wwise plugin priority
1.1.8	Wwise plugin has higher priority on all haptic devices. The WYVRN SDK's synesthesia layer defers to the plugin for every compatible target.
1.2.0+	Wwise plugin has higher priority on controllers and on the Freyja and Kraken V4 Pro devices. Other devices fall through to the WYVRN SDK's synesthesia layer.

Note: "Higher priority" means the Wwise plugin owns haptic output for that device — the WYVRN SDK will not simultaneously drive the same actuator. Applications integrating both the plugin and the WYVRN SDK don't need to coordinate manually; the HapticService runtime resolves the routing.

Unreal Engine

The Unreal integration applies to Unreal Engine 5.x using Audiokinetic's official Wwise plugin.

Install the Wwise integration

1. Open the Audiokinetic Launcher → Unreal Engine tab.
2. Select the Unreal project that will host the audio and click Modify Wwise in Project.
3. On the next page, click Modify. The Launcher copies the matching Wwise SDK plus most third-party plugin DLLs into your project's Plugins/WwiseSoundEngine/ThirdParty/x64_vc170/<Configuration>/bin/ tree.
4. Re-generate Visual Studio project files (right-click your .uproject → Generate Visual Studio project files) and re-open the project in the editor.
5. In the Wwise Browser, refresh the project so Unreal sees the latest events and SoundBanks (Window → Wwise Browser → Refresh).

Note: The Razer Sensa runtime DLL is not deployed automatically by "Modify Wwise in Project" for the current plugin release. Copy it in manually as described in the next section.

Stage the Razer Sensa runtime DLL

The Wwise Sound Engine loads sink plugin DLLs from the Plugins/WwiseSoundEngine/ThirdParty/x64_vc170/<Configuration>/bin/ path at engine startup. For the current plugin release, this DLL is not deployed automatically by "Modify Wwise in Project" and must be copied in by hand (see Known Issues).

1. Extract Razer_Sensa.dll (≈258 KB) from Razer_Sensa_v2025.1.0_Build0_Authoring.Windows_x64.Release.tar.xz in the downloaded plugin package.
2. Copy the DLL into each Wwise runtime configuration bin folder your Unreal build uses:
   • <YourUnrealProject>\Plugins\WwiseSoundEngine\ThirdParty\x64_vc170\Release\bin\
   • <YourUnrealProject>\Plugins\WwiseSoundEngine\ThirdParty\x64_vc170\Profile\bin\
   • <YourUnrealProject>\Plugins\WwiseSoundEngine\ThirdParty\x64_vc170\Debug\bin\
3. Restart the Unreal Editor. The Sound Engine loads plugin DLLs at process startup, so a hot-reload will not pick up the newly-added DLL.

Note: For a quick smoke test, copying the DLL only into the Release/bin/ (or the config matching your Unreal build) is enough. Cover all three configs before shipping.

Initialize the Motion output at startup

Unreal's Wwise integration does not auto-instantiate motion output devices from the Wwise project's bus configuration. You must call AddOutput explicitly with the audio device ShareSet name (Razer_Sensa) at game startup. Do this once, from the Level Blueprint or a GameInstance's Init, before any event that routes to the Motion Factory Bus is posted.

Blueprint approach — chain the following nodes on Event BeginPlay:

[Event BeginPlay]
        ↓
[Make Ak Output Settings]                       // AkGameplayStatics
    - Audio Device Share Set: Razer_Sensa
    - Id Device: 0
    - EPanning Rule: Panning Rule Speakers
    - Channel Config: Ak Parent
        ↓
[Add Output]                                    // AkGameplayStatics
    - In Settings: (from Make Ak Output Settings)
    - In Listener IDs: (leave empty for default)
    - Out Device ID: (bind to a variable if you need to remove it later)
        ↓
[Print String]  "Razer Sensa output registered"

C++ equivalent:

// In your GameInstance / GameMode init
void UHapticGameInstance::Init()
{
    Super::Init();

    FAkOutputSettings SensaSettings;
    SensaSettings.AudioDeviceShareset = TEXT("Razer_Sensa");
    SensaSettings.IdDevice = 0;

    FAkOutputDeviceID DeviceID;
    UAkGameplayStatics::AddOutput(SensaSettings, DeviceID, TArray<AActor*>());

    UE_LOG(LogTemp, Log, TEXT("Razer Sensa output registered (device ID %llu)"),
           static_cast<uint64>(DeviceID.DeviceID));
}

Note: Repeat the chain with Default_Motion_Device as the ShareSet if you also want XInput controller rumble alongside Sensa haptics. Each output is a separate AddOutput call.

Generate SoundBanks for Windows

In the Wwise authoring tool, open the SoundBank Manager, select the Windows platform, and click Generate All (Auto-Defined SoundBanks) or Generate Selected (User-Defined). Then in Unreal, run Generate SoundBanks from the Wwise toolbar so Unreal mirrors the latest banks into Content/WwiseAudio/.

At runtime, load the Init bank plus each event bank you want to post before calling PostEvent:

[Event BeginPlay]  → [Load Init Bank] → [Load Bank: Play_New_Haptic_Clip_Player]
                                      → [Load Bank: Play_New_Sound_SFX]
                                      → [Make Ak Output Settings] → [Add Output]

Packaging

When you cook a Windows build, the Razer Sensa runtime DLL is staged alongside the other Wwise third-party DLLs only if it was present in the source WwiseSoundEngine/ThirdParty/x64_vc170/<Configuration>/bin/ folder before cook time. Since you copied it there manually, the packaged build will include it automatically.

Verify after packaging that Razer_Sensa.dll sits next to AkSoundEngineDLL.dll and the other Audiokinetic DLLs in the shipped output (typical path: <ShippedGame>/Engine/Plugins/Wwise/Binaries/Win64/ or under <ShippedGame>/<ProjectName>/Plugins/WwiseSoundEngine/, depending on how you packaged).

Note: The UE Wwise integration uses dynamic libraries by default. This is the supported configuration for Sensa — do not switch to monolithic / static linking.

Verify in a packaged build

Launch the packaged executable on a PC with Razer Synapse 4 + Chroma installed and a Sensa-compatible device connected. Posting any event routed through the Motion Factory Bus should produce haptic output on the device.

To validate the Sensa path independently of any game logic, use a minimal two-button test widget:

• Button 1 posts Play_New_Haptic_Clip_Player (tests the .haptic / Haptic Clip Player path).
• Button 2 posts Play_New_Sound_SFX (tests the WAV fallback path).

If Button 1 produces HD haptics on your Sensa device and Button 2 produces rumble-style haptics, the integration is end-to-end correct.

Unity

The Unity integration applies to Unity 2022 LTS, 2023, and Unity 6 using Audiokinetic's official Wwise package.

Install the Wwise integration

1. Open the Audiokinetic Launcher → Unity tab.
2. Select the Unity project that will host the audio and click Modify Wwise in Project.
3. On the next page, click Modify. The Launcher installs the Wwise Unity Integration under Assets/Wwise/ and stages most plugin DLLs under Assets/Wwise/API/Runtime/Plugins/Windows/x86_64/DSP/.
4. Re-open the Unity project and let Unity recompile.
5. In the Wwise Picker, refresh so Unity sees the latest generated SoundBanks.

Note: Same caveat as Unreal — the Razer Sensa runtime DLL is not deployed by "Modify Wwise in Project" for the current plugin release. Copy it in manually per the next section.

Stage the Razer Sensa runtime DLL

Unity's Wwise Sound Engine loads plugin DLLs from the DSP/ subfolder under the Wwise runtime plugins path. Without the Sensa DLL there, you'll see the following errors in the Unity Console at Play mode:

WwiseUnity: (ERROR) WwiseMonitor: Could not find plug-in dynamic library: Razer_Sensa
WwiseUnity: (ERROR) WwiseMonitor: Plug-in not found: 1294406455

Fix:

1. Extract Razer_Sensa.dll (≈258 KB) from Razer_Sensa_v2025.1.0_Build0_Authoring.Windows_x64.Release.tar.xz.
2. Copy it into <YourUnityProject>\Assets\Wwise\API\Runtime\Plugins\Windows\x86_64\DSP\.
3. Stop Play mode if it is running, then restart the Unity Editor. The Sound Engine loads plugin DLLs at process startup, so a domain reload is not enough.
4. Re-enter Play mode and check the Console. The two red errors above should be replaced by a successful Motion Device Initialization line for Razer Sensa alongside the existing GameInput initialization.

Initialize the Motion output at startup

Same behavior as Unreal — Unity's Wwise integration does not auto-instantiate motion output devices. Register the Sensa output explicitly by calling AkSoundEngine.AddOutput in a MonoBehaviour that runs after AkInitializer.Awake().

using UnityEngine;
using UnityEngine.UI;
using AK.Wwise;

public class HapticTestBootstrap : MonoBehaviour
{
    public Button hapticClipButton;
    public Button soundSFXButton;
    public AK.Wwise.Event playHapticClip;    // assign: Play_New_Haptic_Clip_Player
    public AK.Wwise.Event playSoundSFX;      // assign: Play_New_Sound_SFX

    void Start()
    {
        // Load event banks (Init.bnk is auto-loaded by AkInitializer)
        AkSoundEngine.LoadBank("Play_New_Haptic_Clip_Player", out uint bankID1);
        AkSoundEngine.LoadBank("Play_New_Sound_SFX",          out uint bankID2);

        // Register the Razer Sensa motion output
        AkOutputSettings sensaSettings = new AkOutputSettings("Razer_Sensa", 0);
        AkSoundEngine.AddOutput(sensaSettings, out ulong deviceID);
        Debug.Log($"Razer Sensa output registered (device ID {deviceID})");

        // Wire buttons
        hapticClipButton.onClick.AddListener(() => playHapticClip.Post(gameObject));
        soundSFXButton.onClick.AddListener(() => playSoundSFX.Post(gameObject));
    }
}

Attach the script to a GameObject that also holds AkInitializer, so AkInitializer.Awake() runs before this script's Start(). The AkOutputSettings("Razer_Sensa", 0) two-argument constructor lets the sink pick its own default channel config — no need to specify one.

Note: If the AkSoundEngine.AddOutput signature in your Wwise integration version requires additional parameters (some versions want a listener array + count), hover the method in your IDE to see the correct overload. The two-argument settings constructor + two-argument AddOutput is what ships in 2024.1 → 2025.1.

Generate SoundBanks for Windows

In the Wwise authoring tool, generate SoundBanks for the Windows platform. In Unity, run Generate SoundBanks from the Wwise menu so Unity copies the latest banks into Assets/StreamingAssets/Audio/GeneratedSoundBanks/Windows/.

Build configuration

In File → Build Settings, target Windows / x86_64. Build the Player and verify that the Razer Sensa DLL is present under <BuildName>_Data/Plugins/x86_64/ next to the other Wwise third-party DLLs.

Note: When building from a fresh project, ensure the Unity Build target platform matches the Wwise platform used to generate SoundBanks (Windows). A mismatch will result in missing audio at runtime.

Verify in a packaged build

Launch the packaged executable on a PC with Razer Synapse 4 + Chroma installed and a Sensa-compatible device connected. Posting any event routed through the Motion Factory Bus should produce haptic output on the device.

Use the two-button test scene described in the Unreal section (or any equivalent) for a clean A/B validation of the Haptic Clip Player vs WAV fallback paths.

Custom C++ (Wwise SDK)

For custom engines linking the Wwise SDK directly, follow the standard Audiokinetic SDK integration guide. In addition to the usual steps:

1. Stage Razer_Sensa.dll next to your executable in the shipped build, or in whichever plugin folder the Wwise Sound Engine is configured to load DSP plugins from.
2. Register the Motion plugin via AK::SoundEngine::RegisterPlugin(...) (or AK_DECLARE_PLUGIN_AT_INITIALIZATION for static configurations).
3. Load Init.bnk and any event banks that reference the Motion Factory Bus.
4. Call AK::SoundEngine::AddOutput(settings, &deviceID, listeners, numListeners) with the audio device ShareSet name set to Razer_Sensa. This is required even if the bus in the SoundBank targets the Sensa sink — the Sound Engine does not create the device instance automatically.
5. Confirm the Motion Factory Bus in your SoundBanks targets the Sensa sink — the runtime can't reroute audio devices on its own.

Runtime requirements on the player machine

To experience Razer Sensa HD Haptics, the player's PC must have:

• Windows 10 / 11 (64-bit)
• Razer Synapse 4 installed and running
• The Chroma module installed (bundled with most Sensa device drivers; can also be installed standalone from Razer)
• A connected Razer Sensa HD-compatible device (controller, headset, chair, mouse, etc.)

Note: Without Razer Synapse 4 + Chroma installed, your game will run normally but every haptic event is silently dropped. Consider checking for Synapse / Chroma at first launch and prompting the user to install it if missing.

Known Issues

Razer Sensa runtime DLL is not deployed by "Modify Wwise in Project"

Symptom. After running "Modify Wwise in Project" in either Unreal or Unity, the Razer Sensa runtime DLL is not deployed into the engine's plugin path. Engines fail to load the Sensa sink at startup:

• Unreal — Wwise Profiler shows Sound could not find a path to an output device when events are posted; the Motion Factory Bus receives signal in the authoring tool but not in the running engine.
• Unity — the Console reports Could not find plug-in dynamic library: Razer_Sensa and Plug-in not found: 1294406455 immediately after Sound Engine initialization.

Where the runtime DLL lives in the current package. Razer_Sensa.dll is contained inside Razer_Sensa_v2025.1.0_Build0_Authoring.Windows_x64.Release.tar.xz. The Audiokinetic Launcher's "Modify Wwise in Project" step does not deploy it into the engine's runtime plugin path automatically for this build.

Workaround. Copy Razer_Sensa.dll from the Authoring Release archive into the engine's runtime plugin path manually:

• Unreal → <YourUnrealProject>\Plugins\WwiseSoundEngine\ThirdParty\x64_vc170\<Configuration>\bin\ (repeat for each configuration your build uses: Debug, Profile, Release).
• Unity → <YourUnityProject>\Assets\Wwise\API\Runtime\Plugins\Windows\x86_64\DSP\.

Restart the editor process after copying so the Sound Engine picks up the newly-placed DLL at initialization. This manual step will not be required once a future plugin release updates the package layout so the Launcher deploys the DLL automatically.

Motion output devices are not created automatically from bus configuration

Symptom. After copying the DLL, the plugin loads successfully at startup but no haptic output reaches the Sensa device. Events post without errors in the engine, but the Wwise Profiler shows no signal on the Razer Sensa audio device.

Root cause. The Wwise Sound Engine registers the Sensa plugin at startup (visible in Init.bnk) but does not instantiate the motion output device from the project's bus configuration. Both Unreal and Unity require an explicit AddOutput call at game startup to register the Sensa output. This is a Wwise Sound Engine behavior — same pattern applies to all secondary / motion outputs.

Fix. Follow the "Initialize the Motion output at startup" step for each engine (Blueprint / C++ / C# examples above).

Troubleshooting

• Unreal Profiler: "Sound could not find a path to an output device". The Razer Sensa runtime DLL is not deployed. See Known Issues — copy Razer_Sensa.dll into Plugins/WwiseSoundEngine/ThirdParty/x64_vc170/<Config>/bin/ and restart the editor.
• Unity Console: "Could not find plug-in dynamic library: Razer_Sensa" / "Plug-in not found: 1294406455". Same DLL-missing issue. Copy Razer_Sensa.dll into Assets/Wwise/API/Runtime/Plugins/Windows/x86_64/DSP/ and restart the editor.
• Events post but no haptics on the Sensa device. The Motion output was not registered at startup. Verify your Blueprint / C# bootstrap calls AddOutput with the ShareSet name Razer_Sensa after Sound Engine initialization.
• AddOutput returns a non-success AKRESULT. The plugin DLL is missing or the ShareSet name does not match. Double-check that the DLL is deployed (previous two entries) and that Razer_Sensa matches exactly the Audio Device declared under Devices → Factory Motion in the Wwise project (case-sensitive).
• Events cannot be posted — "Event not found in loaded banks". Load the event banks explicitly (AkGameplayStatics::LoadBank in Unreal, AkSoundEngine.LoadBank in Unity) after Sound Engine init and before posting events. Init.bnk alone is not enough — it carries plugin registrations, but per-event source data lives in each event's bank.
• No haptics on the player machine. Verify Razer Synapse 4 is running, the Chroma module is installed, and the Sensa device appears in Synapse's connected-devices list.
• DLL missing at runtime in a packaged build. Check the packaged output for Razer_Sensa.dll alongside the other Wwise third-party DLLs. If missing, ensure the DLL was in the source WwiseSoundEngine/ThirdParty/.../bin/ or Assets/Wwise/API/Runtime/Plugins/Windows/x86_64/DSP/ path before you cooked / built the player.
• Project Load Log warnings in the engine's editor (e.g. Motion Sensa or Razer Sensa not found). Install the matching Razer Sensa HD Haptics build for the exact Wwise patch version used by the integration. See Project Setup.
• Audio plays but haptics don't. Confirm the Motion Factory Bus's Audio Device is set to Razer_Sensa, not Default_Motion_Device. The Authoring Preferences override does not carry into runtime builds — it must be set on the bus itself.
• Wwise version mismatch. The integration's Wwise version must match the authoring tool exactly (patch level included). A mismatch is the most common cause of silent plugin failures.