Umbra SceneStream SDK

Umbra SceneStream SDK enables you to integrate large and complex 3D scenes into the context of any application or workflow.

The SDK supports relevant low-level APIs and includes handy developer tools to get you streaming those triangles in no time.

Native SDK

The SDK has been designed to use a low-level C-API for maximizing performance. It also includes C++ and C# wrappers.

Main components

Import

Upload meshes, textures and point clouds into SceneStream

Runtime

Stream and render umbrafied 3D scenes for client-side

Developer tools

Command Line Interface

Upload 3D content into SceneStream and launch umbrafications

Inspect

A desktop viewer tool to quickly visualize umbrafied scenes (Windows, MacOS, Linux)
Umbra Native SDKC++
int main(int argc, char** argv) {
  Umbra::Client client = Umbra::Client("RuntimeSample");
  Umbra::EnvironmentInfo env;
  UmbraEnvironmentInfoDefaults(&env);
  Umbra::Runtime runtime(*client, env);

  // Create a Scene by connecting it to a model
  Umbra::Scene scene = runtime.createScenePublic(publicLink);

  // Wait for connection so that camera can be initialized
  while (scene.getConnectionStatus() == UmbraConnectionStatus_Connecting);

  Umbra::View view = runtime.createView();

  // Setup rendering target and OpenGL

  int windowWidth = 1280;
  int windowHeight = 1024;

  SDL_Window* window;
  SDL_GLContext mainContext;
  initializeSDLAndOpenGL("Umbra runtime sample", windowWidth, windowHeight, window, mainContext);

  // Initialize camera
  Camera camera;
  camera.initialize(scene, windowWidth, windowHeight);

  float currentTime = getTime();

  while (true)
  {
    // SDL event update omitted

    // Perform streaming work for some time
    work(runtime, 10.0f / 1000.0f); // 10 ms streaming budget

    // Update View and Runtime with new camera

    glm::mat4 worldToClip = camera.getProjection() * camera.getCameraMatrix();

    view.updateRendering(
    toUmbra(worldToClip),
    toUmbra(camera.getCameraPosition()),
    UmbraDepthRange_MinusOneToOne,
    UmbraMatrixFormat_ColumnMajor,
    g_quality);

    runtime.update();

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // Render all objects in the View in batches

    for (;;)
    {
      Umbra::Renderable batch[ 128 ];
      int num = view.nextRenderables(batch, 128);
      if (!num)
      break;

      for (int i = 0; i < num; i++)
      {
        glm::mat4 transform = *(glm::mat4*)&batch[ i ].transform.v[ 0 ].v[ 0 ];

        renderMesh(
        camera.getCameraPosition(),
        camera.getProjection(),
        transform * camera.getCameraMatrix(),
        glm::mat3(transform),
        (const Mesh*)batch[ i ].mesh);
      }
    }

    SDL_GL_SwapWindow(window);
  }

  // cleanup code omitted

Umbra.js and three.js

Umbra.js is a low-level Javascript API that enables the integration of SceneStream into any web application. We also offer an integration to one the most used 3D JavaScript libraries - three.js - that allows you to build immersive web experiences right out of the box.

Umbra.js and three.jsJavaScript
let renderer = new THREE.WebGLRenderer({ canvas })let Umbra = await UmbraRuntime.initWithThreeJS(renderer)
let umbraScene = Umbra.createScene('key=pubk-6f592e67-5aec-479a-ad9e-46ad4e4fe699&project=745415655&model=745415871')let scene = new THREE.Scene()
let camera = new THREE.PerspectiveCamera(75, 1.0, 0.01, 1000)
​
scene.add(umbraScene)let animate = function () {
 Umbra.update()
 renderer.render(scene, camera)
 requestAnimationFrame(animate)
}

Unity

We also ship a dedicated SceneStream for Unity SDK that allows you to stream umbrafied assets directly into your application or use Unity’s file importers to upload new content into SceneStream. It uses the C#-wrappers and is shipped as a separate plugin.

Components

Import

Upload 3D assets to SceneStream directly from your Unity scene

Runtime

Stream in umbrafied 3D content into your application

Demos

Three.js demo

Tommi Toija Studio

This model is a complete 3D scan of artist Tommi Toija's studio in Helsinki, Finland.

After a day of shooting, the model was reconstructed from 2,500 photos (50 megapixels each) using RealityCapture photogrammetry software, totalling 2.4B triangles and 525 4K textures. The high-poly mesh was Umbrafied using the Command Line Interface and the output can be shared in browsers using, for example Umbrajs or our three.js-integration.

The rights, title and intellectual property rights to all content on this site are vested in Umbra and/or their respective third party owners and licensors.

Get Access

We’re currently looking for development partners to grant early access.