Required packages

The Object Capture 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.

Features

Creating a 3D model:

The Object Capture for Unity Kit allows you to create a 3D model of any scanned object (area) using device sensors, trained machine learning models, and Unity's rendering capabilities.

Photogrammetry:

Create 3D objects from a series of photos, either your own or taken in the app, using photogrammetry. (Photogrammetry for iOS and macOS platforms)

High-Speed:

Engineered and extensively optimized for superior performance.

Quality:

Take high-quality images of objects to generate 3D models.

Displaying AR tips:

During the scan, users receive virtual on-screen prompts that indicate the direction and progress of the scan.

Export 3D model:

After scanning an object, you can export a 3D model in various 3D formats (.obj, .ply, .usda, .usdc, .usdz).

Flashlight utility:

With this utility, you can control the device's flashlight anytime.

Quick Look utility:

You can use Quick Look in your app so that users can see incredibly detailed visualizations of objects in the real world quickly and easily.

Share utility:

With this utility, you can easily share any files and folders.

Import/Export 3D model (.obj):

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

USDZ Utility:

Easily convert and export any GameObjects (3D) to a .USDZ model file and use them in your applications, preview them with the QuickLook utility, or share them with the Share utility.

Lightweight Integration:

The API is purposefully designed to minimize unnecessary additions or extra burden on your project.

Components:

Platform support

The Object Capture 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/iPadOS version:

• OS 17+
• LiDAR Scanner
• A14 Bionic chip or later

macOS version:

• macOS 15+

Limitations

Devices:

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

Samples

Samples.

Object Capture for Unity Kit (Default):

Object Capture for Unity Kit (macOS):

Utilities:

Install Object Capture for Unity Kit

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

Scene setup

Each AR scene in your app must have two mandatory GameObjects: Object Capture for Unity Kit, Object Capture Session, or Photogrammetry Session.

The GameObject Object Capture for Unity Kit enables and controls AR on the target platform, the Object Capture Session interacts with the framework and builds scanned 3D objects in real time, and the GameObject Photogrammetry Session reconstructs the scanned object from photos. If one of these GameObjects is missing from the scene, augmented reality will not work properly.

To create an Object Capture for Unity Kit, Object Capture Session, or Photogrammetry Session, right-click in the Hierarchy window and choose one of the following options from the shortcut menu.

Silver Tau > Object Capture for Unity Kit > Object Capture for Unity Kit

or

Window > Silver Tau > Object Capture for Unity Kit > Prepare and check the plugin

After adding the Object Capture for Unity Kit (Asset) 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 Object Capture for Unity Kit, Object Capture Session or Photogrammetry Session 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.

Object Capture for Unity Kit

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

Take high-quality images of objects to generate 3D models.

In iOS 17 and later you can create 3D objects from photographs using a process called photogrammetry. You provide Object Capture with a series of well-lit photographs taken from many different angles. It analyzes the overlap area between different images to match up landmarks, and then produces a 3D model of the photographed object.

To generate the best 3D representation from the object-creation process, provide with high-quality, high-resolution photographs that don’t contain hard shadows or strong highlights.

Select an object to photograph

Choose objects that are static and won’t bend or deform while you’re taking photos. You can move the object between shots in order to photograph all sides, but a soft, articulated, or bendable object that changes shape when you move it can compromise framework ability to match landmarks between different images, which may cause Object Capture to fail or produce low-quality results.

Avoid objects that are very thin in one dimension, highly reflective, transparent, or translucent. Additionally, objects that are a single, solid color or have a very smooth surface may not provide enough data necessary for the object-creation algorithm to construct a 3D shape.

Choose an approach

You can approach taking photographs for object creation in two ways: Either move the camera around the object, taking photographs from different angles at different heights, or put the object on a turntable and rotate the object while taking pictures. When using a turntable, take pictures in front of a well-lit, solid color background to minimize extraneous image data that can interfere with the object-creation process and use a tripod if available. Standing the object on different sides while photographing it on a turntable captures the entire object with no gaps or holes.

