Disable Actor Scripts Unreal

2026-01-29 11:20 UTC gpt-5-2-thinking Open in ChatGPT ↗

In Unreal, an Actor’s scripts can “run” from a few different places (Tick, Timers, latent actions, component ticks, BeginPlay logic, plugin threads, etc.). For an NDI Broadcast actor, you usually want to stop ticking + component ticking and/or call whatever Stop Broadcasting function the plugin provides.

Here are the practical options, from “quick and dirty” to “most correct”:

1) Disable Tick (Blueprint or C++)

This stops the actor’s Event Tick and any tick-driven Blueprint logic.

Blueprint:

On the actor reference: Set Actor Tick Enabled (false)

C++:

SetActorTickEnabled(false);

Also consider:

In the actor’s details (or class defaults): uncheck Start with Tick Enabled.

2) Disable ticking on its components (often the missing piece)

Many actors do their work in components (SceneCapture, custom NDI component, etc.), which can keep ticking even if the actor tick is off.

Blueprint:

Get Components by Class (or Get Components) → for each:
- Set Component Tick Enabled (false)
- If it’s a scene capture or similar, also disable whatever “capture every frame” style flags exist.

C++ (generic):

TArray<UActorComponent*> Comps;
GetComponents(Comps);
for (UActorComponent* C : Comps)
{
    C->SetComponentTickEnabled(false);
}

3) Put it to sleep: hide + disable collision (optional)

This doesn’t stop scripts by itself, but helps reduce side effects.

Set Actor Hidden In Game (true)
Set Actor Enable Collision (false)

4) Stop the NDI broadcast explicitly (best for NDI)

NDI plugins commonly keep sending on their own schedule (or via their own internal thread / capture hooks). In that case, disabling tick may not stop the stream.

Look on the NDI Broadcast actor (or its NDI component) for functions like:

Stop Broadcasting
Deactivate
Enabled / Active boolean
Set Broadcasting Enabled(false)

If it has an NDI component:

Deactivate the component (Blueprint node: Deactivate), and/or set Auto Activate to false.

5) Fully disable: Destroy or Unregister

If you truly want nothing to run:

Destroy Actor (Blueprint: Destroy Actor)
- This is the most reliable “off switch,” but you’ll need to respawn it later if you want it again.

Or, more advanced:

Unregister component(s) (C++) — heavy-handed, but it removes them from ticking/updates.

6) If you only want it off sometimes: gate the logic

If you control the Blueprint:

Add a bool like bNDIEnabled
At the top of Tick/BeginPlay logic, branch and do nothing if disabled.
Also clear timers (below).

7) Don’t forget timers / latent actions

If your actor uses Set Timer by Function Name/Event, those can keep firing even with Tick disabled.

Blueprint:

Clear and Invalidate Timer by Handle (or Clear Timer)
K2_ClearTimer equivalents

C++:

GetWorldTimerManager().ClearAllTimersForObject(this);

What I’d do specifically for an NDI Broadcast actor

Call the plugin’s Stop/Disable Broadcast on the NDI actor/component (if available).
Set Actor Tick Enabled(false)
Disable tick on the NDI component (and any capture component) via Set Component Tick Enabled(false) and Deactivate.
Clear timers if it uses them.

If you tell me which NDI plugin you’re using (e.g., NewTek NDI IO, Off World Live, NDI for Unreal from a specific author) and whether your NDI is a component or a standalone actor, I can point you to the exact node/property name it exposes (they differ a lot).

Got it — you want no “game view” being rendered/presented to the main window, and only output via NDI.

There’s an important Unreal reality to keep in mind:

Unreal doesn’t have a built-in “render only to NDI and never render/present the main viewport” switch in pure Blueprint.
NDI still needs frames from somewhere, so something has to render (either the main viewport, or a SceneCapture rendering to a RenderTarget).
What you can do is: move all real rendering to an offscreen RenderTarget (SceneCapture2D) and make the main window render nothing / be as cheap as possible.

Below are the two practical patterns people use.

Option A (recommended): Render offscreen with SceneCapture → NDI, and “blank” the main viewport

1) Drive NDI from a Render Target (offscreen)

Place a SceneCaptureComponent2D
Set it to capture to a TextureRenderTarget2D at your NDI resolution (e.g., 1920×1080)
Point your NDI Broadcast/Sender to that RenderTarget / Texture input (depends on the NDI plugin)

