Required packages

The RoomPlan for Unity Kit contains interfaces for augmented reality functions and implements these functions itself. You do not need any additional packages or tools to use AR.

Custom XR

To use the XR (custom) features of the RoomPlan for Unity Kit, you will need to install additional augmented reality packages.

AR Foundation:

To use AR Foundation, you need to add the following packages:

• AR Foundation;
• Apple ARKit XR plugin on iOS;

Features

AR Foundation support:

RoomPlan for Unity Kit is fully compatible with ARFoundation and is ready to use and interact with all available features in Unity (iOS 17+).

Creating a 3D room model:

RoomPlan for Unity Kit allows you to create a 3D model of an interior room using device sensors, trained machine learning models, and Unity's rendering capabilities.

Detection of physical structures:

The RoomPlan API analyzes camera video feeds and LiDAR data to identify walls, windows, doors, and other physical structures in a room.

Detection of furniture and appliances:

RoomPlan recognizes room features, furniture, and appliances such as a fireplace, bed, or refrigerator and provides this information to the app.

Displaying AR tips:

Users are shown virtual on-screen guidance during scanning that indicates the direction and progress of the scan.

Processing of scan results:

Scan results are displayed in a parametric data format, allowing the application to modify individual components of the scanned room.

Exporting a 3D model:

After combining the scans into a single structure, you can export a 3D model that includes all the rooms captured in that physical area.

Merge scans:

You can combine the scans of several rooms into a single structure (CapturedStructure). This allows you to create a model file and analyze specific shapes, sizes, or objects that RoomPlan observes in the structure.

Support for rooms with different floors and surfaces:

Scanned structures support rooms with different floor heights and rooms on different floors in a building.

Components:

Platform support

The RoomPlan plugin for the Unity Kit relies on platform-specific implementations of augmented reality features, such as Apple's ARKit on iOS/iPadOS. Not all features are available on all platforms.

iOS version:

• iOS 16+

iPadOS version:

• iPadOS 16+

Limitations

Devices:

All devices with a LIDAR sensor are supported for scanning mode.

Samples

Samples.

RoomPlan for Unity Kit (Default):

RoomPlan for Unity Kit (XR):

Utilities:

Install RoomPlan for Unity Kit

To install RoomPlan for Unity Kit, simply import the package into your project.

Scene setup

Each AR scene in your app must have three mandatory GameObjects: RoomPlan Unity Kit, Captured Room Snapshot, and Session Origin.

The RoomPlan Unity Kit GameObject enables and controls AR on the target platform, the Captured Room Snapshot interacts with the framework and builds scanned 3D objects in real time, and the Session Origin GameObject enables device tracking and transforms tracked objects into the Unity coordinate system. If one of these GameObjects is not present in the scene, augmented reality will not work properly.

To create a Unity Kit RoomPlan, Captured Room Snapshot, and Session Origin, right-click in the Hierarchy window and select one of the following options from the shortcut menu.

Silver Tau > RoomPlan for Unity Kit > RPU Kit

or

Window > Silver Tau > RoomPlan for Unity Kit > Prepare and check the RPU

After adding the RPU Kit to the scene, the hierarchy window will look like the one below.

This is the default scene setup, but you can rename or change the parentage of the GameObjects to suit your project's needs.

The RoomPlan Unity Kit, Captured Room Snapshot, and Session Origin GameObjects and their components play an important role in the project.

Universal Render Pipeline

No special settings are required when using the Universal Render Pipeline. The whole process is automated.

RoomPlan Unity Kit

The main component that creates the connection between the Unity engine and the RoomPlan framework.

The RoomPlan Unity Kit framework uses the RoomPlan API, device sensors, trained ML models, and RealityKit rendering capabilities to render the physical environment of an indoor room in the Unity Engine. For example, the framework checks the device's camera image and LiDAR data to identify walls, windows, openings, and doors. The framework also receives functionality from RoomPlan, which recognizes room features, furniture, and appliances, such as a fireplace, bed, or refrigerator, and provides this information to the app.

To start the capture, the app presents a view (RoomCaptureView) through which the user can see their room in augmented reality. The view displays virtual cues as the user moves around the room:

• Real-time graphical overlays are displayed on top of physical structures in the room to show the progress of the scan.
• If the framework requires a certain type of device movement or perspective to complete the scan, instructions are displayed in the interface to explain how to position the device.

When the program determines that the current scan is complete, a smaller version of the scanned room is displayed in the window for user approval.

Actions

Use this to create some dynamic functionality in your scripts. Unity Actions allow you to dynamically call multiple functions.

enum CaptureStatus
{
  None = 0,
  Processing = 1,
  Paused = 2,
  Scanning = 3,
}

Start/End scanning session:

//A function that initializes a framework.
//Use it if the framework has not been initialized before.
RoomPlanUnityKit.Initialize();

//A function that starts a RoomPlan scanning session.
RoomPlanUnityKit.StartCaptureSession();
//A function that stops a RoomPlan scanning session.
RoomPlanUnityKit.StopCaptureSession();

//A function that disposes of a framework.
//Use it if you want to unload the framework.
RoomPlanUnityKit.Dispose();

Start Capture Session with AR World Map:

public class CustomScript : MonoBehaviour
{
  public void Run()
  {
    var arWorldMapDirectoryPath = Path.Combine(Application.persistentDataPath, "ARWorldMaps");
    if (!Directory.Exists(arWorldMapDirectoryPath))
    {
        Directory.CreateDirectory(arWorldMapDirectoryPath);
    }

    var arWorldMapPath = Path.Combine(arWorldMapDirectoryPath, "targetWorldMap");
	
    if (File.Exists(arWorldMapPath))
    {
        roomPlanUnityKit.StartCaptureSessionWithARWorldMap(arWorldMapPath);
    }
    else
    {
        roomPlanUnityKit.StartCaptureSession();
    }
  }
}

Stop Capture Session with AR World Map:

public class CustomScript : MonoBehaviour
{
  public void Stop()
  {
    var arWorldMapDirectoryPath = Path.Combine(Application.persistentDataPath, "ARWorldMaps");

    if (!Directory.Exists(arWorldMapDirectoryPath))
    {
        Directory.CreateDirectory(arWorldMapDirectoryPath);
    }
	
    var arWorldMapPath = Path.Combine(arWorldMapDirectoryPath, "targetWorldMap");
	
    if (roomPlanUnityKit.StopCaptureSessionWithARWorldMap(arWorldMapPath))
    {
        Debug.Log("The session was stopped successfully.");
    }
    else
    {
        Debug.Log("The session is stopped unsuccessfully.");
    }
  }
}

Stop/Continue capture session with a pause:

//Stops the room capture session with the specified AR session parameter. Used to be able to stop the session and add a new scanning room.
RoomPlanUnityKit.StopCaptureSessionWithPause(true);
//Starts a room capture session with the specified configuration after the session was stopped with a pause (StopCaptureSessionWithPause).
RoomPlanUnityKit.RunCaptureSession();

Pause/Resume a scanning session:

//A method that resumes a RoomPlan scanning session. After using this method, the process of transferring snapshot data and creating objects in augmented reality continues.
RoomPlanUnityKit.ResumeCaptureSessionScanning();
//A method that paused a RoomPlan scanning session. After using this method, the process of transferring snapshot data and creating objects in augmented reality is suspended.
RoomPlanUnityKit.PauseCaptureSessionScanning();

Saving the room scanning experience:

//A method that allows you to preserve the scanning experience. To save the data, the last snapshot of the experience in augmented reality is taken.
RoomPlanUnityKit.SaveRoomPlanExperience("Scan name", "Directory name");

Update RoomPlan for Unity Kit Settings:

//A method that updates the main RoomPlan settings in real time.
//By updating RoomPlan Unity Kit Settings, all settings will be applied.
RoomPlanUnityKit.UpdateRPUKitSettings();

Session Camera

Device cameras and their configuration are an essential function of most AR apps. A component that communicates with the framework and enables the camera to navigate in real space.

The Session Camera is fully synchronized with the ARKit camera and transmits real-time positions, projection, and all additional settings for a complete immersion in augmented reality.

Change the camera:

//An additional way to install a new camera.
//This method helps you change the main camera of a session to another one if you need it.
RPUSessionCamera.SetNewCamera();

Update Camera TRS (Translation, Rotation and Scaling):

//A method that updates the position, rotation, and scale of the camera in real time.
//The main purpose of the method is to stabilize and parallelize the camera's broadcast data frame by frame.
RPUSessionCamera.UpdateCameraTRS(Camera inputCamera, string transformData, string projectionData);

Captured Room Snapshot

This class is used only when creating an augmented reality session. A component that interacts with the framework and builds scanned 3D objects in real time. With the help of additional methods, the process of creating objects that are rendered in Unity is implemented and allows you to take separate data for each object during the experience.

This structure represents the processed-post-processed result of the room-scanning process.

Your app receives an instance of this structure through:

• With the room details, an app can provide custom features, such as rendering the room andenabling the user to modify the position of its objects.

Room Snapshot:

//A method that creates objects from a real-time snapshot. Only during the experience, a session in augmented reality.
RoomPlanCapturedSnapshot.RoomSnapshot(string snapshot);

Room Snapshot (Editor):

//A method that creates objects from a snapshot in the Unity Engine editor.
RoomPlanCapturedSnapshot.EditorRoomSnapshot(string snapshot);

[Beta] Add a new room to the snapshot:

//This is a function that performs the action of adding a new room during an AR object scanning session. Only for iOS 17+.
RoomPlanCapturedSnapshot.AddedNewRoomToSnapshot();

Dispose:

//A method that disposes of a Captured Room Snapshot.
RoomPlanCapturedSnapshot.Dispose();

Room Builder

This class can be used at any time, except during an augmented reality session (experience). A component that allows you to build a room from the specified parameters. With the help of additional methods, it implements the process of creating objects that are visualized in Unity and allows you to take separate data for each object during the experience.

Your app generates a detailed captured room object on the raw data. Your app can then inspect or modify this data before exporting the scanned room to a USDZ file or JSON snapshot.

Room Builder initialization:

//Room Builder initialization without additional options.
var roomBuilder = new RoomBuilder();

//or

//Initialization of Room Builder with additional options.
var roomBuilder = new RoomBuilder
{
   container = modelViewerContainer,
   prefabRoomPlanObject = prefabRoomPlanObject,
   createFloor = RoomPlanUnityKit.CurrentRoomPlanUnityKitSettings.createFloorToRoomBuilder,
   useMeshBooleanOperations = RoomPlanUnityKit.CurrentRoomPlanUnityKitSettings.useMeshBooleanOperationsForRoomBuilder,
   meshBooleanOperations = RoomPlanUnityKit.CurrentRoomPlanUnityKitSettings.meshBooleanOperationsForRoomBuilder
};

Floor settings:

This settings block allows you to customize the floor builder.

Type Floor Constructor - The floor constructor type allows you to choose which main target objects will be used to build the floor.

Concavity - Concavity is a value used to restrict the concave angles.

It can go from -1 (not concave at all) | 0 (no concavity - convex is used) | to 1 (extreme concavity).

Avoid concavity == 1 if you don't want 0o angles.

