Controlling the stream

Quality, resolution, fullscreen, mouse behaviour, sound and screenshots of an Eagle 3D Streaming stream — driven from your own interface rather than the default one. Each is shown for both the SDK and the iframe.

The pattern is the same throughout. With the SDK you call a function on e3ds_controller. With an iframe you post a JSON message carrying a cmd key to the frame:

document.getElementById("iframe_1")
  .contentWindow
  .postMessage(JSON.stringify({ cmd: "…", /* … */ }), "*");

Quality

	Call
SDK	`e3ds_controller.setQualityPoint(n)`
iframe	`{ cmd: "setQualityPoint", value: n }`

There is also setAdaptiveQualityPoint in the SDK, which lets the stream move within a range rather than holding one setting. Use a fixed point when you want predictability, adaptive when you want the best picture the connection can carry at that moment.

Resolution

By default the stream follows the size of the frame or window. That is usually right, and on phones it has a consequence worth knowing: a smaller screen means a smaller frame, which means a lower stream resolution. The picture is correctly sized and looks softer than the same app on a desktop.

To hold a fixed resolution instead:

	Pin it	Release it
SDK	`e3ds_controller.setResolution(1920, 1080)`	`e3ds_controller.useViewportResolution()`
iframe	`{ cmd: "freezeResolutionAt", x: 1920, y: 1080 }`	`{ cmd: "useViewportResolution" }`

Fullscreen

Features API › Fullscreen: the same from your own page (iframe or Web SDK) or from your Unreal app, with demos and troubleshooting.

Three places this can be driven from, and they are not equivalent.

SDK

`toggleFullscreen()`

One call, and it handles the platform differences — including iOS, where only the video element can go fullscreen.

iframe

Use the browser's own Fullscreen API on your page, not a message to the frame — requestFullscreen() on the element you want enlarged. Give the iframe the allowfullscreen attribute or nothing will happen.

Blueprint

Not directly — Unreal cannot put a browser into fullscreen. What a Blueprint can do is send a message to your page (Send Pixel Streaming Response), and your page then makes one of the two calls above. Worth knowing when the trigger belongs to your scene rather than your interface.

Mouse behaviour

	Call
SDK	`e3ds_controller.switchMouseControlSchemeTo(scheme)`
iframe	`{ cmd: "switchMouseControlSchemeTo", value: scheme }`

Two schemes. Hovering leaves the cursor free, which suits configurators and anything with an interface to click. Locked captures the pointer for camera control, which suits first-person movement and is what most games expect. Choose per app, or offer both.

Features API › Mouse mode: locked or hovering: the same from your own page (iframe or Web SDK) or from your Unreal app, with demos and troubleshooting.

Sending keys to the app

For an on-screen control that should behave like a key press — a touch-screen movement pad, an action button, a menu shortcut.

What	iframe command
Press and release together	`{ cmd: "emulateKeyboardKeyPress", value: "M" }`
Hold down	`{ cmd: "emulateKeyboardKeyDown", value: "W" }`
Release	`{ cmd: "emulateKeyboardKeyUp", value: "W" }`

Any single letter or digit works, as do Space, Enter, Escape, Tab, Backspace, Shift, Control, Alt and the four arrows. The reply is a keyEmulated event saying whether the key was recognised.

Press and hold are different things. Press is a down and an up together, which is what a menu or an action key wants. Hold leaves the key down until you release it, which is what movement wants — and a single button that does both cannot hold anything.

Sound, touch and screenshots

What	SDK call	iframe command
Volume	`setVolume(level)`	`{ cmd: "setVolume", value: level }`
Touch input on or off	`setTouchInputEnabled(enabled)`	`{ cmd: "setTouchInputEnabled", value: enabled }`
Capture a frame	`captureScreenShot()`	`{ cmd: "captureScreenShot" }`
End the session	`terminate()`	`{ cmd: "ForceEndSession" }`
Which device is watching	—	`{ cmd: "sendDeviceInfo" }` — replies `takeUserDeviceInfo`, see Detect the viewer's device
Which app is streaming	—	`{ cmd: "getAppInfo" }`

Features API › End the session: the same from your own page (iframe or Web SDK) or from your Unreal app, with demos and troubleshooting.

Features API › Volume: the same from your own page (iframe or Web SDK) or from your Unreal app, with demos and troubleshooting.

Six of these are in the next platform release

setVolume, captureScreenShot, toggleFullscreen, useViewportResolution, ForceEndSession and sendDeviceInfo reached the iframe bridge in the next platform release. The current production player does not have them yet from an iframe (the Web SDK has had most of them for longer). The keyEmulated and screenshot replies described on this page arrive with the same release.

An older player does not refuse them — it ignores them. An unrecognised command reaches the end of the player's dispatcher and stops there, with no error, no warning and no reply. So a page that sends setVolume to a platform build that predates it gets silence, which is indistinguishable from a bug in your own code.

How to tell: send { cmd: "sendDeviceInfo" } once the stream is playing. It answers takeUserDeviceInfo whether or not it has anything to report, and it arrived with the same change as the other five — so one reply, or one silence, settles all six. That is exactly what the iframe demo does, which is why some of its controls are sometimes dimmed.

getAppInfo is not part of that set and is not yet on every platform either.

From an iframe, your page saves the screenshot — the frame cannot. A browser refuses a download started inside a cross-origin iframe that has no click of its own, and the click was on your button, not in the frame. Nothing is logged when this happens, which makes it a confusing failure to chase.

So the frame paints the picture and hands it back as a screenshot event carrying a PNG data URL. Your page — which is top level, and has no such restriction — saves it:

if (data.type === "screenshot" && data.ok) {
  const link = document.createElement("a");
  link.href = data.dataUrl;
  link.download = data.fileName;
  link.click();
}

Letting the viewer choose a microphone takes two more commands and has an order you have to respect — see Choose the microphone.

Knowing what the stream is doing

The SDK reports progress and events by calling functions you assign. Every one is optional; the ones you do not define are never called.

Callback	When it fires
`onDataChannelOpen`	The stream is live and ready for your commands.
`onResponseFromUnreal`	Your app sent something back to the page.
`onSessionEnding`	Any reason the session is ending, with a line of text for the viewer.
`onSessionExpired`	The session's time limit was reached.
`onReceivingApp…Progress`	Acquiring, preparing and starting, for your own loading screen.

Set stream quality from an iframeWatch on YouTube

Sending and receiving data →

Two-way communication between your page and your Unreal application.

Last updated 3 Oct 2026