This makes the NDI feed independent of the player viewport.

2) Make the main window render nothing useful (cheap)

You have a few ways:

Blueprint-only “cheap blank”:

Make the player camera look at a black card / empty level, OR
On BeginPlay: PlayerController → Client Start Camera Fade
- Fade to black with hold (this makes the viewport appear black, but note: the scene may still be rendering behind the fade)

Best “stop world rendering to viewport” (usually C++):

In C++, you can disable world rendering on the game viewport client (this is the “real” way to stop the viewport from drawing the 3D scene). The exact property/function depends on engine version, but it’s typically on UGameViewportClient.

If you tell me your UE version (4.27 / 5.0 / 5.1 / 5.2 / 5.3 / 5.4 / 5.5) I’ll give you the exact snippet for that version.

3) Keep audio/input if you want

This approach keeps the game running normally; only the on-screen view is blank/disabled, while your SceneCapture still renders for NDI.

Option B: Keep the main viewport but make it nearly free (fastest to implement)

If you can tolerate the window technically “rendering” but at negligible cost:

Run windowed at tiny res:
- Command line: -windowed -ResX=320 -ResY=180 (or even smaller)
Then still render your SceneCapture at full NDI resolution to a RenderTarget.

This way:

Main viewport cost is tiny
NDI output stays full res (because it comes from the RenderTarget, not the viewport)

What usually won’t work (or breaks NDI)

-nullrhi / true headless: disables rendering entirely → no frames for NDI
“Just disable Tick” on the actor: NDI capture/sending often isn’t tied to actor tick alone

Quick recommendation

If your NDI actor can accept a TextureRenderTarget2D, do Option A:

SceneCapture2D → RenderTarget (full res)
NDI sends that RenderTarget
Disable/blank the main viewport (C++ best; Blueprint fallback is fade/empty scene)

If you answer these 2 things, I’ll give you exact step-by-step for your setup (Blueprint nodes / C++ snippet):

Which Unreal version?
Which NDI plugin / actor (name/vendor) and does it take Viewport, Camera, or Texture/RenderTarget as input?

That “mystery camera at (0,0,0)” is Unreal falling back to a default view target because you don’t have a player camera/pawn set up.

When you press Play, Unreal still needs some view to render to the game viewport window. If it can’t find a valid view target, it will render from a fallback point—commonly the PlayerController’s default view, which often ends up looking like a camera at/near world origin (0,0,0), with a default orientation.

NDI broadcasting doesn’t replace the engine’s need to render a viewport.

What’s actually happening

A PlayerController is created.
A PlayerCameraManager is created for it.
If there’s no Pawn possessed (or no CameraActor set as view target), Unreal picks a fallback view, and you see the world from there.

Fixes (pick one)

1) Make the viewport intentionally black (fastest Blueprint fix)

In your PlayerController (or Level Blueprint on BeginPlay):

Client Start Camera Fade
- From Alpha: 0
- To Alpha: 1
- Duration: 0
- Hold when finished: true

This makes the window black even though the engine is still rendering behind it.

2) Give it a “dummy” camera / pawn that looks at nothing

Create a Pawn (or CameraActor) and set it as the default:

GameMode → Default Pawn Class = your DummyPawn
DummyPawn has a Camera that looks at an empty black plane, or points away from content.

This stops the “origin view” because there’s always a valid camera.

3) Don’t render the world to the main viewport (best, but usually C++)

If you truly want the main window to not draw the 3D scene at all, you typically do this in C++ on the UGameViewportClient (disabling world rendering / drawing). That’s the real “don’t render the game view” solution.

(If you tell me your UE version, I’ll give the exact snippet / override.)

4) If you only want NDI: drive NDI from a SceneCapture RenderTarget

Even if you hide/disable the main viewport, you still need frames for NDI. The clean approach is:

SceneCapture2D → RenderTarget (full res)
NDI sender uses that RenderTarget
Main viewport is faded/blank/disabled

Why it happens even with “no camera in the scene”

Because the game viewport isn’t tied to “cameras in the scene.” It’s tied to having a valid ViewTarget for the local player. If you don’t supply one, Unreal makes one up.

If you tell me:

your Unreal version (5.0/5.1/5.2/5.3/5.4/5.5), and
whether you’re in PIE, Standalone, or packaged,

…I can give you the most direct way to make the main window stay black or stop drawing entirely for that version.