In AR mode, the parameter will be 0.

An example of the Concavity algorithm:

Create a room from a snapshot:

//A method that creates objects from a real-time snapshot.
//The creation process will take place from the uploaded input snapshot.
RoomBuilder.CreateRoomFromSnapshot(string snapshot, Action successfully = null, Action error = null);

Create a room from a Captured Structure:

//A function that allows you to perform the action of creating a room with an input captured structure.
RoomBuilder.CreateRoomFromCapturedStructure(CapturedStructure capturedStructure, Action successfully = null, Action error = null);

Create a room from a Captured Room:

//A function that allows you to perform the action of creating a room with an input captured room.
RoomBuilder.CreateRoomFromCapturedRoom(CapturedRoom capturedRoom, Action successfully = null, Action error = null)

Create a room from a Captured Rooms:

//A function that allows you to perform the action of creating a room with an input captured rooms.
RoomBuilder.CreateRoomFromCapturedRooms(CapturedRoom[] capturedRooms, Action successfully = null, Action error = null)

Converting a snapshot to the Captured Structure class:

//A function that performs the action of converting a snapshot to a CapturedStructure class.
var capturedStructure = RoomBuilder.GetCapturedStructureFromSnapshot(string snapshot, Action error = null)

Dispose:

//A method that disposes of a Room Builder.
RoomBuilder.Dispose(Action callback = null);

Captured Room

This structure represents the post-processed result of the room-scanning process.

Your app receives an instance of this structure through:

• A room builder object (RoomBuilder) for an app that provides its own room-scanning view, or processes the saved results of a prior scan.
• With the room details, an app can provide custom features, such as rendering the room and enabling the user to modify the position of its objects.

Inspecting room details:

//A unique alphanumeric value that the framework assigns to the room.
var identifier: UUID

//The story (floor number) on which the captured room resides within a larger structure.
var story: Int

//An array of floors that the framework identifies during a scan.
var floors: [CapturedRoom.Surface]

//A 2D area in a room that the framework identifies as a surface.
struct Surface

//An array of doors that the framework identifies during a scan.
var doors: [CapturedRoom.Surface]

//An array of objects that the framework identifies during a scan.
var objects: [CapturedRoom.Object]

//A 3D area in a room that the framework identifies as an object.
struct Object

//An array of openings that the framework identifies during a scan.
var openings: [CapturedRoom.Surface]

//An array of walls that the framework identifies during a scan.
var walls: [CapturedRoom.Surface]

//An array of windows that the framework identifies during a scan.
var windows: [CapturedRoom.Surface]

//One or more room types that the framework observes in the room.
var sections: [CapturedRoom.Section]

//An object that identifies a particular area in a captured room in relation to common types of room areas in a building.
struct Section

//Levels of certainty in the classification of a particular detail in a scan.
enum Confidence

//A version number for the captured room.
var version: Int

Captured Structure

An object that holds the results of the merger of multiple capture sessions.

This structure combines the data from multiple CapturedRoom instances that a user scans in the same physical vicinity. The StructureBuilder class’s function merges the captured rooms, which returns an object of this type.

Inspecting structure details:

//A unique alphanumeric value that the framework assigns the structure.
var identifier: UUID
								
//An array of all the floors in the structure.
var rooms: [CapturedRoom]

//An array of all the floors in the structure.
var floors: [CapturedRoom.Surface]

//The type a captured structure assigns to surfaces.
struct Surface

//An array of all the doors in the structure.
var doors: [CapturedRoom.Surface]

//An array of all the objects in the structure.
var objects: [CapturedRoom.Object]

//The type a captured structure assigns to objects.
struct Object

//An array of all the openings in the structure.
var openings: [CapturedRoom.Surface]

//An array of all the walls in the structure.
var walls: [CapturedRoom.Surface]

//An array of all the windows in the structure.
var windows: [CapturedRoom.Surface]

//One or more room types that the framework identifies in the structure.
var sections: [CapturedRoom.Section]

//The type a captured structure assigns to distinct room areas.
struct Section

//A version number for the captured structure.
var version: Int

RoomPlan Object

A component that has the main characteristics of the scanned object.

This abstract class is used to serve and create your own objects. A component that has the main characteristics of the scanned object.

Captured Object Attributes:

Determine details about the objects and surfaces that the framework identifies in a scan.

Each Object contains attributes that the framework observes during a scan that convey details about the object. For example, an object of category Object.Category.chair may contain the attributes ChairType.stool and ChairLegType.star, which describes the framework’s observations of the chair during the scan. An object exposes these details through its attributes array.

By reading the attribute information the framework sets on objects, your app can provide more informed utility with a scanned room, such as:

• A filtered list of product selections in a furniture catalog that matches just the categories and attributes of the present objects in the room.
• A more accurate visual representation, for example when rendering a virtual reality experience, by substituting the default object bounding boxes with detailed 3D models that your app chooses.

Examples of use:

Parse Object Attributes (Convert Dictionary To Enums):

public class ObjectAttributes : MonoBehaviour {

  public void ConvertDictionaryToEnums(RoomPlanObject roomPlanObject)
  {
    var attributes = roomPlanObject.ParseObjectAttributes();
            
    if (attributes.Count == 0)
    {
        Debug.Log("The attributes are empty!");
        return;
    }
        
    foreach (var attribute in attributes)
    {
        Debug.Log(string.Format("Enum Type: {0}, Value: {1}", attribute.GetType().Name.ToString(), attribute));
    }
  }
}

public class CapturedRoomObject : RoomPlanObject {

  //An abstract method that is executed when an object is initialized and passes certain data.					
  public override void InitObject(Vector3 position, Quaternion rotation, Vector3 scale){ }