The number of pictures that RealityKit needs in order to create an accurate 3D representation varies depending on the complexity and size of the object, but adjacent shots must have substantial overlap. Position sequential images so they have a 70% overlap or more. Anything less than 50% overlap between neighboring shots, and the object-creation process may fail or result in a low-quality recreation.

Compose your shots

Position the object so it fills as much of the camera’s frame as possible without excluding or cutting off any part. Use an aperture setting narrow enough to maintain a crisp focus. Shoot at the highest resolution your camera supports and use RAW format if possible.

In low-light situations, cameras with autofocus can have difficulty finding and maintaining focus. Focus manually if there isn’t enough ambient light to get a focus lock, and put your camera on a tripod to make sure you keep it steady. Use a remote trigger, such as the Apple Watch Camera Remote app, to make sure the camera doesn’t move or shake when you press the button to take a photo.

Use diffused lighting if possible. Hard light, such as from an on-camera flash, direct sunlight, or a bare light bulb can cause problems during object creation. This type of lighting casts hard shadows that can confuse the photogrammetry algorithm. Instead, bounce the light off of a reflector, a wall, or the ceiling, or put a diffusing material like a lamp shade or thin white fabric between the light source and the object. You can also use light modifiers or a light tent designed for photographing objects.

When photographing an object outdoors, keep the sun out of your images if possible. Shoot at midday so the sun is high enough in the sky that it won’t be visible in any of your images, or shoot on an overcast day.

Capture consistent images and perform post-processing

In order to ensure that RealityKit can match up landmarks between overlapping photographs, keep your camera settings as consistent as possible from shot to shot. If possible, don’t make changes to any camera settings while shooting, including the focal length (zoom), aperture, shutter speed, or ISO.

If your camera offers manual control of any settings, set those values to keep them consistent between shots. When shooting with the camera on an iPhone or iPad, you can lock the exposure and focus settings by long-pressing the image feed view until you see “AE/AF Lock” appear at the top of the screen.

In addition, masking out objects in the background so the image only contains the object you’re capturing removes unnecessary data that can confuse the photogrammetry algorithm.

There may be times when you can’t capture images under ideal conditions, such as when photographing a large object in a crowded public space. Adjust for image shortcomings using an image editor. Modify a photograph’s contrast, brightness, sharpness, or exposure to compensate for problems in the original capture.

Actions

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

Examples of use:

Initialize/Dispose framework (Manual):

//A function that initializes a framework.
//Use it if the framework has not been initialized before.
ObjectCaptureForUnityKit.Initialize();
//A function that disposes of a framework.
//Use it if you want to unload the framework.
ObjectCaptureForUnityKit.Dispose();

Update Object Capture for Unity Kit Settings:

//A method that updates the main Object Capture settings in real time.
//By updating Object Capture Unity Kit Settings, all settings will be applied.
ObjectCaptureForUnityKit.UpdateSettingsObject();

Is it supported:

//By updating Object Capture Unity Kit Settings, all settings will be applied.
ObjectCaptureForUnityKit.IsSupported();

Object Capture Session

A session object that monitors and controls image capture for photogrammetry.

An ObjectCaptureSession is used together with an ObjectCaptureView to present a view that assists in capturing images of an object for reconstruction of a 3D model by using a PhotogrammetrySession.

A capture session contains functions for starting and advancing the capture session through a state machine that controls the image capture process. Your app can also observe several properties of the capture session to determine the current state of the capture process.

Once a session enters the .completed state, your app can transfer the images to a Mac or use them locally on the iOS device for use in object reconstruction using PhotogrammetrySession. Model reconstruction is a separate phase which this session does not directly monitor or control.

Events

Properties

Functions

Examples of use:

Start scanning:

public class ObjectCapture : MonoBehaviour
{
  // Begins taking images for object capture.
  public void StartCapturing()
  {
    ObjectCaptureSession.StartCapturing();
  }
}

Start detecting:

public class ObjectCapture : MonoBehaviour
{
  // Requests that the session should start detecting the object in the center of the camera.
  public void StartDetecting()
  {
    ObjectCaptureSession.StartDetecting();
  }
}

Reset detecting:

public class ObjectCapture : MonoBehaviour
{
  // Reset detection.
  public void ResetDetection()
  {
    ObjectCaptureSession.ResetDetection();
  }
}

Change the size of the detected object:

public class ObjectCapture : MonoBehaviour
{
  // A method that allows you to change the size and rotation of the found object.
  public void ChangeDetectObjectSize(bool value)
  {
    ObjectCaptureSession.ChangeDetectObjectSize(value);
  }
}

Pause capture session:

public class ObjectCapture : MonoBehaviour
{
  // Pauses the automatic capture and other resource-intense algorithms.
  public void PauseCaptureSession()
  {
    ObjectCaptureSession.PauseCaptureSession();
  }
}

Resume capture session:

public class ObjectCapture : MonoBehaviour
{
  // Resumes object tracking algorithms after ``ObjectCaptureSession.PauseCaptureSession()`` is called.
  public void ResumeCaptureSession()
  {
    ObjectCaptureSession.ResumeCaptureSession();
  }
}

Manual image capture:

public class ObjectCapture : MonoBehaviour
{
  // Manual image capture.
  public void ManualImageCapture()
  {
    ObjectCaptureSession.ManualImageCapture();
  }
}

Finish Capture Session:

public class ObjectCapture : MonoBehaviour
{
  // A function that completes the scanning process with further reconstruction actions.
  public void FinishCaptureSession()
  {
    ObjectCaptureSession.FinishCaptureSession();
  }
}

New scan pass:

public class ObjectCapture : MonoBehaviour
{
  private bool _isObjectFlipped;
  private bool _isCantFlipObject;

  // A function that starts a new scanning phase.
  public void StartNewScanPass()
  {
    if (_isObjectFlipped && !_isCantFlipObject)
    {
        ObjectCaptureSession.BeginNewScanPassAfterFlip();
    }
    else
    {
        ObjectCaptureSession.BeginNewScanPass();
    }
  }
}

Start Object Capture Session:

public class ObjectCapture : MonoBehaviour
{
  // Starts the session with the provided output image directory and optional checkpoint directory.
  public void StartObjectCaptureSession()
  {
    ObjectCaptureSession.StartObjectCaptureSession();
  }
}

Stop Object Capture Session:

public class ObjectCapture : MonoBehaviour
{
  // Requests to stop the capture session and stop all data.
  public void StopObjectCaptureSession()
  {
    ObjectCaptureSession.StopObjectCaptureSession();
  }
}

Update settings:

public class ObjectCapture : MonoBehaviour
{
  // The method that updates the settings. Before using the feature, change the settings in the Object Capture for Unity Kit Settings.
  public void UpdateSettings()
  {
    ObjectCaptureSession.UpdateSettings();
  }
}

Change capture mode:

public class ObjectCapture : MonoBehaviour
{
  // Setting the target capture mode.
  public void ChangeCaptureMode(CaptureMode captureMode)
  {
    ObjectCaptureSession.SetCaptureMode(captureMode);
  }
}

Hide/Show Point Cloud when capturing:

public class ObjectCapture : MonoBehaviour
{
  // A func that specifies whether the visualization Point Cloud is hidden when scanning objects with default settings.
  public void HideShowPointCloudWhenCapturing(bool isHidden)
  {
    ObjectCaptureSession.HidePointCloudMTKViewWhenCapturing(isHidden);
  }
}

Photogrammetry Session

Manages the creation of a 3D model from a set of images.

In iOS 17 and later to create a 3D object from a series of photographs, submit the images to Kit using a PhotogrammetrySession, register to receive status updates, and start the session. The completed process produces a 3D representation of the photographed object that you can use in your app or export to other software like Reality Composer, 3D Editors and etc.

Events

Functions

Examples of use:

Start Photogrammetry Session:

public class ObjectCapture : MonoBehaviour
{
  // Start a photogrammetry session.
  public void StartPhotogrammetrySession()
  {
    // You can set your own paths to folders.
    var currentSnapshotsFolder = ObjectCaptureSession.CurrentSnapshotsFolder;
    var currentImagesFolder = ObjectCaptureSession.CurrentImagesFolder;
    var currentModelsFolder = ObjectCaptureSession.CurrentModelsFolder;

    PhotogrammetrySession.StartPhotogrammetrySession(currentSnapshotsFolder, currentImagesFolder, currentModelsFolder);
  }
}

Stop Photogrammetry Session:

public class ObjectCapture : MonoBehaviour
{
  // Stop a photogrammetry session. Requests cancellation of any running requests.
  public void StopPhotogrammetrySession()
  {
    PhotogrammetrySession.StopPhotogrammetrySession();
  }
}

Update settings:

public class ObjectCapture : MonoBehaviour
{
  // The method that updates the settings. Before using the feature, change the settings in the Object Capture for Unity Kit Settings.
  public void UpdateSettings()
  {
    PhotogrammetrySession.UpdateSettings();
  }
}

Camera Capture Image Session

Capture high-quality images with depth and gravity data to use with RealityKit Object Capture.

This module is a camera tool that enables the capture of high-quality images along with depth and gravity data. It allows for the creation of more realistic and accurate three-dimensional objects by not only capturing visual information about the object but also gathering data about its surroundings and physical characteristics. This contributes to a more comprehensive reproduction of objects in virtual space, significantly enhancing the realism and immersion of the scenes being created.

The main features of the module include:

• High-quality image capture: The module provides the ability to capture high-resolution images, which allows you to preserve the detail and realism of objects.
• Depth data collection: In addition to conventional images, the module also collects depth information about objects, allowing for more accurate rendering in three dimensions.
• Gravity data collection: Gravity data can be important for creating animations or effects related to the physical interaction of objects in the virtual world.
• Compatibility with RealityKit Object Capture: Captured data can be easily integrated with RealityKit Object Capture technology, allowing you to quickly and efficiently create 3D objects with a high degree of realism.

This module is a powerful tool for developers and artists working in the field of augmented and virtual reality, providing them with the ability to create better and more immersive visual effects and scenes.

Events

Functions

Static functions

Properties

Examples of use:

Start Session:

public class CameraCapture : MonoBehaviour
{

  [SerializeField] private CameraCaptureImageSession cameraCaptureImageSession;

  // Object initialization function.
  public void StartPhotogrammetrySession()
  {
    // You can set your own paths to folders.
    cameraCaptureImageSession.SetCustomCapturePath(customCapturePath);
    cameraCaptureImageSession.StartSession();
  }
}

Stop Session:

public class CameraCapture : MonoBehaviour
{
  [SerializeField] private CameraCaptureImageSession cameraCaptureImageSession;

  // Stop a Capture Image session. Requests cancellation of any running requests.
  public void StopPhotogrammetrySession()
  {
    cameraCaptureImageSession.StopSession();
  }
}

On Image Created (Event):

public class CameraCapture : MonoBehaviour
{
  private void OnEnable()
  {
    CameraCaptureImageSession.OnImageCreated += CameraCaptureImageSessionOnOnImageCreated;
  }

  private void OnDisable()
  {
    CameraCaptureImageSession.OnImageCreated -= CameraCaptureImageSessionOnOnImageCreated;
  }
  
  // Function - an event that is called when a picture (photo) is created.
  // heicPath - Output path to a HEIC image (photo).
  private void CameraCaptureImageSessionOnOnImageCreated(string heicPath)
  {
    Debug.Log(heicPath)
  }
}

Change Capture Video Size:

public class CameraCapture : MonoBehaviour
{
  // A feature that allows you to specify the size of the camera viewer relative to your screen.
  private void OnChangeCaptureVideoSize(CaptureVideoSize type)
  {
    CameraCaptureImageSession.SetCaptureVideoSize(type);
  }
}

