Reflect performance#

The performance of Unity Reflect Review can vary significantly depending on your hardware and the complexity of your model. This page explains the different factors that can affect performances and offers performance benchmarks for midrange devices.

Performance metrics#

This document uses different metrics to talk about performance and model complexity.

• Frames per second (fps): The number of frames that your hardware can draw every second. Real-Time 3D engines (RT3D) render images fast enough to create a continuous, smooth experience as opposed to offline renderers that render one image at a time. 15-20 fps will produce a functional but not fluid experience. A fluid experience requires at least 30 fps and ideally 60 fps.

  On mobile devices, the framerate is limited to 30 fps to preserve battery.

• Object count: The number of objects in your model. This is the biggest factor in your model's performance in Reflect. Reflect keeps as much granularity as needed to maintain the integrity of the BIM information in your model, and as a result, maintains a large number of objects. Object count also has significant impact on load time.

• Instances: If you have one object that repeats itself multiple times in a model (for example, a chair repeated 10,000 times in a stadium), these are typically “instanced”: this means that only one copy of the chair is actually sent to Reflect, and then that information is used to draw the chair multiple times. Instances greatly improve performance.

• Streaming: Reflect uses data streaming to progressively download objects as needed. The first time a model is opened, every object is represented as a blue box until Reflect downloads their information. Objects are downloaded based on the camera position, their size on screen, and their occlusion, so that the objects you currently see are downloaded first. Reflect streams first from the Cloud and then caches the result on your hard drive, so future streaming is much faster.

• Memory (RAM): The available memory on your device can limit Reflect's ability to load an entire model. When Reflect detects that a device runs out of memory, it stops streaming. But don’t worry: Reflect can dynamically unload and load objects based on its streaming algorithm.

Metrics not used#

• Polygon/triangle count (poly count): This metric can vary significantly based on what is loaded as well as the decimation technique used. Because each model is converted into geometry (tessellated) in different ways, this is not a good metric to use when comparing models and applications.
• Model size (MB or GB): The size of the model on disk does not affect Reflect's performance. Small models can be very complex and large models can perform very smoothly: the nature of the model has a far greater impact than the total model size.

Reflect optimization#

Reflect automatically processes your models to make them load and render faster on all devices.

Note: Because of the amount of processing power required, these optimizations for Reflect are only available for projects in the cloud. Locally exported models will not benefit from these optimizations.

• Decimation: When objects have a very large amount of polygons, Reflect will attempt to reduce them without compromising their visual quality. This is done using PiXYZ algorithms, and will greatly reduce the polycount on complex objects. Simple objects like walls will not be affected.

• Occlusion: Occlusion means that something is hidden, either because it is outside the Camera view frustum or because it is behind another object like a wall. Reflect takes advantage of this and does not draw occluded objects. Architectural models greatly benefit from occlusion, because walls occlude MEP systems or furniture in rooms that cannot be seen.

• Hierarchical Levels of Details (HLODs): Reflect takes advantage of HLODs to determine which parts of the scene should be streamed at which level of quality.

  With HLODs, models that are very far away are merged into a single, low-resolution object that requires fewer resources to draw. As you move closer to the object, it loads into its components, allowing higher visual fidelity and letting you access the object’s BIM data or metadata at the necessary level of granularity.

  The HLOD system also allows you to load partial scenes, preventing the mobile application from closing unexpectedly if your device runs out of memory.

• Actor System: Unity leverages an actor system to efficiently load models. This allows the import and load process to use all your CPU cores at once, making it a parallelized (multi-threaded) process.

Tips for improving performance#

While Reflect uses performance- enhancing methods and processing, you may still experience slow performance with large models. This section provides tips to help.

Limit your model#

Section off parts of the model you don’t need, or hide objects that are unnecessary, before exporting it to Reflect. Don’t include the MEP systems if they are not useful. For larger models, Reflect supports section boxes so you can export the model in different sections or views.

Download the model first#

If loading time is an issue, try downloading the model before opening it. The projects window displays a ... icon next to the name of each project: click on it and click Download. Once the download is finished, opening the model is much faster.

Make further optimizations#

Very large models may need optimization. PiXYZ Studio is a tool that lets you optimize geometry, remove hidden objects, replace materials, merge objects, and make other optimizations. PiXYZ Studio also has a Reflect plug-in.

Examples#

Here are a few examples of typical Reflect models and what level of performance you can expect based on different factors.

What’s next?#

Every new version of Unity Reflect will get better and better when it comes to performance and loading larger models. Our team is dedicated to achieving our goal of handling “Unlimited Models."

There are a multitude of different methods, algorithms, and technologies that we are exploring to reach this goal. Some of these are as simple as better optimizing the geometry, and some will take more time to explore new ways of doing things, but we are 100% committed to enabling real-time 3D on all devices regardless of model complexity or device capabilities.

Benchmarks#

Two devices were used to benchmark different models:

Thin & light Ultrabook (Dell XPS 2018)

• Intel Core i9-8950HK @ 2.9GHz
• 32GB RAM
• Intel UHD Graphics 630 + NVidia GTX 1050ti

iPad Pro, 4th generation (2020)

• Apple A12 Chip
• 8GB RAM

Note: On PC, the framerate is capped to a maximum of 60 fps. On mobile devices, the framerate is capped at 30 fps to save battery power.

Supermarket#

]

Object count: 2,050

Download time: <10s

Hospital#

]

Object count: 5,617

**Download time: **30s

High-rise hotel#

]

Object count: 64,969

**Download time: **2m 17s

Steel plant#

]

Object count: 2,581

**Download time: **1m 22s