  //An abstract method that is executed when an object is updated and passes certain data.
  public override void UpdateObject(Vector3 position, Quaternion rotation, Vector3 scale){ }

  //An abstract method that is executed when an object is removed and passes certain data.
  public override void RemoveObject()
  {
    Destroy(gameObject);
  }
}

RoomPlan Unity Kit Settings

This is a script object that has characteristics for customizing RoomPlan for Unity Engine. Here you can customize the availability of main functions for your case and needs.

An example of adding a two-sided render for a shader:

public class CapturedRoomObject : RoomPlanObject {
  private void UpdateFloorOrCeiling()
  {
	if (CurrentCapturedRoomObject.category != CapturedRoom.Category.floor || CurrentCapturedRoomObject.category != CapturedRoom.Category.ceiling) return;
	meshRenderer.material = new Material(meshRenderer.material);
	meshRenderer.material.SetFloat("_Cull", (float)CullMode.Off);
  }
}

Flashlight Manager

Flashlight Manager is a manager class that allows you to control the flashlight of a device during scanning or resting. It performs an auxiliary function, additional lighting, in the real world for better scanning. The manager also has the function of manually turning on/off the device's flashlight.

The main purpose of this manager is to improve scanning in low-light conditions in the real world. It can be used during nighttime scanning.

Change status:

public class FlashlightManager : MonoBehaviour
{
  private bool _isFlashlightEnable;

  #region MonoBehaviour

  private void OnDisable()
  {
    if (_isFlashlightEnable)
    {
      SetFlashlightStatus(false);
      _isFlashlightEnable = false;
    }
  }

  #endregion
        
  #region Flashlight methods
        
  //A method that allows you to set the state of the flashlight. It can be used even when running an AR Session.
  public void SetFlashlightStatus(bool status)
  {
    RoomPlanUnityKit.SetFlashlightStatus(status);
    _isFlashlightEnable = status;
  }

  //A method that allows you to automatically set the state of the flashlight (on/off).
  public void FlashlightOnOff()
  {
    _isFlashlightEnable = !_isFlashlightEnable;
    RoomPlanUnityKit.SetFlashlightStatus(_isFlashlightEnable);
  }
        
  #endregion
}

Custom Session Instruction

Custom Session Instruction is a class that allows you to manage hints from the RoomPlan API. It can be customized as you like. To get it working, don't forget to configure the RoomPlan Unity Kit settings file.

Determining a coaching recommendation::

• normal - An instruction that indicates scanning proceeds normally and the user needs no coaching.
• moveCloseToWall - An instruction that requests the user move closer to the wall.
• moveAwayFromWall - An instruction that requests the user move further from the wall.
• turnOnLight - An instruction that requests the user increase the amount of light in the room.
• slowDown - An instruction that requests that the user move slower.
• lowTexture - An instruction that indicates the framework doesn’t detect distinguishable room features.

Interact with instructions (tips) during scanning:

public class CustomSessionInstruction : MonoBehaviour
{
  private void OnEnable()
  {
    RoomPlanUnityKit.captureSessionInstruction += CaptureSessionInstruction;
  }

  private void OnDisable()
  {
    RoomPlanUnityKit.captureSessionInstruction -= CaptureSessionInstruction;
  }

  #region Capture Session Instruction process

  private void CaptureSessionInstruction(CapturedRoom.SessionInstruction sessionInstruction)
  {
    Debug.Log(sessionInstruction);
  }
        
  #endregion
}

Custom Capture Error Handler

The Custom Capture Error Handler is a class that allows you to manage errors that are thrown during scanning from the RoomPlan API. It can be customized as you wish.

Errors that can occur during a room-capture session:

• None - There are no errors, everything works properly.
• ExceedSceneSizeLimit - An error that indicates when the scene size grows past the framework's limitations.
• WorldTrackingFailure - An error that indicates an issue with the underlying ARKit session.
• InvalidARConfiguration - An error that indicates when the ARKit session runs an unsupported configuration.
• DeviceTooHot - An error that indicates when the device thermal metrics surpass the framework's limitations.
• DeviceNotSupported - An error that indicates that the framework doesn't support the user's device.
• InternalError - An error that indicates when the framework encounters an unexpected error case.

Interact with errors during scanning:

public class CustomCaptureErrorHandler : MonoBehaviour
{
  private void OnEnable()
  {
    RoomPlanUnityKit.captureError += CaptureError;
  }

  private void OnDisable()
  {
    RoomPlanUnityKit.captureError -= CaptureError;
  }

  #region Capture Error process

  private void CaptureError(RoomCaptureSession.CaptureError error)
  {
    Debug.Log(error);
  }
        
  #endregion
}

Camera Stream

The RPUCameraStream class provides access to a live video stream from the device's camera in real-time. This allows developers to create custom camera previews using Unity’s UI system, independent of AR processing or tracking.

This can be useful for:

• Displaying the live camera feed in a UI panel (e.g., picture-in-picture).
• Capturing a raw visual feed for processing or analysis.
• Building augmented interfaces without full ARScene rendering.
• Creating screenshots and capturing images from the camera;

Properties:

Functions:

How to Use RPU CameraStream:

The RPUCameraStream class gives you access to the raw camera feed in real-time as a Texture2D. You can use this texture in any way you want – whether to display it in a UI element, send it for processing, or use it in shaders, compute buffers, or machine learning pipelines.

Below is an example of how to display the camera stream on a UI panel, but this is just one possible use case.

Common Setup:

// 1. Initialize the camera stream
var _rpuCameraStream = new RPUCameraStream();

// 2. Subscribe to OnFrame event
_rpuCameraStream.OnFrame += OnFrameReceived;

// 3. Start streaming
_rpuCameraStream.Run();

// 4. In Update(), process pending native frames
_rpuCameraStream.ProcessCameraFrame();

// 5. On disable or destroy
_rpuCameraStream.Stop();
_rpuCameraStream.OnFrame -= OnFrameReceived;
_rpuCameraStream = null;

[SerializeField] private RawImage myRawImage;
[SerializeField] private AspectRatioFitter aspectRatioFitter;

using UnityEngine;
using UnityEngine.UI;
using SilverTau.RoomPlanUnity;

namespace SilverTau.Sample
{
    // Displays a real-time camera stream using RPUCameraStream on a UI RawImage.
    public class RPUCameraStreamer : MonoBehaviour
    {
        [Header("UI Settings:")]
        [Tooltip("UI RawImage component used to display the camera frame.")]
        [SerializeField] private RawImage myRawImage;
        
        [Tooltip("Maintains correct aspect ratio for the displayed image.")]
        [SerializeField] private AspectRatioFitter aspectRatioFitter;

        // The camera stream handler.
        private RPUCameraStream _rpuCameraStream;
        
        private void OnEnable()
        {
            _rpuCameraStream = new RPUCameraStream();
            _rpuCameraStream.OnFrame += OnFrameStream;
            _rpuCameraStream.Run();
        }

        private void OnDisable()
        {
            _rpuCameraStream.Stop();
            _rpuCameraStream.OnFrame -= OnFrameStream;
            _rpuCameraStream = null;
        }

        private void OnFrameStream(Texture2D tex)
        {
            myRawImage.texture = tex;
            aspectRatioFitter.aspectRatio = (float)tex.width / tex.height;
        }

        private void Update()
        {
            if (_rpuCameraStream == null) return;
            _rpuCameraStream.ProcessCameraFrame();
        }
    }
}

Install RoomPlan for Unity Kit (XR)

To install RoomPlan for Unity Kit, simply import the package into your project.

XR Scene setup

Installing an XR scene is similar to installing a regular RoomPlan for Unity Kit AR scene, but there are additional steps. We will describe everything from the beginning.

Each AR scene in your app must have three mandatory GameObjects: RoomPlan Unity Kit, Captured Room Snapshot, and Session Origin.

The RoomPlan Unity Kit GameObject enables and controls AR on the target platform, the Captured Room Snapshot interacts with the framework and builds scanned 3D objects in real time, and the Session Origin GameObject enables device tracking and transforms tracked objects into the Unity coordinate system. If one of these GameObjects is not present in the scene, augmented reality will not work properly.

To create a Unity Kit RoomPlan, Captured Room Snapshot, and Session Origin, right-click in the Hierarchy window and select one of the following options from the shortcut menu.

Silver Tau > RoomPlan for Unity Kit > RPU Kit (XR)

or

Window > Silver Tau > RoomPlan for Unity Kit > Prepare and check the RPU (XR)

After adding the RPU Kit (XR) to the scene, the hierarchy window will look like the one below.

After that, you need to add the XR Session Service to the main ARSession object.

XR Session Service is a script created to manage XR sessions for RoomPlan for Unity Kit.

It performs the functions of combining a session with RoomPlan for Unity Kit.

This is the default scene setup, but you can rename or change the parentage of the GameObjects to suit your project's needs.

The RoomPlan Unity Kit, Captured Room Snapshot, and Session Origin GameObjects and their components play an important role in the project.

Extensions

The extension features that will help you interact with various XR systems and their components.

AR Session:

This is an extending function for AR Session (subsystem) that combines work sessions. To use it, you need to initialize (enable) the ARSession and execute the extension.

ARSession.Combine_And_Start_RPU_XR_Session();

Quick Look

When showing files in your app, including the ability to quickly preview a file and its content can be helpful to your users. For example, you may want to allow users to zoom into a photo, play back an audio file, and so on. Use the Quick Look framework to show a preview of common file types in your app that allows basic interactions.

Quick Look can generate previews for common file types, including:

• iWork and Microsoft Office documents;
• Images;
• Live Photos;
• Text files;
• PDFs;
• Audio and video files;
• Augmented reality objects that use the USDZ file format (iOS and iPadOS only);

Quick Look:

public class CustomQuickLook : MonoBehaviour
{
  // A function that opens the object for quick viewing.
  public void QuickLook()
  {
    QuickLook.OpenQuickLook(string path);
  }
}

Export 3D Model

The "Export 3D Model" utility is still under development. At the moment, we are developing the logic and interface for interacting with the utility. In the next updates, it will be available for public use and for all your application development needs.

CSGeometry

Constructive solid geometry (formerly called computational binary solid geometry) is a technique used in solid modeling. Constructive solid geometry allows a modeler to create a complex surface or object by using Boolean operators to combine simpler objects, potentially generating visually complex objects by combining a few primitive ones.

Additive:

public class CustomCSG : MonoBehaviour
{
  // A function that combines objects.
  public void Additive()
  {
    SilverTau.Utilities.CSGeometry.Additive(GameObject targetObject, GameObject[] objects);
  }
}

Subtractive:

public class CustomCSG : MonoBehaviour
{
  // A function that subtractive objects.
  public void Subtractive()
  {
    SilverTau.Utilities.CSGeometry.Subtractive(GameObject targetObject, GameObject[] objects);
  }
}

Intersect:

public class CustomCSG : MonoBehaviour
{
  // A function that intersect objects.
  public void Intersect()
  {
    SilverTau.Utilities.CSGeometry.Intersect(GameObject targetObject, GameObject[] objects);
  }
}

DeIntersect:

public class CustomCSG : MonoBehaviour
{
  // A function that deintersect objects.
  public void DeIntersect()
  {
    SilverTau.Utilities.CSGeometry.DeIntersect(GameObject targetObject, GameObject[] objects);
  }
}

Screenshot

Your app can take a screenshot in real time. The result is an image that is the same size as view, with view and its subviews drawn into it.

Take a screenshot:

public class CustomScreenshot : MonoBehaviour
{
  // A function that takes a screenshot with certain parameters.
  public void TakeScreenshot()
  {
    Screenshot.TakeScreenshot(true, true);
  }
}

Share your screenshot:

When you use the share screenshot function, the target screenshot will be the last one you took.

public class CustomScreenshotShare : MonoBehaviour
{
  // The function that performs the action shares the last screenshot taken.
  public void ScreenshotShare()
  {
    Screenshot.ScreenshotShare();
  }
}

Screen recording

Your app can record the audio and video inside of the app, along with user commentary through the microphone. You get a reference to the recorder through the shared() function and use it to implement start-and-stop recording functionality. You can present a user interface (view controller) where a user can trim and preview recordings, and share them with other users.

Take a video of the screen:

public class CustomScreenRecorder : MonoBehaviour
{
  // A function that starts recording the screen with certain parameters.
  public void StartScreenRecorder()
  {
    ScreenRecorder.StartScreenRecorder(true, true);
  }

  // A function that stops screen recording.
  public void StopScreenRecorder()
  {
    ScreenRecorder.StopScreenRecorder();
  }
}

Share

Your app can share any files and folders. Share utility is a simple way to share content from one app to another, even from different developers.

Share a folder & file:

public class CustomShare : MonoBehaviour
{
  // A function that allows you to share a folder.
  public void ShareFolder()
  {
    Share.ShareFolder(string directoryPath);
  }

  // A function that allows you to share a file.
  public void ShareFile()
  {
    Share.ShareFile(string usdzPath);
  }
}

OBJ utility

Using the utilities developed and built into the plugin, you can easily import Unity models into both the Runtime and Editor.

Import:

public class CustomOBJ : MonoBehaviour
{
  // Import an OBJ file from a file path. This function will also attempt to load the MTL defined in the OBJ file.
  public void Import(string path, Shader shader)
  {
    var importObject = OBJUtility.Import(path, shader);
  }

  // Import an OBJ and MTL file from a file path.
  public void Import(string path, string mtlPath, Shader shader)
  {
    var importObject = OBJUtility.Import(path, mtlPath, shader);
  }

  // Import an OBJ file from a stream. No materials will be loaded, and will instead be supplemented by a blank white material.
  public void Import(Stream input, Shader shader)
  {
    var importObject = OBJUtility.Import(input, shader);
  }

  // Import an OBJ and MTL file from a stream.
  public void Import(Stream input, Stream mtlInput Shader shader)
  {
    var importObject = OBJUtility.Import(input, mtlInput, shader);
  }
}

Export:

public class CustomOBJ : MonoBehaviour
{
  // Export game object to OBJ format model.
  public void Export(GameObject exportObject, string path, string modelName)
  {
    if(string.IsNullOrEmpty(path)) return;

	if (!Directory.Exists(path))
	{
		Directory.CreateDirectory(path);
	}

	path = Path.Combine(path, modelName + ".obj");
	OBJUtility.Export(path, exportObject.transform);
  }
}

USDZ utility

Using the utility, you can easily export 3D Unity Game Objects and convert .OBJ models to .USDZ models.

Export GameObject to .USDZ:

public class ExportUSDZ : MonoBehaviour
{
    [SerializeField]
    [Tooltip("Target GameObject.")]
    private GameObject targetGameObject;
        
    [SerializeField]
    [Tooltip("The name of the model file.")]
    private string outputUSDZFilename = "result_model";
        
    [Tooltip("Target material settings for the model to be imported.")]
    [SerializeField] private MTLSettings mTLSettings;
		
    private string _outputPath;

    private void Start()
    {
       _outputPath = Path.Combine(Application.persistentDataPath);
    }

    // The function allows you to export any 3D GameObject to the .USDZ model format.
    private void ExportGameObjectToUSDZ()
    {
        USDZUtility.ExportObjectToUSDZ(targetGameObject, _outputPath, outputUSDZFilename, mTLSettings);
    }
}

Convert .OBJ to .USDZ:

public class ConvertOBJ : MonoBehaviour
{
    [SerializeField]
    [Tooltip("The name of the model file.")]
    private string outputUSDZFilename = "result_model";

    [SerializeField] 
    [Tooltip("Path to the .OBJ model file. For the test, we use the streamingAssetsPath. If you plan to change the path, do not forget to make changes to the code.")]
    private string inputOBJFilePath = "USDZUtility/model/silvertau_logo.obj";
    
    private string _outputPath;

    private void Start()
    {
       _outputPath = Path.Combine(Application.persistentDataPath);
    }

    // The function allows you to convert any .OBJ model file to the .USDZ model format.
    private void ConvertOBJToUSDZModel()
    {
        var pathObj = Path.Combine(Application.streamingAssetsPath, inputOBJFilePath);
            
        if (!File.Exists(pathObj))
        {
            return;
        }
            
        USDZUtility.ConvertOBJToUSDZ(pathObj, _outputPath, outputUSDZFilename);
    }
}

RPU Inspector

RoomPlan for Unity Kit Inspector is a utility that helps you manage and analyze data from scanned objects.

Use the shortcut menu to open the RPU Inspector:

Window > Silver Tau > RoomPlan for Unity Kit > RPU Inspector

Examples of use:

RoomBulder:

public class CustomRoomBuilder : MonoBehaviour
{
	// Create a new RoomBulder and add it to the RPU inspector.
  public void NewRoomBuilder()
  {
    // Create a new RoomBulder.
    var roomBuilder = new RoomBuilder 
    {
       container = targetContainer,
       prefabRoomPlanObject = targetPrefab
    }

    // The RoomBuilder object is added to the inspector's RPU.
#if UNITY_EDITOR
    RPUInspector.AddRoomBulder(roomBuilder);
#endif

  }
}

What's new

Version [1.6.2]

Added

• Streaming video from camera feature;
• Scene (example) of using streaming video from a camera;

Updated

• RoomPlanUnityKit framework;
• RoomPlanUnity lib;
• Optimization;
• Documentation;

Fixed

• Minor bugs;

Upgrade guide

Starting from version 1.3.3, the Screenshot and Screen Recorder functions were separated and moved. Now you can use these utilities independently of the main framework. For more information, see the Utilities section.

Changelog

## [1.6.2]
### Added:
- Streaming video from camera feature;
- Scene (example) of using streaming video from a camera;

### Updated
- RoomPlanUnityKit framework;
- RoomPlanUnity lib;
- Optimization;
- Documentation;

### Fixed
- Minor bugs;

## [1.6.1]
### Updated
- RoomPlan for Unity Kit Inspector;
- RoomPlanUnityKit framework;
- Optimization;
- Documentation;

### Fixed
- Minor bugs;

## [1.6.0]
### Added:
- ARWorldMap (The state in a world-tracking AR session during which a device maps the user’s position in physical space and proximity to anchor objects.);
- Added an example of changing textures and materials for Indoor Models Settings;

### Updated
- RoomPlanUnityKit framework;
- RoomPlanUnity lib;
- Room Builder;
- Object visualization;
- Indoor Models Settings;
- Captured Snapshot;
- Process optimization;
- Documentation;

### Fixed
- Minor bugs;

## [1.5.2]
### Updated
- RoomPlanUnityKit framework;
- RoomPlanUnity lib;
- Floor & Ceiling generation;
- UV map generation;
- Triangulation module;
- Room Builder;
- Captured Snapshot;
- Process optimization;
- Documentation;

### Fixed
- Minor bugs;

## [1.5.1]
### Updated
- RoomPlanUnityKit framework;
- RoomPlanUnity lib;
- Initialize functions;
- Deinitialize & Dispose functions;
- Memory usage;
- USDZ Utility;
- Share Utility;
- QuickLook utility;
- An example of the USDZ utility;
- An example of the Share utility;
- An example of the QuickLook utility;

### Fixed
- Minor bugs;

## [1.5.0]
### Added:
- Captured Object Attributes;

### Updated
- RoomPlan for Unity Kit Inspector;
- RoomPlanUnityKit framework;
- RoomPlanUnity lib;
- RoomPlan Object;
- Captured Room;
- Room Builder;
- Captured Snapshot;
- Documentation;
- Examples;

### Fixed
- Minor bugs;

## [1.4.4]
### Added:
- Support for landscape mode for RPU;

### Updated
- Initialize and dispose functions;
- RoomPlanUnityKit framework;
- Captured Room Session;
- RoomPlanUnity lib;
- Documentation;
- Examples;

### Fixed
- Minor bugs;

## [1.4.3]
### Added:
- Error handling for Capture & Room Sessions;
- New examples of prefabs for scanned objects;
- New examples of materials and shaders for scanned objects;

### Updated
- RoomPlanUnityKit framework;
- Captured Room Session;
- RoomPlanUnity lib;
- Documentation;
- OBJ Utility;
- Examples;

### Fixed
- Minor bugs;

## [1.4.2]
### Updated
- USDZ Utility;
- OBJ Utility;
- RoomPlan for Unity Kit Inspector;
- RoomPlanUnityKit framework;
- RoomPlanUnity lib;
- Examples;

### Fixed
- Minor bugs;

## [1.4.1]
### Added:
- Recognition of the ceiling in AR mode;
- Ceiling recognition for RoomBuilder;
- Ceiling builder settings;

### Updated
- RoomPlan for Unity Kit Inspector;
- RoomPlanUnityKit framework;
- RoomPlanUnity lib;
- Room Builder;
- XR solution for ARFoundation;
- Process optimization;
- Examples;

### Fixed
- Minor bugs;
- XR bugs;

## [1.4.0]
### Added:
- USDZ Utility;
- USDZ Utility example scene;

### Updated
- RoomPlan for Unity Kit Inspector;
- RoomPlanUnityKit framework;
- RoomPlanUnity lib;
- Room Builder;
- OBJ Utility;
- OBJ Utility example scene;
- Examples;
- Documentation;

### Fixed
- Minor bugs;

## [1.3.8]
### Added:
- "Custom Miniature Model" example scene;

### Updated
- RoomPlan for Unity Kit Inspector;
- RoomPlanUnityKit framework;
- RoomPlanUnity lib;
- Room Builder;
- Captured Room Snapshot;
- Examples;

### Fixed
- Minor bugs;

## [1.3.7]
### Added:
- RoomPlan for Unity Kit Inspector;

### Updated
- RoomPlan for Unity Kit Settings;
- RoomPlanUnityKit framework;
- RoomPlanUnityKit (XR);
- RoomPlanUnity lib;
- Room Builder;
- CapturedRoom - Section;
- Captured Room Snapshot;
- Examples;
- Documentation;

### Fixed
- Minor bugs;

## [1.3.6]
### Added
- Floor builder settings;
- "Floor Settings" example scene;

### Updated
- RoomPlan for Unity Kit Settings;
- RoomPlanUnityKit framework;
- RoomPlanUnity lib;
- Room Builder;
- Captured Room Snapshot;
- Examples;
- Documentation;

### Fixed
- Minor bugs;

## [1.3.5]
### Added
- OBJ Utility;
- OBJ Utility example scene;

### Updated
- Process optimization;
- RoomPlanUnity lib;
- 3D view controller;
- Examples;
- Documentation;

### Fixed
- Xcode build ".mm" bug;
- Minor bugs;

## [1.3.4]
### Updated
- Process optimization;
- RoomPlanUnity lib;
- RoomPlanUnityKit framework;
- CSGeometry utility;
- QuickLook utility;
- Share utility;

### Fixed
- Minor bugs;

## [1.3.3]
### Added
- CSGeometry utility;
- QuickLook utility;
- Screen Recorder utility;
- Screenshot utility;
- Share utility;

### Updated
- RoomPlanUnityKit framework;
- RoomPlanUnity lib;
- Process optimization;
- Documentation;

### Fixed
- Minor bugs;

## [1.3.2]
### Added
- RPU - instant initialization of the framework;
- RPU validate function;

### Updated
- RoomPlanUnityKit framework;
- Process optimization;
- Reduced initialization time;
- Documentation;

### Fixed
- Minor bugs;

## [1.3.1]
### Added
- RPU XR - instant initialization of the framework;
- RPU quick options menu;

### Updated
- RoomPlanUnityKit framework;
- RoomPlanUnity lib;
- XR Session;
- XR Session Service;
- XR Loader;
- Process optimization;
- Documentation;

### Fixed
- Minor bugs;

## [1.3.0]
### Added
- AR Foundation support;
- RPU XR example scene;

### Updated
- RoomPlan for Unity Kit Settings;
- RoomPlanUnityKit framework;
- RoomPlanUnity lib;
- Room Builder;
- Captured Room Snapshot;
- Session Camera;
- Examples;
- Build Process;
- Process optimization;
- RoomPlanUnityKit provider;
- Documentation;

### Fixed
- Minor bugs;

## [1.2.1]
### Added
- Constructive solid geometry for RoomBuilder;
- USD export settings;
- CSGeometry example scene;

### Updated
- RoomPlan for Unity Kit Settings;
- Room Builder;
- RoomPlanUnityKit framework;
- RoomPlanUnity lib;
- Captured Room Data;
- Documentation;

### Fixed
- Minor bugs;

## [1.2.0]
### Added
- MultiRoom support;
- Merging multiple scans;
- Structure Builder;
- Captured Structure;
- Exporting a captured room to usdz with models;
- Additional functions for captured room;
- MultiRoom example scene;
- Merging example scene;

### Updated
- Captured Room;
- Captured Room Data;
- Captured Room Snapshot;
- RoomPlan for Unity Kit Settings;
- Structure;
- Floor creator;
- Build Process;
- Room Builder;
- RoomPlanUnityKit framework;
- RoomPlanUnity lib;
- Documentation;

### Fixed
- Minor bugs;

## [1.1.6]
### Added
- EventSystem Extensions;

### Updated
- EventSystem Extensions;
- RoomPlanUnity lib;
- RoomPlanUnityKit framework;

### Fixed
- Minor bugs;

## [1.1.5]
### Added
- Example of data transfer rate;

### Updated
- Changing the structure of some project elements;
- Examples of prefabs;
- Floor creator;
- RoomPlanUnity lib;
- RoomPlanUnityKit framework;

### Fixed
- Minor bugs;

## [1.1.4]
### Added
- Setting the data transfer rate for a RoomPlan Captured snapshot;
- An example of visualizing a model in a room;

### Updated
- RoomPlanUnity lib;
- RoomPlanUnityKit framework;
- Build Process;
- Floor creator (AR & RoomBuilder);
- Request default permission settings;
- Documentation;

### Fixed
- Minor bugs;

## [1.1.3]
### Added
- Flashlight feature;
- Automatic flashlight in AR feature;
- An example of a user session instruction function;
- An example of a flashlight function;

### Updated
- RoomPlanUnityKit framework;
- AR samples;
- RPU Session Instruction;
- Documentation;

### Fixed
- Minor bugs;

## [1.1.2]
### Added
- Captured Room Object Visualizer;
- Data Transfer parameter;
- Sample data transfer by default scan;

### Updated
- Session camera;
- Speed of data exchange;
- RoomPlanUnity lib;
- RoomPlanUnityKit framework;
- AR samples;
- Documentation;

### Fixed
- RSCaptureSession error (RSError: kRSError_Runtime_DriftDetection: 4);
- Minor bugs;

## [1.1.1]
### Added
- Pause/Resume RoomPlan Capture Session scanning;
- [Try] additional functions;

### Updated
- RoomPlanUnity lib;
- RoomPlanUnityKit framework;
- AR samples;

### Fixed
- Bitcode error (Xcode setting ENABLE_BITCODE);
- Minor errors;

## [1.1.0]
### Added
- Floor creator (AR & RoomBuilder);
- Shadow receiver shader (AR & RoomBuilder);
- Raycast plan (AR);
- Mesh surface creator;
- Triangulation functions;
- Place the object in the AR sample;
 
### Updated
- Session Camera;
- Room Builder;
- RoomPlan captured snapshot;
- RoomPlan for Unity Kit settings;
- RoomPlan for Unity Kit samples;
- RoomPlanUnity lib;
- RoomPlanUnityKit framework;
  
### Fixed
- Camera operation;
- Utilization operations;
- Minor errors in the examples;

## [1.0.0]
### Added
- First release

Issues

Issues are used to track errors, bugs, etc.