Change Capture Device Type:

public class CameraCapture : MonoBehaviour
{
  // A function that allows you to specify the type of camera to be used.
  private void OnChangeCaptureDeviceType(CaptureDeviceType type)
  {
    CameraCaptureImageSession.SetCaptureDeviceType(type);
  }
}

Create Image:

public class CameraCapture : MonoBehaviour
{
  // A function that performs the action of creating an image (photo).
  private void CreateImage()
  {
    CameraCaptureImageSession.CreateImage();
  }
}

Get Session Info:

public class CameraCapture : MonoBehaviour
{
  // A function that provides information about the current session.
  // This will help you understand whether your current camera settings support the functionality you need.
  private void SessionInfo()
  {
    var highQualityInfo = cameraCaptureImageSession.IsHighQualityMode();
    var gravityInfo = cameraCaptureImageSession.IsMotionDataEnabled();
    var depthInfo = cameraCaptureImageSession.IsDepthDataEnabled();
  }
}

Object Capture for Unity Kit Settings

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

Properties

Reconstruction Output

The ReconstructionOutput class is responsible for processing and managing the output data generated from 3D reconstruction processes. It provides an organized structure and methods to handle various types of reconstruction data, making it easier to integrate, visualize, and interact with in applications. This class acts as a bridge between raw reconstruction outputs and their practical usage in features such as 3D visualization, data analysis, or AR experiences.

Features:

1. Point Cloud Processing:

• Handles the 3D point cloud data, which represents the geometry of the scanned object or environment.
• Each point in the point cloud contains spatial position data and optional color information.
• Facilitates visualization and analysis of spatial geometry.

2. Pose Management:

• Processes pose data, which includes translations and rotations.
• Pose data helps in understanding the spatial alignment and movement of the reconstructed model or individual snapshots.
• Enables dynamic visualization of poses with smooth transitions.

3. Bounding Box Handling:

• Extracts and manages bounding box information, which defines the spatial limits of the reconstructed object.
• Useful for defining the object's extents and integrating with features like collision detection or scene scaling.

Use Cases:

• Visualization: This class is instrumental in visualizing reconstruction data, such as rendering point clouds, showing object poses, or displaying bounding boxes in 3D space.
• Integration: Simplifies the process of integrating reconstruction data into experiences by organizing and standardizing the data.

Properties

Examples of use:

Get the output reconstruction data:

public void Run(string snapshotsFolderPath)
{
  var reconstructionOutput = new ReconstructionOutput(snapshotsFolderPath);
  
  var pointCloudData = reconstructionOutput.PointCloud;
  
  if (pointCloudData != null)
  {
    Debug.Log($"PointCloud received with {pointCloudData.Points.Count} items.");
  }
  
  var posesData = reconstructionOutput.Poses;
  
  if (posesData != null)
  {
    Debug.Log($"Poses received with {posesData.PosesBySample.Count} items.");
  }
  
  var boundingBoxData = reconstructionOutput.BoundingBox;
  
  if (boundingBoxData != null)
  {
    Debug.Log($"BoundingBoxData is received.");
  }
}

Photogrammetry Session (macOS)

Manages the creation of a 3D model from a set of images.

In macOS 15 and later to create a 3D object from a series of photographs, submit the images to Kit using a PhotogrammetrySession, register to receive status updates, and start the session. The completed process produces a 3D representation of the photographed object that you can use in your app or export to other software like Reality Composer, 3D Editors and etc.

Events

Functions

Examples of use:

Start Photogrammetry Session:

public class CustomScript : MonoBehaviour
{
  // Start a photogrammetry session.
  public void StartPhotogrammetrySession(string imageFolderPath, string modelName, string modelFolderPath)
  {
    if (!Directory.Exists(imageFolderPath))
    {
        Debug.Log("Error: Directory is null!");
        return;
    }
            
    if (!Directory.Exists(modelFolderPath))
    {
        Debug.Log("Error: Directory is null!");
        return;
    }
            
    if (string.IsNullOrEmpty(modelName))
    {
        Debug.Log("Error: Model Name is empty!");
        return;
    }
            
    PhotogrammetryMacOSSession.StartPhotogrammetrySession(imageFolderPath, modelName, modelFolderPath);
  }
}

Stop Photogrammetry Session:

public class CustomScript : MonoBehaviour
{
  // Stop a photogrammetry session. Requests cancellation of any running requests.
  public void StopPhotogrammetrySession()
  {
    PhotogrammetryMacOSSession.StopPhotogrammetrySession();
  }
}

Update settings:

public class CustomScript : MonoBehaviour
{
  // The method that updates the settings.
  public void UpdateSettings()
  {
    PhotogrammetryMacOSSession.UpdateSettings();
  }
}

Photogrammetry Settings (macOS)

This is a script object that has characteristics for customizing Photogrammetry MacOS (Object Capture) for Unity Engine. Here you can customize the availability of main functions for your case and needs.

Properties

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);

Examples of use:

Quick Look:

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

Flashlight

This is an assistant utility that is responsible for the operation of the device's flashlight.

Examples of use:

Flashlight:

public class CustomFlashlight : MonoBehaviour
{
  // A function that allows you to control the device's flashlight.
  public void SetFlashlightStatus(bool value)
  {
    Flashlight.SetFlashlightStatus(value);
  }
}

OBJ Utility

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

MTL Settings:

MTL Settings is responsible for synchronizing the parameters of the target shader (color, main texture, normal map, etc.) with the parameters that will be used to read/write the model settings when importing or exporting it.

Below is a table with a list of parameters and their descriptions.

Examples of use:

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, MTLSettings mtlSettings = null)
  {
    var importObject = OBJUtility.Import(path, shader, mtlSettings);
  }

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

  // 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, MTLSettings mtlSettings = null)
  {
    var importObject = OBJUtility.Import(input, shader, mtlSettings);
  }

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

Export:

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

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

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

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.

Examples of use:

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 path);
  }
}

USDZ Utility

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

Examples of use:

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);
    }
}

What's new

Version [1.6.1]

Added

• dSYM;

Updated

• Object Capture for Unity framework;
• Object Capture for Unity libs;
• Documentation;

Fixed

• Warning about missing dSYM in Xcode;
• Minor bugs;

Upgrade guide

You can easily upgrade to a new version of the package without any problems for your project.

Changelog

## [1.6.1]
### Added
- dSYM;

### Updated
- Object Capture for Unity framework;
- Object Capture for Unity libs;
- Documentation;

### Fixed
- Warning about missing dSYM in Xcode;
- Minor bugs;

## [1.6.0]
### Added
- Photogrammetry support for macOS platform;
- Object Capture for Unity framework (macOS);
- Photogrammetry Settings (macOS);
- Example for Photogrammetry (macOS);

### Updated
- Object Capture for Unity framework;
- Object Capture for Unity libs;
- Object Capture Session;
- Photogrammetry Session;
- Optimization of the ObjectCaptureSession;
- Optimization of Camera Capture Image Session;
- Optimization of the Photogrammetry Session;
- Documentation;

### Fixed
- A bug with the “Done” button when resizing objects in the default scan example;
- Memory leaks;
- Minor bugs;

## [1.5.2]
### Added
- Point Cloud visibility option for default scanning (MTKView in Settings SO);

### Updated
- Object Capture for Unity framework;
- Object Capture for Unity libs;
- Object Capture Session;
- Photogrammetry Session;
- Camera Capture Image Session;
- Object Capture for Unity Kit Settings;
- Optimization of the ObjectCaptureSession;
- Optimization of Camera Capture Image Session;
- Optimization of the Photogrammetry Session;
- Model Viewer;
- Samples;
- Documentation;

### Fixed
- Memory leaks;
- Minor bugs;

## [1.5.1]
### Updated
- Object Capture for Unity framework;
- Object Capture for Unity libs;
- Photogrammetry Session;
- Reconstruction Outputs;
- Output Models;
- Optimization;
- OBJ Utility;
- Samples;

### Fixed
- Centering the position (pivot point) of 3D objects when scanning and reconstructing objects;
- Minor bugs;

## [1.5.0]
### Added
- Reconstruction Outputs;
- Point cloud output and rendering;
- Poses output and visualization;
- Bounding box output and visualization;
- Example for Model Scan Visualization;

### Updated
- Object Capture for Unity framework;
- Object Capture for Unity libs;
- Photogrammetry Session;
- Documentation;
- Samples;

### Fixed
- Minor bugs;

## [1.4.0]
### Added
- iOS 18 Support;
- Capture mode (Object/Area);
- Option to ignore any information about the bounding box;

### Updated
- Object Capture for Unity framework;
- Object Capture for Unity libs;
- Object Capture Session;
- Photogrammetry Session;
- Object Capture Settings;
- Samples;

### Fixed
- Minor bugs;

## [1.3.0]
### Updated
- Object Capture for Unity framework;
- Object Capture for Unity libs;
- Camera Capture Image Session;
- Initialize functions;
- USDZ Utility;
- Share Utility;
- QuickLook utility;
- An example of the USDZ utility;
- An example of the Share utility;
- An example of the QuickLook utility;
- Demo files (StreamingAssets);

### Fixed
- Minor bugs;

## [1.2.3]
### Updated
- Object Capture for Unity framework;
- Initialize and dispose functions;
- Object Capture for Unity libs;
- Object Capture Session;
- Samples;

### Fixed
- Minor bugs;

## [1.2.2]
### Added
- Assist functions for managing the scan size;

### Updated
- Object Capture for Unity framework;
- Auto-rotate the camera session;
- Object Capture for Unity libs;
- Camera Capture Image Session;
- Object Capture Session;
- OBJ Utility;
- Samples;

### Fixed
- Initializing the camera in landscape mode;
- Minor bugs;

## [1.2.1]
### Added
- Camera Capture Image Session;
- Camera landscape mode for CCI Session;

### Updated
- Object Capture for Unity framework;
- Object Capture for Unity libs;
- Object Capture Session;
- Auto-rotate the camera session;
- OBJ Utility;
- USDZ Utility;
- Samples;

### Fixed
- Minor bugs;

## [1.2.0]
### Added
- Camera Capture Image Session;
- High-quality image capture;
- Depth data collection;
- Gravity data collection;
- Camera viewer;
- Ability to select the camera type;
- HEIC image conversion functions (to PNG & JPG);
- Example of interaction and work for the module Camera Capture Image;

### Updated
- Object Capture for Unity framework;
- Object Capture for Unity libs;
- Object Capture Session;
- Object Capture Settings;
- OBJ Utility;
- Samples;

### Fixed
- Minor bugs

## [1.1.0]
### Added
- The new USDZ utility;
- An example of the USDZ utility;
- An example of the OBJ utility;
- An example of the Share utility;
- An example of the QuickLook utility;
- An example of the Flashlight utility;

### Updated
- OBJ Utility;
- Samples;
- New functionality for ObjectCaptureSession;
- Advanced features for Share Utility and OBJ Utility;
- Object Capture for Unity framework;
- Object Capture for Unity libs;

### Fixed
- Minor bugs;

## [1.0.1]
### Added
- MTL Settings for Standard & URP (OBJ Utility);

### Updated
- OBJ Utility;
- Share Utility;
- Samples;
- Plugin validation function;
- Object Capture for Unity framework;
- Object Capture for Unity libs;

### Fixed
- Minor bugs;

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

Issues

Issues are used to track errors, bugs, etc.

dsymutil PathToFramework/ObjectCaptureAPIForUnity.framework/ObjectCaptureAPIForUnity -o PathToOutput/ObjectCaptureAPIForUnity.framework.dSYM