At its core, Umbra is a C++ SDK that consists of two components – geometry processing and runtime.
The geometry processing component takes the 3D scene or model as input and processes it into a spatially organized and optimised representation, namely – the Umbra 3D database. The runtime component can be used to issue queries into the 3D database which then help in the rendering, streaming and spatial reasoning of the 3D data.
Umbra’s operation has three stages:
The input geometry (triangles and textures or, optionally, point clouds) is either uploaded into the Umbra Cloud or input through the C++ API for local computation. Umbra can easily handle arbitrarily complex 3D geometry with no restrictions on the shape or structure of the data, while the Umbra Cloud backend offers capacity for unlimited data size.
Umbra processes the 3D data and based on visibility and connectivity re-arranges it into a hierarchical spatial database. The processing is based on voxelization of the input and identifying the spatial features of the scene from the voxel representation. As well, Umbra can create a multi-resolution remeshing of the original geometry, which can then be efficiently used hand-in-hand with visibility queries.
Umbra’s computation can be parallelized across multiple cores or machines. The Umbra Cloud scales elastically to always guarantee extremely fast turnaround times. The Umbra Cloud automatically handles incremental computation and the caching of intermediate results, ensuring a hassle-free user experience.
Umbra has been used to optimize the rendering of many video games. The software has been developed by the sharpest minds of the industry, and over the years it has evolved to cover an ever-expanding list of use-cases, mostly in rendering. Umbra is constantly improving, and expanding its role in optimizing and delivering 3D content.
Example Scenario: An application with a lot of overdraw — i.e. 3D models obstructing other 3D models. A good example of this is a first-person-shooter video game with mixed outdoor and indoor locations and/or terrain features that obstruct other parts of the scene.
Occlusion culling is Umbra’s bread and butter and the most commonly used of Umbra’s features in today’s video games. For a given view, Umbra’s visibility query returns a list of objects that are visible to be drawn on the display. The rendering engine then focuses on just these visible objects saving CPU and GPU processing power which is then available to increase the frame rate or the overall fidelity of the graphics.
Umbra’s occlusion culling feature set is mature, stable and available for licensing now.
Example scenario: A massive 3D model or scene which doesn’t fit into the rendering or memory budget of the target device. Imagine a 3D model of an entire city, with all the interiors included, rendered in VR or on a mobile device. The data can’t be loaded into memory and certainly exceeds the rendering budget of the graphics hardware.
Umbra can automatically re-arrange and optimize this massive amount of data into streamable pieces that are guaranteed to fit into specific budgets for each device. The user can specify a triangle-rendering budget as well as how much data can be loaded into memory, and Umbra handles the rest.
Umbra uses the visibility data to figure out what part of the scene needs to be streamed in, and then what needs to be rendered on the screen. If something is guaranteed to be hidden it needn’t be loaded into memory.
The Umbra database contains multiple versions of the geometry and textures at different levels of detail and the appropriate resolution of the data is chosen based on distance and visibility – higher resolution is needed close to the viewer, while far away objects can use lower resolution.
This unique combination of visibility, level-of-detail and 3D content streaming makes it possible for Umbra to guarantee that budgets are met from any viewpoint inside the scene. Looking at a wide vista over a city? Or standing inside a closed room within this same scene? Umbra will make sure you have only the necessary data loaded at any given time with the frame-rate you need for your application.
Example scenario: Resolving the shortest non-obstructed route between an audio source and a receiver.
Umbra’s 3D database is essentially a simplified topological representation of the 3D environment. Often applications – most commonly videogames – require information about the spatial features of the scene to implement intelligent AI, realistically behaving audio effects, or broad-phase collision detection. Umbra currently features a number of custom, lightning-fast queries that can be used to implement such operations: