Add Zed Unity Plugin

- import plugin without examples

Assets/ZED.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e3a7cbfea16082643a3d98e3d64a1407
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/Doc.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 02d0a9f454e51e949a8dcdc1559922be
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/Doc/ReleaseNotes.md

@@ -0,0 +1,353 @@
+<!------------------------- Release notes ------------------------------------->
+
+### 3.1.0
+ * **Features:**
+   * Added support for AEC_ACG_ROI video settings (See ZED SDK release notes for more information)
+   * Added support for GAMMA video settings (See ZED SDK release notes for more information)
+   * Added support for compression level in Mat write() function since it has been added in ZED SDK 3.1
+   * Added Texture confidence threshold support in RuntimeParameters/ZED Manager UI since it was added since ZED SDK 3.0
+   * General update to ZED SDK 3.1
+
+
+ * **Compatibility**:
+    * Compatible with ZED SDK 3.0, CUDA 9.0, 10.0 and 10.2 on Windows and Linux
+
+
+### 3.0.1
+  * **Bug Fixes:**
+    * Fixes an issue when saving meshes where default culture is set to use comma notation for decimals (Thanks to @kaszim)
+    * Fixes Black screen with Unity 2019.3 in Forward. Removed RenderPipeline tag not supported anymore.
+    * Fixes texture in spatial mapping not drawn in live.
+    * Added ZEDLayersManager.cs  . This script creates on load all the layers needed by the plugin.
+    * Fixes for 2018 unity version (drawProceduralNow was not existing in previous version). 
+    * Moved MR Calibration app to Tools folder. 
+
+
+### 3.0.0
+  * **Features:**
+    * Added object detection module from ZED SDK 3.0.
+    * Updated with API rework from SDK 3.0.
+    * Added utils function in ZEDCamera.cs to save image, depth and point cloud: *(Those functions are wrapped from ZED SDK C++ functions)*
+         * `ZEDCamera.SaveCurrentImageInFile()`   
+         * `ZEDCamera.SaveCurrentDepthInFile()`
+         * `ZEDCamera.SaveCurrentPointCloudInFile()`      
+    * Update Layer system for rendering and AR planes to a single layer used (layer 30).
+    * Merge Windows and Linux compatibility branches into a single one.
+
+
+  * **Bug Fixes:**
+    * Fixed display issue with spatial mapping (display/hide mesh was not working).
+    * Fixed camera position when SVO is looping back and initial position is estimated. It was previously reset to identity, now it uses the detected position.
+    * Fixed Mesh flip when saved into .obj file.
+
+
+  * **Compatibility**:
+    * Compatible with ZED SDK 3.0, CUDA 9.0, 10.0 and 10.2 on Windows and Linux
+
+### 2.8.3
+  * **Bug Fixes:**
+    * Fix potential compile issue with Oculus SDK
+    * Fix MR headset latency correction when headset does not containes "windows" in their names
+    * Merge PR to fix CreateTrackedObjectPrefab (Thanks to @Abrahamh08)
+
+
+### 2.8.2
+
+  * **Features:**
+    * Added OpenCV ArUco marker detection sample scene. If you've also imported the OpenCV for Unity package from the Asset Store, you can place objects in 3D where ArUco-stlye markers are detected.
+    * Added brand new Mixed Reality calibration app as a sample scene. You can now calibrate the ZED with a tracked object for mixed reality VR capture, all from within the Unity editor.
+
+  * **Improvements:**
+    * Added Max Depth Range and Confidence Threshold options in ZEDManager's Advanced Settings
+    * Added option to disable IMU prior setting in ZEDManager's Advanced Settings
+    * Changed how meshes scanned with the Spatial Mapping feature were saved, to avoid them being flipped on the Z axis when re-imported
+    * Added option to set which side of the ZED (left or right) that ZEDRenderingPlane retrieves. This also solved an issue where the right camera in the ZED_Rig_Stereo prefab would display the left feed when not in AR pass-through mode
+
+  * **Bug Fixes:**
+    * Fixed a crash that would happen if two ZEDManagers were set to use the same Camera ID
+    * Fixed ZED_Rig_Stereo sometimes not outputting an image to the Game window in newer versions of Unity
+    * Fixed ZED_GreenScreen prefab setting that caused the output to be displayed in only half the screen
+    * Fixed depth values being incorrect for occlusion when using OpenGL instead of DirectX
+
+
+### 2.8.1
+
+  * **Improvements:**
+
+    * * Updated ZEDControllerTracker:
+      - Added input support for SteamVR plugin 2.0 and greater
+      - Added ZEDControllerTracker_DemoInputs, which inherits from ZEDControllerTracker, but with generic button/axis check functions
+      - These functions work whether using SteamVR or Oculus Unity plugins
+      -  Several scripts in Example scenes are now simplified to call these functions instead of having plugin-specific code.
+    * Removed limit on how long ZEDManager would attempt to connect to the ZED camera - previously 10 seconds
+    * ZEDTransformController, used to move object like the Planetarium and Movie Screen in example scenes, now takes into account the Reposition At Start feature added to ZEDManager in 2.8
+    * Shader properties that are retrieved or modified more than once per scene now have their property IDs cached, saving lookups
+    * ZEDManager can now be used outside of the included prefabs, and is more flexible when determining if it's in "stereo" mode (like the ZED_Rig_Stereo prefab) for loading AR pass-through features.
+    * ZEDManager's process for closing cameras when the scene closes is now more stable
+
+  * **Bug Fixes:**
+
+    * Fixed ZEDControllerTracker's latency compensation feature moving the controller incorrectly when using ZED in third person
+    * Fixed non-rendering Camera objects not getting properly disposed at scene close, causing performance issues after running scene in editor repeatedly
+    * Camera Brightness adjustment now works in deferred rendering (Global Shader value)
+    * Fixed #ZED_OCULUS compiler directive not getting activated when newer Oculus package is imported
+    * Fixed newer Oculus package causing #ZED_STEAM_VR compiler directive getting activated when importing Oculus package. This would also happen when importing the OpenVR package in Unity 2019
+    * Fixed ZEDControllerTracker not updating Oculus Touch controller position if only one controller is connected
+    * Fixed ZEDSupportFunctions.GetForwardDistanceAtPixel not properly accounting for screen size
+    * Fixed "ZED Disconnected" error message not being locked to the headset when using ZED_Rig_Stereo
+    * Fixed Planetarium example scene being way too dark in deferred rendering
+    * Fixed plugin not recognizing Dell VISOR or Lenovo Explorer WMR headsets when using them in SteamVR, or any WMR controllers at all.
+    * Updated video stream link in Movie Screen example scene as the old video link was taken down (same video, new host)
+    * Fixed SVO Loop feature not working when real-time mode is enabled
+    * Fixed Multicam crash if both cameras share the same CAMERA_ID
+
+
+### 2.8.0
+
+   * **Features**:
+    * Added Multi ZED Rig support:
+      - *Complete refactoring of the wrapper and plugin to change singleton implementation into multi instance support. The maximum number of instance is limited to 4 cameras.*
+      - *Each ZEDManager now has a ZED_CAMERA_ID to define its own camera ID.*
+      - *All static events in ZEDManager have been replaced by "local" events to make them specific to a rig/camera. Example: OnZEDReady*
+      - *Added ZEDManager.GetInstance(sl.ZED_CAMERA_ID) static function to access the ZEDManager in a external script without having the ZEDManager as a parameter of the script. Note that the user must check the return value of this function since it can be null.*
+      - *Added ZEDManager.GetInstances() to list all ZEDManagers in the scene.*
+      - *Spatial Mapping module and Camera settings module have been moved to ZEDManager to simplify their use in a multi or single ZED configuration.*
+      - *Added MultiCam example to show how to use 2 ZEDs in a single application.*
+      - *Overhauled many scripts to take advantage of multiple cameras when possible. For example, projectiles in the Drone Shooter sample can collide with the world seen by any camera.*
+    * Added Streaming module from ZED SDK 2.8:
+      - ***Input*** : *You can now receive a video stream from a ZED over the network, and process it locally. Do this by setting ZEDManager's Input Type to "Stream" in the Inspector, and specify the IP/Port configuration of the sender.*
+      - ***Output*** : *To broadcast a stream, set the ZED's Input Type to USB or SVO, and open the "Streaming" section further down. Specify the codec/streaming configuration if necessayr and check "Enable Streaming Output".*
+      - *You can adjust camera settings from a receiving PC, allowing you to control an entire scene from a single device.*
+    * Added initial camera position estimation option to ZEDManager:
+      - *If EnableTracking is activated, estimateInitialPosition will simply activate the TrackingParameters::set_floor_as_origin to estimate the floor position, and therefore the camera position, during tracking initialization. *
+      - *If EnableTracking is not used, estimateInitialPosition will try to detect the floor planes multiple times and compute an average camera position from the floor position.*
+    * Pose smoothing added to spatial memory feature, so pose corrections no longer appear as "jumps."
+    * Added manually turning the ZED's LED light on and off, to be used for debugging. See ZEDCameraSettings.
+    * Added option in ZEDManager's Advanced Settings to grey out the skybox when the scene starts. This was done automatically before to avoid affecting AR lighting, but can be disabled for greenscreen use.
+
+    * **Improvements**:
+     * Removed ZED rigs' dependence on layers:
+       - Previously, the "frame" quads in each ZED rig (including the hidden AR rig) were assigned their own layer, and all other cameras had this layer removed from their culling mask. This made it so no camera would see a frame meant for another eye, but left fewer layers available to the user and made the cameras' culling masks impossible to set from the Inspector.
+       - Frames now use the HideFromWrongCamera script to prevent rendering to the wrong cameras without the use of layers. Cameras in ZED_Rig_Mono and ZED_Rig_Stereo can have their culling masks set freely.
+       - The hidden AR camera rig still uses a single "AR layer", customizable in ZEDManager's Advanced Settings, so that it can see the frame without seeing any other objects. This was done as an alternative to drawing the quad with Graphics.Draw, which would make it difficult for newer users to understand.
+     * Moved all SVO features from ZEDSVOManager (now deprecated) to ZEDManager:
+       - Read an existing SVO by setting Input Type to "SVO" and specifying a file.
+       - Record a new SVO by opening the "Recording" section. You now need to press "Start Recording" from the editor or call ZEDCamera.EnableRecording() in a script (and ZEDCamera.DisableRecording() to stop).
+     * Planes detected by the ZED no longer drawn with  a hidden camera, allowing them to be drawn at the same time as a spatial mapping wireframe.
+     * ZEDPlaneDetectionManager can now have "Visible in Scene" disabled and "Visible in Scene" enabled at the same time.
+
+   * **Bug Fixes**:
+    * Fixed bug that overwrites camera position if user set one before starting the scene (when tracking is not activated).
+    * Fixed latency compensation in ZEDControllerTracker causing the ZED to drift infinitely when a ZED rig was a child of it.
+    * Fixed normally-hidden AR rig not appearing in the Hierarchy on start if "Show Final AR Rig" was enabled before runtime.
+    * Fixed app taking a long time to close if closed while a ZED was still initializing.
+    * Fixed asteroids in Planetarium sample only being drawn to layer 8.
+
+
+   * **Compatibility**:
+    * Compatible with ZED SDK 2.8, CUDA 9.0 and 10.0.
+    * Updated controller scripts to work with the new SteamVR Unity plugin v2.0, so long as its Action system has not been activated.
+
+
+
+
+###2.7.1
+
+   * **Features/Improvements**:
+     - Added option to enable/disable the skybox at start in ZEDManager -> Advanced Settings. Prior, it was always disabled.  
+     - ZEDManager now automatically names the layers it uses (27-30 by default) so long as they don't already have names. This makes them visible in layer drop-downs,
+       making it much clearer how the plugin uses these layers. Big thanks to Andrea Brunori for suggesting the method used to achieve this.
+     - ZEDManager's default layers changed from 28-31 to 27-30 to avoid conflicting with Unity rendering in the Inspector. Another thanks to Andrea
+       for pointing out this conflict.
+     - Global lighting settings in all demo scenes are now similar to avoid confusion.
+     - Removed outdated controller scripts ZEDOculusControllerManager and ZEDSteamVRControllerManager. These have been deprecated for several versions.
+       Use ZEDControllerTracker instead.
+
+   * **Bug Fixes**:
+     - Fixed the visibility and physics of planes detected by ZEDPlaneDetectionManager not being updated if the global visibility/physics values
+       were updated by a script when the Inspector wasn't visible. See planesHavePhysics, planesVisibleInScene and planesVisibleInGame within ZEDPlaneDetectionManager.
+     - Fixed Oculus Integration and SteamVR Plugin packages not being detected if their folders were renamed, or placed anywhere but the root /Assets/ folder.
+     - Fixed ZEDControllerTracker causing ZED rig to float away when ZED rig is a child of it (due to drift correction)
+     - Fixed hidden AR rig not appearing in the Hierarchy if Show AR Rig in ZEDManager's Advanced Settings was set to true on start.
+
+
+
+### 2.7.0
+
+   * **Features**:
+    - Added toggle box to reveal a camera rig used for final HMD output, normally hidden, for advanced users
+    - Added toggle boxes for the fade-in effect when the ZED initializes, and setting the ZED rig Gameobject to "DontDestroyOnLoad" on start
+
+
+   * **Bug Fixes**:
+    - Fixed Rift/Vive controller drift when using ZED's tracking instead of the HMD's  
+    - Changed the previously hard-coded layers the ZED plugin used (8-11) to be adjusted in the Inspector, and set them to 28-31 by default
+    - Changed greenscreen config file loading so that it will work in a build when placed in a Resources folder, and changed default save path accordingly
+    - Clarified error messages from playing SVOs in loop mode with tracking enabled
+
+
+   * **Compatibility**:
+    - Compatible with ZED SDK 2.7, CUDA 9.0 or 10.0.
+
+
+
+
+
+### 2.6.0
+   * **Features/Bug Fixes**:
+     - Add WindowsMR support through SteamVR Only (Beta).
+     - Fixed overwriting old mesh textures when Spatial mapping button is used while Save Mesh is checked.
+     - Forced pasue state to false when stating a scan in case it's been left in a pause state from a previous scan.
+     - Fixed restart (not) required when changing post-processing settings.
+     - Fixed repetitve UI error when not using plugin in VR mode in ZEDControllerTracker.cs. [ssue #21 reported on github].
+
+
+  * **Documentation**:
+    - Full rework of comments in source code.
+
+
+   * **Compatibility**:
+     - Compatible with ZED SDK 2.6, CUDA 9.0 or 9.2.
+
+
+### 2.5.0
+   * **Features**:
+     - Add USB Headset detection function in non-play mode.
+     - Improve tracking status with "Camera not tracked" status if no headset connected and camera tracking is disabled.
+
+
+  * **Examples**:
+    - Add Drone Shooter example. This example reproduces the ZEDWorld drone demo app.
+    - Add Movie Screen example. This example reproduces the ZEDWorld movie demo app.
+    - Add VR Only Plane Detection. Advanced plane detection sample to show how the place the bunny and make collisions.
+
+
+   * **Compatibility**:
+     - Compatible with ZED SDK 2.5, CUDA 9.0 or 9.2.
+
+
+### 2.4.1
+  - **Features**:
+    - Add Full IMUData access to get angular velocity and linear acceleration through ZEDCamera.GetInternalIMUData() function.
+
+  - **Examples**:
+    - Modified Dark room sample into a AR "night club" light show to show how to use ZED Manager's camera brightness settings and ZEDLight script.
+    - Update Object Placement sample and doc.
+
+  - **Bug Fixes**:
+    - Fix ZEDManager's camera brightness settings through scripting.
+    - Fix Normal and Center on plane's detection. Refactor ZEDPlaneGameObject as MonoBehavior.
+    - Fix ZED Rig Mono image when game is built due to rendering path.
+    - Fix crash when moving SVO playback playhead.
+    - Fix Camera settings spamming errors due to pluginIsReady value not set.
+    - Fix loading screen blank on left eye at specific rotations (180deg).
+    - Fix Depth occlusion setting in Rig mono.
+    - Fix greenscreen wrong config file that breaks the GreenScreen example if not found.
+    - Remove "Restart Camera" when changing Depth occlusions as it was not needed.
+
+  - **Compatibility**:
+    - Add Vive Pro support as VR headset (not with the Vive's cameras).
+
+
+### 2.4.0
+ - **Features**:
+   - Added plane detection :
+      - ZEDPlaneDetectionManager.cs interfaces with the SDK. Click on the screen to add planes when detected, or specify a screen-space location with DetectPlaneAtHit(). A specific function for floor detection DetectFloorPlane() is provided (as well as a GUI button access). ZEDPlaneDetectionManager inherits from MonoBehavior and must be used to have access to plane detection in Unity Scene.
+      - ZEDPlaneGameObject.cs represents a plane with info about its position, rotation, boundaries, etc. It also creates a GameObject representation of the plane that supports collisions and rendering.
+      - ZEDPlaneRenderer.cs (automatically created by ZEDPlaneDetectionManager) displays a scene's planes overlapping other objects so that planes highlight real-world features instead of appearing distinct from them.
+   - Added HitTest multiple support functions for Real / Virtual world collision when no spatial mapping is used (Beta).
+   - Added prompt for recommended settings on import, most notably MSAA x4 and Linear color space.
+   - Added changing resolution, depth mode, and other options in ZEDManager at runtime (requires restarting the camera).
+   - The ZED can now be reconnected mid-scene after being disconnected.
+   - Scanned meshes, SVOs, greenscreen configuration files and .area files are now saved in /Assets/ by default rather than the root project folder. This makes them accessible in the Project tab within Unity.
+
+ - **Bug Fixes**:
+   - Fixed wrong transformation for Normal vector in World reference frame, causing object placement sometimes unstable.
+   - Fixed incorrect reports of bandwidth issues when set to 1080p resolution.
+   - Fixed alert about missing IMU before enough time has passed to find it.
+   - Updated broken prefab references in Spatial Mapping sample and prefabs
+   - Fixed Depth Occlusion option on ZEDManager only being changable at runtime, and only applying to the left eye in stereo mode.
+   - Added proper error message when scene is started without the ZED SDK installed
+   - Removed missing sdk window popup when play/pause is pressed. This window now only shows up when Unity is loaded.
+   - Fixed broken Pause button on ZEDSVOManager.
+   - Fixed the ZED stream not properly closing if ZEDManager was disabled or destroyed when the scene ended. This would result in problems connecting to the ZED until the ZED is replugged or the computer is restarted.  
+   - Fixed issue causing the loading screen to be heavily pixelated in stereo mode.
+   - Fixed flashing errors in loading screen (when an error occurs).
+   - Specifying an invalid .area file for spatial memory no longer causes tracking to be disabled; the file is now ignored.
+   - Fixed directionnal light on Object Placement scene.
+   - Hide Rendering planes of ZED_Rig_Stereo prefab in the scene when game is not started.
+
+ - **Examples**:
+   - Modified lighting, animations and navigation in ZomBunny prefab for Spatial Mapping and Object Placement samples to make it appear more realistic.
+   - PlaceOnScreen.cs (Object Placement) now instantiates new objects on click rather than moving around a pre-existing object.
+
+ - **Renaming**:
+   - Renaming getDepthAtxxx() and getDistanceAtxxx() support functions in getForwardDistanceAtxxx() and getEuclideanDistanceAtxxx() for better understanding.
+
+ - **Compatibility**:
+   - Updated Oculus Package detection ("OVR" becomes "Oculus") in ZEDOculusControllerManager.cs
+
+
+### 2.3.3
+- **Features**:
+   - Updated ZEDCamera.cs script to include GetInternalIMUOrientation function to get access to internal imu quaternion of the ZED-M.
+   - Improved VAR (timewarp) when using HTC Vive in stereo pass-through.
+
+- **Bug Fixes**:
+   - Fixed camera FPS stats display when camera is disconnected. It shows now "disconnected" instead of the last camera FPS.
+
+
+
+### 2.3.2
+- **Features**:
+   - Updated ZEDCamera.cs script to include setIMUPrior(sl::Transform) function used for video pass-through.
+   - Added Camera FPS, Engine FPS, Tracking Status, HMD and Plugin version in ZED Manager panel. These status will help developers see where the application's bottlenecks are.
+A Camera FPS below 60FPS indicates a USB bandwidth issue. An Engine FPS below 90FPS indicates that rendering is the limiting factor. Both will induce drop frames.
+Note that building and running your application greatly improves performance compared to playing the scene in Unity Editor
+   - Added automatic detection of OVR package to avoid having to manually define "ZED_OCULUS" in project settings when using ZEDOculusControllerManager.
+   - Added compression settings (RAW, LOSSLESS, LOSSY) in ZEDSVOManager.cs script.
+
+- **Bug Fixes**:
+   - Fixed initial camera position when using ZED Mini and an HMD. This had an impact on virtual objects created with physical gravity up and spatial mapping mesh origin.
+   - Fixed enable/disable depth occlusions settings in Deferred rendering mode.
+   - Fixed resize of halo effect in the Planetarium example.
+   - Fixed garbage matte behavior in GreenScreen example that displayed anchor spheres in the scene after loading a matte
+   - Fixed ZED Manager instance creation to respect MonoBehavior implementation. Only one ZED manager instance is available at a time for an application.
+   - Fix Loading message when ZED tries to open.
+   - Remove BallLauncher message instruction as gameobject, as it was not used.
+
+### 2.3.1
+- **Minor Bug fixes and Features** :
+   - Fix GreenScreen broken prefab in Canvas.
+   - Fix default spatial memory path when enableTracking is true. Could throw an exception when tracking was activated in green screen prefab.
+   - Fix missing but unused script in Planetarium prefab
+   - Added Unity Plugin version in ZEDCamera.cs
+
+### 2.3.0
+- **Features**:
+   - Added support for ZED mini.
+   - Added beta stereo passthrough feature with optimized rendering in VR headsets (only with ZED mini)
+- **Prefabs**:
+   - Added ZED_Rig_Stereo prefab, with stereo capture and stereo rendering to VR headsets (beta version)
+   - Renamed ZED_Rig_Left in ZED_Rig_Mono, for better mono/stereo distinction.
+- **Examples**:
+   - Added Planetarium scene to demonstrate how to re-create the solar system in the real world. This is a simplified version of the ZEDWorld app.
+   - Added Dark Room scene to demonstrate how to decrease the brightness of the real world using the "Real Light Brightness" setting in ZEDManager.cs.
+   - Added Object Placement scene to demonstrate how to place an object on a horizontal plane in the real world.
+- **Scripts**:
+   - Added ZEDSupportFunctions.cs to help using depth and normals at a screen or world position. Some of these functions are used in ObjectPlacement scene.
+   - Added ZEDMixedRealityPlugin.cs to handle stereo passthrough in Oculus Rift or HTC Vive Headset.
+- **Renaming**:
+  -  ZEDTextureOverlay.cs has been renamed ZEDRenderingPlane.cs.
+- **Compatibility**:
+  - Supports ZED SDK v2.3.0
+  - Supports Unity 2017.x.y (with automatic updates from Unity).
+- **Known Issues**:
+  - On certain configurations, VRCompositor in SteamVR can freeze when using HTC Vive and ZED. Disabling Async Reprojection in SteamVR's settings can fix the issue.
+  - The stereo passthrough experience is highly sensitive to Capture/Engine FPS. Here are some tips:
+            * Make sure your PC meets the requirements for stereo pass-through AR (GTx 1070 or better).
+            * Make sure you don't have other resource-intensive applications running on your PC at the same time as Unity.
+            * Test your application in Build mode, rather than the Unity editor, to have the best FPS available.
+
+### 2.2.0/2.1.0/2.0.0
+See ZED SDK release notes.

Assets/ZED/Doc/ReleaseNotes.md.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ace2a5d4211709245b3c7249eb366966
+timeCreated: 1515608218
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/Doc/Tutorials.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 7e1e3c632119214408b71566cdb74f98
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/Doc/Tutorials/Linux_tutorial.md

@@ -0,0 +1,74 @@
+# Unity plugin -- How to build an application for Linux
+
+
+## Introduction
+In this tutorial, we will show how easy it is to build an application for Linux when you are running the Unity editor on Windows.
+
+Note that the current official plugin version does not support Linux. The Linux support is currently in beta.
+
+We won't cover how to create the scenes, as it's the exact same as Windows and covered in our [Unity documentation](https://www.stereolabs.com/docs/unity/). 
+
+## Requirements
+* Requires Unity 2018.x. (plugin is now using UnityEngine.XR)
+* Unity Editor in OpenGLCore/Desktop graphic API (DirectX does not exist on Linux)
+* ZED Unity Plugin from github, on Linux_compatibility_beta branch.
+
+## What's Different about the Linux Native Plugin?
+
+The Unity plugin revolves around the ZED Unity wrapper, sl_unitywrapper.dll, a single library that provides access to ZED SDK functions. Under Windows, you can find this library in SDK/Plugins/Win64/.
+
+Under Linux, it's instead an .so library (similar to a dll for Linux) called libsl_unitywrapper.so in the SDK/Plugins/Linux/ folder.
+
+Under the hood, there are some differences with the Windows version:
+- On Windows, the .dll is dynamically linked against the ZED SDK and statically linked against CUDA(rt). Therefore, due to the way Windows resolves the dependencies, the wrapper will load the ZED SDK libraries installed on the PC.
+- On Linux, any dependencies of a library must be linked once the executable is created.<br/>
+ Since we support multiple CUDA versions and multiple Ubuntu LTS versions (16 and 18), that would mean a different version for each configuration. Since when you are building an application for Linux, you may not know what the final target would be, other than that it's Linux. It was not possible to keep it that way.
+
+To solve this, the ZED SDK is statically embedded in the Linux wrapper library. The big advantage this provides is that you don't need to worry about the CUDA version and even the Ubuntu version (for 16LTS and 18LTS).
+Furtermore, unlike Windows, you *don't need to install the ZED SDK* on the target device since it is already inside the wrapper.
+ *One library to rule them all...*
+
+
+## Install the Linux Build Support on Windows
+
+When you install Unity on Windows, it does not come with Linux build support by default. This is what you need to specify that the application will run on Linux.
+To install it, go to the Unity Hub on the *Installs* tab :
+On the desired Unity version, click on *...* and select Add Component:
+
+![](./images/Hub_add_component.png)
+
+
+This will open a list of components you can add to your installation. Select Linux Build Support:
+
+![](./images/Hub_Add_Linux_Support.png)
+
+Wait for the installation to complete and restart Unity Hub.
+
+
+## Create your Project in Unity
+
+* When Unity is started, create a new project, enter a name and click on "Create Project"
+* In the menu bar, click on Assets >> Import Package >> Custom Package... and select the ZED Unity package file (xxxxx.unitypackage). The unity import window should appear and click on "import".
+* In the project window, select one of the provided scene located in ZED/Examples/XXXX/Scenes/ by double clicking on it. You can also use the prefabs.
+* A simple scene with spheres and cubes should appear in the Scene and Game window.
+* Click on play button to launch it.
+
+
+## Build the Application
+
+On the Unity Menu bar, click on **File** -> then **Build Settings** to build your application (or Ctrl+Shift+B). A familiar popup will open.
+Now that you've installed Linux support in Unity, you can choose Linux as the Target Platform in addition to Windows.
+
+![](./images/Linux_choice.png)
+
+
+* Select Linux and click on Build.
+
+* Under Linux, the application will be called XXXXX.x86_64 with a XXXX_data folder attached. Inside the XXX_data/plugins folder, you will see the libsl_unitywrapper.so directly inside.
+
+![](./images/Linux_folder.png)
+
+* Copy both the file and folder oto your Linux desktop. You may need to set the file as an executable : 
+`$ chmod +x ./XXXXX.x86_64`
+
+Launch the application and enjoy it running on Linux.

Assets/ZED/Doc/Tutorials/Linux_tutorial.md.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 5e8530b4143a014499e2d03cef546920
+timeCreated: 1563257664
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/Doc/Tutorials/images.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 194f6e9ae8fe58e41bb77ef3f3b6a06c
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/Doc/Tutorials/images/Hub_Add_Linux_Support.png.meta

@@ -0,0 +1,74 @@
+fileFormatVersion: 2
+guid: 9a28fee6e68ea8e45bc9ba23b4851a5d
+timeCreated: 1563257670
+licenseType: Free
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/Doc/Tutorials/images/Hub_add_component.png.meta

@@ -0,0 +1,74 @@
+fileFormatVersion: 2
+guid: 2705d90a67c02dd44a180911a8520d8d
+timeCreated: 1563257669
+licenseType: Free
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/Doc/Tutorials/images/Linux_choice.png.meta

@@ -0,0 +1,74 @@
+fileFormatVersion: 2
+guid: 1860396ae95a7c84f86348d6c0c4381e
+timeCreated: 1563257669
+licenseType: Free
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/Doc/Tutorials/images/Linux_folder.png.meta

@@ -0,0 +1,74 @@
+fileFormatVersion: 2
+guid: 841c9492e6bdfcd439b7f6062635b521
+timeCreated: 1563257670
+licenseType: Free
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 46858e2abe57d8a439e3fad1b34fc42d
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/Editor/Scripts.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4234cc24cfcfb404cb424f5192a0ecc6
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/Editor/Scripts/BuildScript.cs

@@ -0,0 +1,8 @@
+using UnityEditor;
+class BuildScript
+{
+	static void CreateCSProj()
+	{
+		EditorApplication.ExecuteMenuItem("Assets/Open C# Project");
+	}
+}

Assets/ZED/Editor/Scripts/BuildScript.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f73e4b49169cb574899b0bca90d1d152
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/Editor/Scripts/RenderingPipelineDefines.cs

@@ -0,0 +1,125 @@
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+[InitializeOnLoad]
+public class RenderingPipelineDefines
+{
+    enum PipelineType
+    {
+        Unsupported,
+        BuiltInPipeline,
+        UniversalPipeline,
+        HDPipeline
+    }
+
+    static RenderingPipelineDefines()
+    {
+        UpdateDefines();
+    }
+
+    /// <summary>
+    /// Update the unity pipeline defines for URP
+    /// </summary>
+    static void UpdateDefines()
+    {
+        var pipeline = GetPipeline();
+
+        if (pipeline == PipelineType.UniversalPipeline)
+        {
+            AddDefine("ZED_URP");
+        }
+        else
+        {
+            RemoveDefine("ZED_URP");
+        }
+        if (pipeline == PipelineType.HDPipeline)
+        {
+            AddDefine("ZED_HDRP");
+        }
+        else
+        {
+            RemoveDefine("ZED_HDRP");
+        }
+    }
+
+
+    /// <summary>
+    /// Returns the type of renderpipeline that is currently running
+    /// </summary>
+    /// <returns></returns>
+    static PipelineType GetPipeline()
+    {
+#if UNITY_2019_1_OR_NEWER
+        if (GraphicsSettings.renderPipelineAsset != null)
+        {
+            // SRP
+            var srpType = GraphicsSettings.renderPipelineAsset.GetType().ToString();
+            if (srpType.Contains("HDRenderPipelineAsset"))
+            {
+                return PipelineType.HDPipeline;
+            }
+            else if (srpType.Contains("UniversalRenderPipelineAsset"))
+            {
+                return PipelineType.UniversalPipeline;
+            }
+            else return PipelineType.Unsupported;
+        }
+#elif UNITY_2017_1_OR_NEWER
+        if (GraphicsSettings.renderPipelineAsset != null) {
+            // SRP not supported before 2019
+            return PipelineType.Unsupported;
+        }
+#endif
+        // no SRP
+        return PipelineType.BuiltInPipeline;
+    }
+
+    /// <summary>
+    /// Add a custom define
+    /// </summary>
+    /// <param name="define"></param>
+    /// <param name="buildTargetGroup"></param>
+    public static void AddDefine(string define)
+    {
+        var definesList = GetDefines();
+        if (!definesList.Contains(define))
+        {
+            definesList.Add(define);
+            SetDefines(definesList);
+        }
+    }
+
+    /// <summary>
+    /// Remove a custom define
+    /// </summary>
+    /// <param name="_define"></param>
+    /// <param name="_buildTargetGroup"></param>
+    public static void RemoveDefine(string define)
+    {
+        var definesList = GetDefines();
+        if (definesList.Contains(define))
+        {
+            definesList.Remove(define);
+            SetDefines(definesList);
+        }
+    }
+
+    public static List<string> GetDefines()
+    {
+        var target = EditorUserBuildSettings.activeBuildTarget;
+        var buildTargetGroup = BuildPipeline.GetBuildTargetGroup(target);
+        var defines = PlayerSettings.GetScriptingDefineSymbolsForGroup(buildTargetGroup);
+        return defines.Split(';').ToList();
+    }
+
+    public static void SetDefines(List<string> definesList)
+    {
+        var target = EditorUserBuildSettings.activeBuildTarget;
+        var buildTargetGroup = BuildPipeline.GetBuildTargetGroup(target);
+        var defines = string.Join(";", definesList.ToArray());
+        PlayerSettings.SetScriptingDefineSymbolsForGroup(buildTargetGroup, defines);
+    }
+}

Assets/ZED/Editor/Scripts/RenderingPipelineDefines.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8722208ce646f9346b8b373203118192
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/Editor/Scripts/UpgradePluginToSRP.cs

@@ -0,0 +1,303 @@
+using System;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+public class EditPrefabAssetScope : IDisposable
+{
+
+    public readonly string assetPath;
+    public readonly GameObject prefabRoot;
+
+    public EditPrefabAssetScope(string assetPath)
+    {
+        this.assetPath = assetPath;
+        prefabRoot = PrefabUtility.LoadPrefabContents(assetPath);
+    }
+
+    public void Dispose()
+    {
+        PrefabUtility.SaveAsPrefabAsset(prefabRoot, assetPath);
+        PrefabUtility.UnloadPrefabContents(prefabRoot);
+    }
+}
+
+
+public class UpgradePluginToSRP
+{
+
+    [MenuItem("ZED/Upgrade ZED Plugin to URP")]
+    static void UpgradeToURP()
+    {
+        var SRP = GraphicsSettings.renderPipelineAsset;
+
+        string zedRigMonoPath = "Assets/ZED/Prefabs/ZED_Rig_Mono.prefab";
+        string zedRigStereoPath = "Assets/ZED/Prefabs/ZED_Rig_Stereo.prefab";
+        string zedGreenScreenPath = "Assets/ZED/Examples/GreenScreen/Prefabs/ZED_GreenScreen.prefab";
+        string zedPlanetariumPath = "Assets/ZED/Examples/Planetarium/Prefabs/Planetarium.prefab";
+
+
+        if (GraphicsSettings.renderPipelineAsset != null)
+        {
+            if (SRP.GetType().ToString().Contains("UniversalRenderPipelineAsset"))
+            {
+
+                RenderingPipelineDefines.AddDefine("ZED_URP");
+                RenderingPipelineDefines.RemoveDefine("ZED_HDRP");
+
+                Material Mat_Zed_Forward_Lighting = Resources.Load("Materials/Lighting/Mat_ZED_Forward_Lighting_URP") as Material;
+                Material Mat_Zed_GreenScreen = Resources.Load("Materials/Mat_ZED_GreenScreen_URP") as Material;
+                Material Mat_Zed_Sun = Resources.Load("Sun/Materials/Sun_URP") as Material;
+
+
+                // Modify prefab contents and save it back to the Prefab Asset
+                using (var editScope = new EditPrefabAssetScope(zedRigMonoPath))
+                {
+                    Transform frame = editScope.prefabRoot.transform.Find("Camera_Left").Find("Frame");
+
+                    if (frame)
+                    {
+                        frame.GetComponent<MeshRenderer>().material = Mat_Zed_Forward_Lighting;
+                    }
+                    else
+                    {
+                        Debug.Log("Frame is not found");
+                    }
+                }
+                using (var editScope = new EditPrefabAssetScope(zedRigStereoPath))
+                {
+                    Transform frame_left = editScope.prefabRoot.transform.Find("Camera_eyes").Find("Left_eye").Find("Frame");
+
+                    if (frame_left)
+                    {
+                        frame_left.GetComponent<MeshRenderer>().material = Mat_Zed_Forward_Lighting;
+                    }
+                    else
+                    {
+                        Debug.Log("Frame Left is not found");
+                    }
+
+                    Transform frame_right = editScope.prefabRoot.transform.Find("Camera_eyes").Find("Right_eye").Find("Frame");
+
+                    if (frame_right)
+                    {
+                        frame_right.GetComponent<MeshRenderer>().material = Mat_Zed_Forward_Lighting;
+                    }
+                    else
+                    {
+                        Debug.Log("Frame Right is not found");
+                    }
+                }
+                // Modify prefab contents and save it back to the Prefab Asset
+                using (var editScope = new EditPrefabAssetScope(zedGreenScreenPath))
+                {
+                    Transform frame = editScope.prefabRoot.transform.Find("Camera_Left").Find("Frame");
+
+                    if (frame)
+                    {
+                        frame.GetComponent<MeshRenderer>().material = Mat_Zed_GreenScreen;
+                    }
+                    else
+                    {
+                        Debug.Log("Frame is not found");
+                    }
+                }
+                using (var editScope = new EditPrefabAssetScope(zedPlanetariumPath))
+                {
+                    Transform sun = editScope.prefabRoot.transform.Find("Sun").Find("sun");
+
+                    if (sun)
+                    {
+                        sun.GetComponent<MeshRenderer>().material = Mat_Zed_Sun;
+                    }
+                    else
+                    {
+                        Debug.Log("Planetarium is not found");
+                    }
+                }
+            }
+            else
+            {
+                Debug.LogWarning("Trying to convert to URP without using URP !!");
+            }
+        }
+
+    }
+
+    [MenuItem("ZED/Upgrade ZED Plugin to HDRP")]
+    static void UpgradeToHDRP()
+    {
+        var SRP = GraphicsSettings.renderPipelineAsset;
+
+        string zedRigMonoPath = "Assets/ZED/Prefabs/ZED_Rig_Mono.prefab";
+        string zedRigStereoPath = "Assets/ZED/Prefabs/ZED_Rig_Stereo.prefab";
+        string zedGreenScreenPath = "Assets/ZED/Examples/GreenScreen/Prefabs/ZED_GreenScreen.prefab";
+        string zedPlanetariumPath = "Assets/ZED/Examples/Planetarium/Prefabs/Planetarium.prefab";
+
+        if (SRP.GetType().ToString().Contains("HDRenderPipelineAsset"))
+        {
+
+            RenderingPipelineDefines.AddDefine("ZED_HDRP");
+            RenderingPipelineDefines.RemoveDefine("ZED_URP");
+
+            Material Mat_Zed_Forward_Lighting = Resources.Load("Materials/Lighting/Mat_ZED_HDRP_Lit") as Material;
+            Material Mat_Zed_GreenScreen = Resources.Load("Materials/Mat_ZED_Greenscreen_HDRP_Lit") as Material;
+            Material Mat_Zed_Sun = Resources.Load("Sun/Materials/Sun_URP") as Material;
+
+            // Modify prefab contents and save it back to the Prefab Asset
+            using (var editScope = new EditPrefabAssetScope(zedRigMonoPath))
+            {
+                Transform frame = editScope.prefabRoot.transform.Find("Camera_Left").Find("Frame");
+
+                if (frame)
+                {
+                    frame.GetComponent<MeshRenderer>().material = Mat_Zed_Forward_Lighting;
+                }
+                else
+                {
+                    Debug.Log("Frame is not found");
+                }
+            }
+
+            using (var editScope = new EditPrefabAssetScope(zedRigStereoPath))
+            {
+                Transform frame_left = editScope.prefabRoot.transform.Find("Camera_eyes").Find("Left_eye").Find("Frame");
+
+                if (frame_left)
+                {
+                    frame_left.GetComponent<MeshRenderer>().material = Mat_Zed_Forward_Lighting;
+                }
+                else
+                {
+                    Debug.Log("Frame Left is not found");
+                }
+
+                Transform frame_right = editScope.prefabRoot.transform.Find("Camera_eyes").Find("Right_eye").Find("Frame");
+
+                if (frame_right)
+                {
+                    frame_right.GetComponent<MeshRenderer>().material = Mat_Zed_Forward_Lighting;
+                }
+                else
+                {
+                    Debug.Log("Frame Right is not found");
+                }
+            }
+            // Modify prefab contents and save it back to the Prefab Asset
+            using (var editScope = new EditPrefabAssetScope(zedGreenScreenPath))
+            {
+                Transform frame = editScope.prefabRoot.transform.Find("Camera_Left").Find("Frame");
+
+                if (frame)
+                {
+                    frame.GetComponent<MeshRenderer>().material = Mat_Zed_GreenScreen;
+                }
+                else
+                {
+                    Debug.Log("Frame is not found");
+                }
+            }
+            using (var editScope = new EditPrefabAssetScope(zedPlanetariumPath))
+            {
+                Transform sun = editScope.prefabRoot.transform.Find("Sun").Find("sun");
+
+                if (sun)
+                {
+                    sun.GetComponent<MeshRenderer>().material = Mat_Zed_Sun;
+                }
+                else
+                {
+                    Debug.Log("Planetarium is not found");
+                }
+            }
+        }
+        else
+        {
+            Debug.LogWarning("Trying to convert to HDRP without using HDRP !!");
+        }
+    }
+
+    /*[MenuItem("ZED/Revert ZED Plugin to built-in RP")]
+    static void RevertToBuiltInRP()
+    {
+        RenderingPipelineDefines.RemoveDefine("ZED_HDRP");
+        RenderingPipelineDefines.RemoveDefine("ZED_URP");
+
+        string zedRigMonoPath = "Assets/ZED/Prefabs/ZED_Rig_Mono.prefab";
+        string zedRigStereoPath = "Assets/ZED/Prefabs/ZED_Rig_Stereo.prefab";
+        string zedGreenScreenPath = "Assets/ZED/Examples/GreenScreen/Prefabs/ZED_GreenScreen.prefab";
+        string zedPlanetariumPath = "Assets/ZED/Examples/Planetarium/Prefabs/Planetarium.prefab";
+
+        Material Mat_Zed_Forward_Lighting = Resources.Load("Materials/Lighting/Mat_ZED_Forward_Lighting") as Material;
+        Material Mat_Zed_GreenScreen = Resources.Load("Materials/Mat_ZED_GreenScreen_URP") as Material;
+        Material Mat_Zed_Sun = Resources.Load("Sun/Materials/Sun_URP") as Material;
+
+        // Modify prefab contents and save it back to the Prefab Asset
+        using (var editScope = new EditPrefabAssetScope(zedRigMonoPath))
+        {
+            Transform frame = editScope.prefabRoot.transform.Find("Camera_Left").Find("Frame");
+
+            if (frame)
+            {
+                frame.GetComponent<MeshRenderer>().material = Mat_Zed_Forward_Lighting;
+            }
+            else
+            {
+                Debug.Log("Frame is not found");
+            }
+        }
+        using (var editScope = new EditPrefabAssetScope(zedRigStereoPath))
+        {
+            Transform frame_left = editScope.prefabRoot.transform.Find("Camera_eyes").Find("Left_eye").Find("Frame");
+
+            if (frame_left)
+            {
+                frame_left.GetComponent<MeshRenderer>().material = Mat_Zed_Forward_Lighting;
+            }
+            else
+            {
+                Debug.Log("Frame Left is not found");
+            }
+
+            Transform frame_right = editScope.prefabRoot.transform.Find("Camera_eyes").Find("Right_eye").Find("Frame");
+
+            if (frame_right)
+            {
+                frame_right.GetComponent<MeshRenderer>().material = Mat_Zed_Forward_Lighting;
+            }
+            else
+            {
+                Debug.Log("Frame Right is not found");
+            }
+        }
+        // Modify prefab contents and save it back to the Prefab Asset
+        using (var editScope = new EditPrefabAssetScope(zedGreenScreenPath))
+        {
+            Transform frame = editScope.prefabRoot.transform.Find("Camera_Left").Find("Frame");
+
+            if (frame)
+            {
+                frame.GetComponent<MeshRenderer>().material = Mat_Zed_GreenScreen;
+            }
+            else
+            {
+                Debug.Log("Frame is not found");
+            }
+        }
+        using (var editScope = new EditPrefabAssetScope(zedPlanetariumPath))
+        {
+            Transform sun = editScope.prefabRoot.transform.Find("Sun").Find("sun");
+
+            if (sun)
+            {
+                sun.GetComponent<MeshRenderer>().material = Mat_Zed_Sun;
+            }
+            else
+            {
+                Debug.Log("Planetarium is not found");
+            }
+        }
+    }*/
+}
+
+

Assets/ZED/Editor/Scripts/UpgradePluginToSRP.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 574df5654f2725c46a383cb7cb5aaf9a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/Editor/Scripts/ZEDCameraEditor.cs

@@ -0,0 +1,1544 @@
+//======= Copyright (c) Stereolabs Corporation, All rights reserved. ===============
+using UnityEngine;
+using UnityEditor;
+
+/// <summary>
+/// Custom editor used by ZEDManager to extend the default panel shown in the Inspector.
+/// Adds the camera status boxes, the button on the bottom to open camera settings, and a button to restart the camera when
+/// a settings has changed that requires it.
+/// </summary>
+[CustomEditor(typeof(ZEDManager)), CanEditMultipleObjects]
+public class ZEDCameraEditor : Editor
+{
+    /// <summary>
+    /// Reference to the ZEDManager instance we're editing.
+    /// </summary>
+    ZEDManager manager;
+
+    //Store copies of ZEDManager's fields to detect changes later with CheckChange().
+    //These do not need to be SerializedProperties because they're only used for checking recent changes.
+    sl.RESOLUTION resolution;
+    sl.DEPTH_MODE depthmode;
+    bool usespatialmemory;
+
+
+    //Input Prop
+    private SerializedProperty cameraIDProperty;
+    private SerializedProperty inputTypeProperty;
+    private SerializedProperty depthModeProperty;
+    private SerializedProperty usbResolutionProperty;
+    private SerializedProperty usbFPSProperty;
+    private SerializedProperty svoFileNameProperty;
+    private SerializedProperty svoLoopProperty;
+    private SerializedProperty svoRealTimeModeProperty;
+    private SerializedProperty pauseSVOProperty;
+    private SerializedProperty currentFrameSVOProperty;
+    private SerializedProperty maxFrameSVOProperty;
+    private SerializedProperty streamIPProperty;
+    private SerializedProperty streamPortProperty;
+
+#if ZED_HDRP
+    //SRP Lighting Prop
+    private SerializedProperty srpShaderTypeProperty;
+    private SerializedProperty selfIlluminationProperty;
+    private SerializedProperty applyZEDNormalsProperty;
+#endif
+
+    //Tracking Prop
+    private SerializedProperty enableTrackingProperty;
+    private SerializedProperty enableSMProperty;
+    private SerializedProperty pathSMProperty;
+    private SerializedProperty estimateIPProperty;
+    private SerializedProperty trackingIsStaticProperty;
+
+    //Rendering Prop
+    private SerializedProperty depthOcclusionProperty;
+    private SerializedProperty arpostProcessingPropery;
+    private SerializedProperty camBrightnessProperty;
+
+    //Recording Prop
+    private SerializedProperty svoOutputFileNameProperty;
+    private SerializedProperty svoOutputCompressionModeProperty;
+    private SerializedProperty svoOutputBitrateProperty;
+    private SerializedProperty svoOutputTargetFPSProperty;
+    private SerializedProperty svoOutputTranscodeProperty;
+
+
+    //Streaming Prop
+    private SerializedProperty streamingOutProperty;
+    private SerializedProperty streamingOutCodecProperty;
+    private SerializedProperty streamingOutPortProperty;
+    private SerializedProperty streamingOutBitrateProperty;
+    private SerializedProperty streamingOutGopSizeProperty;
+    private SerializedProperty streamingOutAdaptBitrateProperty;
+    private SerializedProperty streamingOutChunkSizeProperty;
+    private SerializedProperty streamingOutTargetFPSProperty;
+
+
+    //Spatial mapping prop
+    private string displayText = "Hide Mesh";
+    /// <summary>
+    /// Serialized version of ZEDSpatialMappingManager's range_preset property.
+    /// </summary>
+    private SerializedProperty range;
+    /// <summary>
+    /// Serialized version of ZEDSpatialMappingManager's resolution_preset property.
+    /// </summary>
+    private SerializedProperty mappingResolution;
+    /// <summary>
+    /// Serialized version of ZEDSpatialMappingManager's isFilteringEnable property.
+    /// </summary>
+    private SerializedProperty isFilteringEnable;
+    /// <summary>
+    /// Serialized version of ZEDSpatialMappingManager's filterParameters property.
+    /// </summary>
+    private SerializedProperty filterParameters;
+    /// <summary>
+    /// Serialized version of ZEDSpatialMappingManager's isTextured property.
+    /// </summary>
+    private SerializedProperty saveWhenOver;
+    /// <summary>
+    /// Serialized version of ZEDSpatialMappingManager's saveWhenOver property.
+    /// </summary>
+    private SerializedProperty isTextured;
+
+    /// <summary>
+    /// Layout option used to draw the '...' button for opening a File Explorer window to find a mesh file.
+    /// </summary>
+    private SerializedProperty meshPath;
+
+    //Object Detection Prop
+    private SerializedProperty OD_ImageSyncMode;
+    private SerializedProperty OD_ObjectTracking;
+    private SerializedProperty OD_BodyFitting;
+    private SerializedProperty OD_2DMask;
+    private SerializedProperty OD_DetectionModel;
+    private SerializedProperty OD_MaxRange;
+    private SerializedProperty OD_FilteringMode;
+    //Object Detection Runtime Prop
+    private SerializedProperty OD_VehicleDetectionConfidence;
+    private SerializedProperty OD_PersonDetectionConfidence;
+    private SerializedProperty SK_PersonDetectionConfidence;
+    private SerializedProperty OD_BagDetectionConfidence;
+    private SerializedProperty OD_AnimalDetectionConfidence;
+    private SerializedProperty OD_ElectronicsDetectionConfidence;
+    private SerializedProperty OD_FruitVegetableDetectionConfidence;
+    private SerializedProperty OD_SportDetectionConfidence;
+    private SerializedProperty OD_PersonFilter;
+    private SerializedProperty OD_VehicleFilter;
+    private SerializedProperty OD_BagFilter;
+    private SerializedProperty OD_AnimalFilter;
+    private SerializedProperty OD_ElectronicsFilter;
+    private SerializedProperty OD_FruitVegetableFilter;
+    private SerializedProperty OD_SportFilter;
+
+    /// <summary>
+    /// Layout option used to draw the '...' button for opening a File Explorer window to find a mesh file.
+    /// </summary>
+    private GUILayoutOption[] optionsButtonBrowse = { GUILayout.MaxWidth(30) };
+    private GUILayoutOption[] optionsButtonStandard = { /*GUILayout.(EditorGUIUtility.labelWidth)*/};
+
+    SerializedProperty sensingModeProperty;
+    SerializedProperty rightDepthProperty;
+    SerializedProperty maxDepthProperty;
+    SerializedProperty confidenceThresholdProperty;
+    SerializedProperty textureConfidenceThresholdProperty;
+    SerializedProperty enableSelfCalibrationProperty;
+    SerializedProperty enableIMUFusionProperty;
+    SerializedProperty opencvCalibFilePath;
+
+    // Rendering Prop
+    private int arlayer;
+    private SerializedProperty showarrig;
+    private SerializedProperty fadeinonstart;
+    private SerializedProperty dontdestroyonload;
+    private SerializedProperty enableImageEnhancementProperty;
+    SerializedProperty setIMUPrior;
+    SerializedProperty allowPassThroughProperty;
+    SerializedProperty greyskybox;
+
+    SerializedProperty showadvanced; //Show advanced settings or not.
+    SerializedProperty showSpatialMapping;  //Show spatial mapping or not.
+    SerializedProperty showObjectDetection; //show object detection settings or not
+    SerializedProperty showRecording;  //Show recording settings or not.
+    SerializedProperty showStreamingOut;  //Show streaming out settings or not
+    SerializedProperty showcamcontrol; //Show cam control settings or not.
+
+    // Current value for camera controls
+    SerializedProperty videoSettingsInitModeProperty;
+    SerializedProperty brightnessProperty;
+    SerializedProperty contrastProperty;
+    SerializedProperty hueProperty;
+    SerializedProperty saturationProperty;
+    SerializedProperty autoGainExposureProperty;
+    SerializedProperty exposureProperty;
+    SerializedProperty gainProperty;
+    SerializedProperty autoWhiteBalanceProperty;
+    SerializedProperty whitebalanceProperty;
+    SerializedProperty sharpnessProperty;
+    SerializedProperty gammaProperty;
+    SerializedProperty ledStatus;
+
+    //private bool hasLoadedSettings = false;
+    /// <summary>
+    /// Whether we've set a manual value to gain and exposure or if they're in auto mode.
+    /// </summary>
+    //private bool setManualValue = true;
+    /// <summary>
+    /// Whether we've set a manual value to white balance or if it's in auto mode.
+    /// </summary>
+    //private bool setManualWhiteBalance = true;
+
+    private string[] toolbarStrings = new string[] { "USB", "SVO", "Stream" };
+    private string pauseText = "Pause";
+    private string pauseTooltip = " SVO playback or recording."; //Appended to the pause Text to make tooltip text.
+    private string[] filters = { "Svo files", "svo" }; //Filters used for browsing for an SVO.
+
+    private void OnEnable()
+    {
+        manager = (ZEDManager)target;
+
+        ////////////////////////////////////////////////// FoldOut
+        showadvanced = serializedObject.FindProperty("advancedPanelOpen");
+        showSpatialMapping = serializedObject.FindProperty("spatialMappingFoldoutOpen");
+        showcamcontrol = serializedObject.FindProperty("camControlFoldoutOpen");
+        showRecording = serializedObject.FindProperty("recordingFoldoutOpen");
+        showStreamingOut = serializedObject.FindProperty("streamingOutFoldoutOpen");
+        showObjectDetection = serializedObject.FindProperty("objectDetectionFoldoutOpen");
+
+
+
+        resolution = manager.resolution;
+        depthmode = manager.depthMode;
+        usespatialmemory = manager.enableSpatialMemory;
+
+        //Input Serialized Properties
+        cameraIDProperty = serializedObject.FindProperty("cameraID");
+        depthModeProperty = serializedObject.FindProperty("depthMode");
+        inputTypeProperty = serializedObject.FindProperty("inputType");
+        usbResolutionProperty = serializedObject.FindProperty("resolution");
+        usbFPSProperty = serializedObject.FindProperty("FPS");
+        svoFileNameProperty = serializedObject.FindProperty("svoInputFileName");
+        svoLoopProperty = serializedObject.FindProperty("svoLoopBack");
+        svoRealTimeModeProperty = serializedObject.FindProperty("svoRealTimeMode");
+        streamIPProperty = serializedObject.FindProperty("streamInputIP");
+        streamPortProperty = serializedObject.FindProperty("streamInputPort");
+        pauseSVOProperty = serializedObject.FindProperty("pauseSVOReading");
+        currentFrameSVOProperty = serializedObject.FindProperty("currentFrame");
+        maxFrameSVOProperty = serializedObject.FindProperty("numberFrameMax");
+
+#if ZED_HDRP
+        //SRP Lighting Serialized Property
+        srpShaderTypeProperty = serializedObject.FindProperty("srpShaderType");
+        selfIlluminationProperty = serializedObject.FindProperty("selfIllumination");
+        applyZEDNormalsProperty = serializedObject.FindProperty("applyZEDNormals");
+#endif
+
+        //Tracking Serialized Properties
+        enableTrackingProperty = serializedObject.FindProperty("enableTracking");
+        enableSMProperty = serializedObject.FindProperty("enableSpatialMemory");
+        pathSMProperty = serializedObject.FindProperty("pathSpatialMemory");
+        estimateIPProperty = serializedObject.FindProperty("estimateInitialPosition");
+        trackingIsStaticProperty = serializedObject.FindProperty("trackingIsStatic");
+
+
+        ///Rendering Serialized Properties
+        depthOcclusionProperty = serializedObject.FindProperty("depthOcclusion");
+        arpostProcessingPropery = serializedObject.FindProperty("postProcessing");
+        camBrightnessProperty = serializedObject.FindProperty("m_cameraBrightness");
+
+        ///Spatial Mapping Serialized Properties
+        range = serializedObject.FindProperty("mappingRangePreset");
+        mappingResolution = serializedObject.FindProperty("mappingResolutionPreset");
+        isFilteringEnable = serializedObject.FindProperty("isMappingFilteringEnable");
+        filterParameters = serializedObject.FindProperty("meshFilterParameters");
+        isTextured = serializedObject.FindProperty("isMappingTextured");
+        saveWhenOver = serializedObject.FindProperty("saveMeshWhenOver");
+        meshPath = serializedObject.FindProperty("meshPath");
+
+        ///Object Detection Serialized Properties
+        OD_ImageSyncMode = serializedObject.FindProperty("objectDetectionImageSyncMode");
+        OD_ObjectTracking = serializedObject.FindProperty("objectDetectionTracking");
+        OD_BodyFitting = serializedObject.FindProperty("objectDetectionBodyFitting");
+        OD_2DMask = serializedObject.FindProperty("objectDetection2DMask");
+        OD_DetectionModel = serializedObject.FindProperty("objectDetectionModel");
+        OD_MaxRange = serializedObject.FindProperty("objectDetectionMaxRange");
+        OD_FilteringMode = serializedObject.FindProperty("objectDetectionFilteringMode");
+
+        OD_PersonDetectionConfidence = serializedObject.FindProperty("OD_personDetectionConfidenceThreshold");
+        SK_PersonDetectionConfidence = serializedObject.FindProperty("SK_personDetectionConfidenceThreshold");
+        OD_VehicleDetectionConfidence = serializedObject.FindProperty("vehicleDetectionConfidenceThreshold");
+        OD_BagDetectionConfidence = serializedObject.FindProperty("bagDetectionConfidenceThreshold");
+        OD_AnimalDetectionConfidence = serializedObject.FindProperty("animalDetectionConfidenceThreshold");
+        OD_ElectronicsDetectionConfidence = serializedObject.FindProperty("electronicsDetectionConfidenceThreshold");
+        OD_FruitVegetableDetectionConfidence = serializedObject.FindProperty("fruitVegetableDetectionConfidenceThreshold");
+        OD_SportDetectionConfidence = serializedObject.FindProperty("sportDetectionConfidenceThreshold");
+        OD_PersonFilter = serializedObject.FindProperty("objectClassPersonFilter");
+        OD_VehicleFilter = serializedObject.FindProperty("objectClassVehicleFilter");
+        OD_BagFilter = serializedObject.FindProperty("objectClassBagFilter");
+        OD_AnimalFilter = serializedObject.FindProperty("objectClassAnimalFilter");
+        OD_ElectronicsFilter = serializedObject.FindProperty("objectClassElectronicsFilter");
+        OD_FruitVegetableFilter = serializedObject.FindProperty("objectClassFruitVegetableFilter");
+        OD_SportFilter = serializedObject.FindProperty("objectClassSportFilter");
+
+        //Recording Serialized Properties
+        svoOutputFileNameProperty = serializedObject.FindProperty("svoOutputFileName");
+        svoOutputCompressionModeProperty = serializedObject.FindProperty("svoOutputCompressionMode");
+        svoOutputBitrateProperty = serializedObject.FindProperty("svoOutputBitrate");
+        svoOutputTargetFPSProperty = serializedObject.FindProperty("svoOutputTargetFPS");
+        svoOutputTranscodeProperty = serializedObject.FindProperty("svoOutputTranscodeStreaming");
+
+
+        streamingOutProperty = serializedObject.FindProperty("enableStreaming");
+        streamingOutCodecProperty = serializedObject.FindProperty("streamingCodec");
+        streamingOutPortProperty = serializedObject.FindProperty("streamingPort");
+        streamingOutBitrateProperty = serializedObject.FindProperty("bitrate");
+        streamingOutGopSizeProperty = serializedObject.FindProperty("gopSize");
+        streamingOutAdaptBitrateProperty = serializedObject.FindProperty("adaptativeBitrate");
+        streamingOutChunkSizeProperty = serializedObject.FindProperty("chunkSize");
+        streamingOutTargetFPSProperty = serializedObject.FindProperty("streamingTargetFramerate");
+
+
+
+        ///Advanced Settings Serialized Properties
+        arlayer = ZEDLayers.arlayer;
+        showarrig = serializedObject.FindProperty("showarrig");
+        fadeinonstart = serializedObject.FindProperty("fadeInOnStart");
+        greyskybox = serializedObject.FindProperty("greySkybox");
+        dontdestroyonload = serializedObject.FindProperty("dontDestroyOnLoad");
+        showarrig = serializedObject.FindProperty("showarrig");
+        sensingModeProperty = serializedObject.FindProperty("sensingMode");
+        rightDepthProperty = serializedObject.FindProperty("enableRightDepthMeasure");
+        maxDepthProperty = serializedObject.FindProperty("m_maxDepthRange");
+        confidenceThresholdProperty = serializedObject.FindProperty("m_confidenceThreshold");
+        textureConfidenceThresholdProperty = serializedObject.FindProperty("m_textureConfidenceThreshold");
+        enableSelfCalibrationProperty = serializedObject.FindProperty("enableSelfCalibration");
+        enableIMUFusionProperty = serializedObject.FindProperty("enableIMUFusion");
+        allowPassThroughProperty = serializedObject.FindProperty("allowARPassThrough");
+        setIMUPrior = serializedObject.FindProperty("setIMUPriorInAR");
+        enableImageEnhancementProperty = serializedObject.FindProperty("enableImageEnhancement");
+        opencvCalibFilePath = serializedObject.FindProperty("opencvCalibFile");
+
+        //Video Settings Serialized Properties
+        videoSettingsInitModeProperty = serializedObject.FindProperty("videoSettingsInitMode");
+
+        brightnessProperty = serializedObject.FindProperty("videoBrightness"); ;
+        contrastProperty = serializedObject.FindProperty("videoContrast"); ;
+        hueProperty = serializedObject.FindProperty("videoHue"); ;
+        saturationProperty = serializedObject.FindProperty("videoSaturation"); ;
+        autoGainExposureProperty = serializedObject.FindProperty("videoAutoGainExposure"); ;
+        gainProperty = serializedObject.FindProperty("videoGain"); ;
+        exposureProperty = serializedObject.FindProperty("videoExposure"); ;
+        autoWhiteBalanceProperty = serializedObject.FindProperty("videoAutoWhiteBalance"); ;
+        whitebalanceProperty = serializedObject.FindProperty("videoWhiteBalance"); ;
+        sharpnessProperty = serializedObject.FindProperty("videoSharpness");
+        gammaProperty = serializedObject.FindProperty("videoGamma");
+        ledStatus = serializedObject.FindProperty("videoLEDStatus"); ;
+    }
+
+    public override void OnInspectorGUI()
+    {
+        GUIStyle boldfoldout = new GUIStyle(EditorStyles.foldout);
+        boldfoldout.fontStyle = FontStyle.Bold;
+        //DrawDefaultInspector(); //Draws what you'd normally see in the inspector in absence of a custom inspector.
+
+        EditorGUIUtility.labelWidth = EditorGUIUtility.currentViewWidth * 0.4f;
+        ///////////////////////////////////////////////////////////////
+        ///  Inputlayout  /////////////////////////////////
+        /////////////////////////////////////////////////////////////
+        GUILayout.Space(10);
+        EditorGUILayout.LabelField("Input", EditorStyles.boldLabel);
+        GUILayout.Space(5);
+        EditorGUI.indentLevel++;
+        GUIContent cameraIDLabel = new GUIContent("Camera ID", "Which ZED camera to connect to. Used when multiple ZED cameras are connected to this device.");
+        cameraIDProperty.enumValueIndex = (int)(sl.ZED_CAMERA_ID)EditorGUILayout.EnumPopup(cameraIDLabel, (sl.ZED_CAMERA_ID)cameraIDProperty.enumValueIndex);
+
+        GUIContent cameraDepthModeLabel = new GUIContent("Depth Mode", "Camera depth mode. Higher values increase quality at the cost of performance.");
+        depthModeProperty.enumValueIndex = (int)(sl.DEPTH_MODE)EditorGUILayout.EnumPopup(cameraDepthModeLabel, (sl.DEPTH_MODE)depthModeProperty.enumValueIndex);
+        GUILayout.Space(15);
+        EditorGUILayout.BeginHorizontal();
+        GUIContent inputTypeLabel = new GUIContent("Input Type", "Where the ZED video feed comes from.\r\n\n" +
+            "- USB: A live ZED camera connected to this device.\r\n\n- SVO: A video file recorded from a ZED previously.\r\n\n" +
+            "- Stream: A live ZED camera connected to a device elsewhere on the network.");
+        EditorGUILayout.LabelField(inputTypeLabel, GUILayout.Width(EditorGUIUtility.labelWidth));
+        GUI.enabled = !Application.isPlaying;
+        inputTypeProperty.intValue = GUILayout.Toolbar(inputTypeProperty.intValue, toolbarStrings, GUILayout.ExpandWidth(true));
+        GUI.enabled = true;
+        EditorGUILayout.EndHorizontal();
+        GUILayout.Space(5);
+        switch (inputTypeProperty.intValue)
+        {
+            case 0:
+                GUIContent cameraResolutionLabel = new GUIContent("Resolution", "Camera resolution.");
+                //GUI.enabled = !Application.isPlaying;
+                usbResolutionProperty.enumValueIndex = (int)(sl.RESOLUTION)EditorGUILayout.EnumPopup(cameraResolutionLabel, (sl.RESOLUTION)usbResolutionProperty.enumValueIndex);
+                //GUI.enabled = true;
+                GUIContent cameraFPSLabel = new GUIContent("FPS", "Desired camera FPS. Maximum FPS depends on your resolution setting:\r\n\n" +
+                    "- HD2k: 15FPS\r\n\n- HD1080: 30FPS\r\n\n- HD720p: 60FPS\r\n\n- VGA: 100FPS");
+                GUI.enabled = !Application.isPlaying;
+                usbFPSProperty.intValue = EditorGUILayout.IntField(cameraFPSLabel, usbFPSProperty.intValue);
+                GUI.enabled = true;
+                serializedObject.ApplyModifiedProperties();
+
+                //Check if we need to restart the camera, and create a button for the user to do so.
+                if (Application.isPlaying && manager.IsZEDReady && CheckChange())
+                {
+                    GUILayout.Space(10);
+                    GUIStyle orangetext = new GUIStyle(EditorStyles.label);
+                    orangetext.normal.textColor = Color.red;
+                    orangetext.wordWrap = true;
+                    string labeltext = "Settings have changed that require restarting the camera to apply.";
+                    Rect labelrect = GUILayoutUtility.GetRect(new GUIContent(labeltext, ""), orangetext);
+                    EditorGUI.LabelField(labelrect, labeltext, orangetext);
+
+                    if (GUILayout.Button("Restart Camera"))
+                    {
+                        manager.Reset(); //Reset the ZED.
+
+                        //Reset the fields now that they're synced.
+                        resolution = manager.resolution;
+                        depthmode = manager.depthMode;
+
+                    }
+                }
+
+                break;
+
+            case 1:
+                EditorGUILayout.BeginHorizontal();
+                GUIContent svoFileNameLabel = new GUIContent("SVO File", "SVO file name");
+                GUI.enabled = !Application.isPlaying;
+                svoFileNameProperty.stringValue = EditorGUILayout.TextField(svoFileNameLabel, svoFileNameProperty.stringValue);
+                GUIContent loadSVOlabel = new GUIContent("...", "Browse for existing SVO file.");
+                if (GUILayout.Button(loadSVOlabel, optionsButtonBrowse))
+                {
+                    svoFileNameProperty.stringValue = EditorUtility.OpenFilePanelWithFilters("Load SVO", "", filters);
+                }
+                GUI.enabled = true;
+                EditorGUILayout.EndHorizontal();
+                GUIContent svoLoopLabel = new GUIContent("Loop SVO", "Loop SVO when it reaches the end.");
+                svoLoopProperty.boolValue = EditorGUILayout.Toggle(svoLoopLabel, svoLoopProperty.boolValue);
+                GUIContent svoRealTimeModelabel = new GUIContent("Real-Time Mode", "When enabled, the time between frames comes from the actual timestamps of each frame. Otherwise, " +
+                    "each frame is read based on the maximum FPS of the recorded resolution (ex. 30FPS for HD1080). Real-Time mode makes playback speed more true, but dropped frames result in pauses.");
+                svoRealTimeModeProperty.boolValue = EditorGUILayout.Toggle(svoRealTimeModelabel, svoRealTimeModeProperty.boolValue);
+                EditorGUI.BeginChangeCheck();
+
+                GUI.enabled = (manager.NumberFrameMax > 0);
+                GUIContent sliderlabel = new GUIContent("Frame ", "SVO playback position");
+                currentFrameSVOProperty.intValue = EditorGUILayout.IntSlider(sliderlabel, currentFrameSVOProperty.intValue, 0, maxFrameSVOProperty.intValue);
+                if (EditorGUI.EndChangeCheck())
+                {
+                    if (manager.zedCamera != null)
+                    {
+                        //If the slider of frame from the SVO has moved, manually grab the frame and update the textures.
+                        manager.zedCamera.SetSVOPosition(currentFrameSVOProperty.intValue);
+                        if (pauseSVOProperty.boolValue)
+                        {
+                            manager.NeedNewFrameGrab = true;
+                        }
+                    }
+                }
+                GUI.enabled = false;
+
+                if (manager.zedCamera != null)
+                    GUI.enabled = manager.zedCamera.IsCameraReady;
+
+                EditorGUILayout.BeginHorizontal();
+                GUILayout.Space(EditorGUIUtility.labelWidth);
+                pauseText = pauseSVOProperty.boolValue ? "Resume" : "Pause";
+                GUIContent pauselabel = new GUIContent(pauseText, pauseText + pauseTooltip);
+                if (GUILayout.Button(pauselabel))
+                {
+                    pauseSVOProperty.boolValue = !pauseSVOProperty.boolValue;
+                }
+                EditorGUILayout.EndHorizontal();
+                GUI.enabled = true;
+                serializedObject.ApplyModifiedProperties();
+                break;
+
+            case 2:
+                GUIContent streamIPLabel = new GUIContent("IP", "IP of the host device with the ZED attached.");
+                GUI.enabled = !Application.isPlaying;
+                streamIPProperty.stringValue = EditorGUILayout.TextField(streamIPLabel, streamIPProperty.stringValue);
+                GUI.enabled = true;
+                GUIContent streamPortLabel = new GUIContent("Port", "Port where the ZED stream is sent to.");
+                GUI.enabled = !Application.isPlaying;
+                streamPortProperty.intValue = EditorGUILayout.IntField(streamPortLabel, streamPortProperty.intValue);
+                GUI.enabled = true;
+                serializedObject.ApplyModifiedProperties();
+                break;
+        }
+
+        EditorGUI.indentLevel--;
+
+#if ZED_HDRP
+        ///////////////////////////////////////////////////////////////
+        ///  HDRP Lighting layout  /////////////////////////////////
+        /////////////////////////////////////////////////////////////
+        GUILayout.Space(10);
+        EditorGUILayout.LabelField("SRP Lighting", EditorStyles.boldLabel);
+        GUILayout.Space(5);
+        EditorGUI.indentLevel++;
+
+        GUIContent shaderTypeLabel = new GUIContent("Lighting Type", "Defines the type of shader (lit or unlit) that's applied to the canvas object(s) used to display the ZED image. " +
+            "Lit takes into account scene lighting - it is the most realistic but harder to configure. Unlit makes the ZED image evenly lit, but lacks lighting/shadow effects.");
+        string[] shaderoptions = new string[5] { "Lit", "Unlit", "Lit Greenscreen", "Unlit Greenscreen", "Don't Change"};
+
+        GUI.enabled = !Application.isPlaying;
+        srpShaderTypeProperty.enumValueIndex = EditorGUILayout.Popup(shaderTypeLabel, srpShaderTypeProperty.enumValueIndex, shaderoptions);
+        GUI.enabled = true;
+
+        if (srpShaderTypeProperty.enumValueIndex == 2 || srpShaderTypeProperty.enumValueIndex == 3)
+        {
+            GUIStyle greenscreennotestyle = new GUIStyle();
+            greenscreennotestyle.normal.textColor = new Color(.7f, .7f, .7f);
+            greenscreennotestyle.wordWrap = true;
+            greenscreennotestyle.fontSize = 10;
+            greenscreennotestyle.fixedWidth = 0;
+            greenscreennotestyle.stretchWidth = false;
+            greenscreennotestyle.alignment = TextAnchor.MiddleLeft;
+            greenscreennotestyle.fontStyle = FontStyle.Italic;
+
+            GUILayout.Space(2);
+            EditorGUI.indentLevel++;
+
+            string greenscreennote = "Requires GreenScreenManager component on the ZED rig's Camera objects.";
+            Rect gsrect = GUILayoutUtility.GetRect(new GUIContent(greenscreennote, ""), greenscreennotestyle);
+            EditorGUI.LabelField(gsrect, greenscreennote, greenscreennotestyle);
+
+            GUILayout.Space(8);
+            EditorGUI.indentLevel--;
+        }
+
+        if (srpShaderTypeProperty.enumValueIndex == 0 || srpShaderTypeProperty.enumValueIndex == 2)
+        {
+            GUIContent selfIlluminationLabel = new GUIContent("Self-Illumination", "How much the ZED image should light itself via emission. " +
+                "Setting to zero is most realistic, but requires you to emulate the real-world lighting conditions within Unity. Higher settings cause the image " +
+                "to be uniformly lit, but light and shadow effects are less visible.");
+            selfIlluminationProperty.floatValue = EditorGUILayout.Slider(selfIlluminationLabel, selfIlluminationProperty.floatValue, 0, 1);
+
+            GUIContent applyZEDNormalsLabel = new GUIContent("ZED Normals", "Apply normals map from the ZED SDK. Causes lighting to be calculated based "
+                + "on the real-world angle of the geometry, instead of treating the ZED image like a plane. However, the normals map is imperfect and can lead to noise.");
+            applyZEDNormalsProperty.boolValue = EditorGUILayout.Toggle(applyZEDNormalsLabel, applyZEDNormalsProperty.boolValue);
+
+        }
+
+        EditorGUI.indentLevel--;
+#endif
+
+        ///////////////////////////////////////////////////////////////
+        ///  Motion Tracking layout  /////////////////////////////////
+        /////////////////////////////////////////////////////////////
+        GUILayout.Space(10);
+        EditorGUILayout.LabelField("Motion Tracking", EditorStyles.boldLabel);
+        GUILayout.Space(5);
+        EditorGUI.indentLevel++;
+        GUIContent enableTrackingLabel = new GUIContent("Enable Tracking", "If enabled, the ZED will move/rotate itself using its own inside-out tracking. " +
+        "If false, the camera tracking will move with the VR HMD if connected and available.");
+        enableTrackingProperty.boolValue = EditorGUILayout.Toggle(enableTrackingLabel, enableTrackingProperty.boolValue);
+
+        GUIContent enableSMPropertyLabel = new GUIContent("Enable Spatial Memory", "Enables the spatial memory. Will detect and correct tracking drift by remembering features and anchors in the environment, "
+        + "but may cause visible jumps when it happens");
+        enableSMProperty.boolValue = EditorGUILayout.Toggle(enableSMPropertyLabel, enableSMProperty.boolValue);
+
+        GUIContent pathSMlabel = new GUIContent("Path Spatial Memory", "If using Spatial Memory, you can specify a path to an existing .area file to start with some memory already loaded. " +
+        ".area files are created by scanning a scene with ZEDSpatialMappingManager and saving the scan.");
+        pathSMProperty.stringValue = EditorGUILayout.TextField(pathSMlabel, pathSMProperty.stringValue);
+
+        GUIContent estimateIPPropertyLabel = new GUIContent("Estimate Initial Position", "Estimate initial position by detecting the floor. Leave it false if using VR Headset");
+        estimateIPProperty.boolValue = EditorGUILayout.Toggle(estimateIPPropertyLabel, estimateIPProperty.boolValue);
+
+        GUIContent trackingIsStaticPropertyLabel = new GUIContent("Tracking Is Static", "If true, tracking is enabled but doesn't move after initializing. " +
+            "Can be useful for stationary cameras where you still need tracking enabled, such as in Object Detection.");
+        trackingIsStaticProperty.boolValue = EditorGUILayout.Toggle(trackingIsStaticPropertyLabel, trackingIsStaticProperty.boolValue);
+
+
+        EditorGUI.indentLevel--;
+
+        ///////////////////////////////////////////////////////////////
+        ///  Rendering layout  /////////////////////////////////
+        /////////////////////////////////////////////////////////////
+        GUILayout.Space(10);
+        EditorGUILayout.LabelField("Rendering", EditorStyles.boldLabel);
+        GUILayout.Space(5);
+        EditorGUI.indentLevel++;
+        GUIContent depthOcclusionPropertyLabel = new GUIContent("Depth Occlusion", "When enabled, the real world can occlude (cover up) virtual objects that are behind it. " +
+        "Otherwise, virtual objects will appear in front.");
+        depthOcclusionProperty.boolValue = EditorGUILayout.Toggle(depthOcclusionPropertyLabel, depthOcclusionProperty.boolValue);
+
+        GUIContent arpostProcessingProperyLabel = new GUIContent("AR Post-Processing", "Enables post-processing effects on virtual objects that blends them in with the real world.");
+        arpostProcessingPropery.boolValue = EditorGUILayout.Toggle(arpostProcessingProperyLabel, arpostProcessingPropery.boolValue);
+
+        GUIContent camBrightnessPropertyLabel = new GUIContent("Camera Brightness", "Brightness of the final real-world image. Default is 100. Lower to darken the environment in a realistic-looking way. " +
+        "This is a rendering setting that doesn't affect the raw input from the camera.");
+        camBrightnessProperty.intValue = EditorGUILayout.IntSlider(camBrightnessPropertyLabel, camBrightnessProperty.intValue, 0, 100);
+        EditorGUI.indentLevel--;
+
+        ///////////////////////////////////////////////////////////////
+        ///  Spatial Mapping layout  /////////////////////////////////
+        /////////////////////////////////////////////////////////////
+        GUILayout.Space(10);
+        showSpatialMapping.boolValue = EditorGUILayout.Foldout(showSpatialMapping.boolValue, "Spatial Mapping", boldfoldout);
+        if (showSpatialMapping.boolValue)
+        {
+            EditorGUI.indentLevel++;
+            bool cameraIsReady = false;
+
+            if (manager)
+                cameraIsReady = manager.zedCamera != null ? manager.zedCamera.IsCameraReady : false;
+
+            displayText = manager.IsSpatialMappingDisplay ? "Hide Mesh" : "Display Mesh";
+
+            EditorGUILayout.BeginHorizontal();
+
+            GUILayout.Space(5);
+
+            EditorGUILayout.EndHorizontal();
+
+
+            GUIContent resolutionlabel = new GUIContent("Resolution", "Resolution setting for the scan. " +
+                                         "A higher resolution creates more submeshes and uses more memory, but is more accurate.");
+            ZEDSpatialMapping.RESOLUTION newResolution = (ZEDSpatialMapping.RESOLUTION)EditorGUILayout.EnumPopup(resolutionlabel, manager.mappingResolutionPreset);
+            if (newResolution != manager.mappingResolutionPreset)
+            {
+                mappingResolution.enumValueIndex = (int)newResolution;
+                serializedObject.ApplyModifiedProperties();
+            }
+
+            GUIContent rangelabel = new GUIContent("Range", "Maximum distance geometry can be from the camera to be scanned. " +
+                                    "Geometry scanned from farther away will be less accurate.");
+            ZEDSpatialMapping.RANGE newRange = (ZEDSpatialMapping.RANGE)EditorGUILayout.EnumPopup(rangelabel, manager.mappingRangePreset);
+            if (newRange != manager.mappingRangePreset)
+            {
+                range.enumValueIndex = (int)newRange;
+                serializedObject.ApplyModifiedProperties();
+            }
+
+            EditorGUILayout.BeginHorizontal();
+            GUIContent filteringlabel = new GUIContent("Mesh Filtering", "Whether mesh filtering is needed.");
+            filterParameters.enumValueIndex = (int)(sl.FILTER)EditorGUILayout.EnumPopup(filteringlabel, (sl.FILTER)filterParameters.enumValueIndex);
+            isFilteringEnable.boolValue = true;
+
+
+            EditorGUILayout.EndHorizontal();
+
+            GUI.enabled = !manager.IsMappingRunning; //Don't allow changing the texturing setting while the scan is running.
+
+            GUIContent texturedlabel = new GUIContent("Texturing", "Whether surface textures will be scanned and applied. " +
+                                       "Note that texturing will add further delay to the post-scan finalizing period.");
+            isTextured.boolValue = EditorGUILayout.Toggle(texturedlabel, isTextured.boolValue);
+
+            GUI.enabled = cameraIsReady; //Gray out below elements if the ZED hasn't been initialized as you can't yet start a scan.
+
+            EditorGUILayout.BeginHorizontal();
+            GUILayout.Space(EditorGUIUtility.labelWidth);
+            if (!manager.IsMappingRunning)
+            {
+                GUIContent startmappinglabel = new GUIContent("Start Spatial Mapping", "Begin the spatial mapping process.");
+                if (GUILayout.Button(startmappinglabel))
+                {
+                    if (!manager.IsSpatialMappingDisplay)
+                    {
+                        manager.SwitchDisplayMeshState(true);
+                    }
+                    manager.StartSpatialMapping();
+                }
+            }
+            else
+            {
+                if (manager.IsMappingRunning && !manager.IsMappingUpdateThreadRunning || manager.IsMappingRunning && manager.IsMappingTexturingRunning)
+                {
+                    GUILayout.FlexibleSpace();
+                    GUIContent finishinglabel = new GUIContent("Spatial mapping is finishing", "Please wait - the mesh is being processed.");
+                    GUILayout.Label(finishinglabel);
+                    Repaint();
+                    GUILayout.FlexibleSpace();
+                }
+                else
+                {
+                    GUIContent stopmappinglabel = new GUIContent("Stop Spatial Mapping", "Ends spatial mapping and begins processing the final mesh.");
+                    if (GUILayout.Button(stopmappinglabel))
+                    {
+                        manager.StopSpatialMapping();
+                    }
+                }
+            }
+
+            EditorGUILayout.EndHorizontal();
+
+            EditorGUILayout.BeginHorizontal();
+            GUI.enabled = cameraIsReady;
+            string displaytooltip = manager.IsSpatialMappingDisplay ? "Hide the mesh from view." : "Display the hidden mesh.";
+            GUILayout.Space(EditorGUIUtility.labelWidth);
+            GUIContent displaylabel = new GUIContent(displayText, displaytooltip);
+            if (GUILayout.Button(displayText))
+            {
+                manager.SwitchDisplayMeshState(!manager.IsSpatialMappingDisplay);
+            }
+            EditorGUILayout.EndHorizontal();
+
+            EditorGUILayout.BeginHorizontal();
+            GUIContent clearMesheslabel = new GUIContent("Clear All Meshes", "Clear all meshes created with the ZED");
+            GUILayout.Space(EditorGUIUtility.labelWidth);
+            if (GUILayout.Button(clearMesheslabel))
+            {
+                manager.ClearAllMeshes();
+            }
+            EditorGUILayout.EndHorizontal();
+            GUI.enabled = true;
+
+            GUILayout.Space(5);
+            EditorGUILayout.LabelField("Storage", EditorStyles.boldLabel);
+
+            GUIContent savelabel = new GUIContent("Save Mesh (when finished)", "Whether to save the mesh and .area file when finished scanning.");
+            saveWhenOver.boolValue = EditorGUILayout.Toggle(savelabel, saveWhenOver.boolValue);
+
+
+            EditorGUILayout.BeginHorizontal();
+
+            GUIContent pathlabel = new GUIContent("Mesh Path", "Path where the mesh is saved/loaded from. Valid file types are .obj, .ply and .bin.");
+            meshPath.stringValue = EditorGUILayout.TextField(pathlabel, meshPath.stringValue);
+
+            GUIContent findfilelabel = new GUIContent("...", "Browse for an existing .obj, .ply or .bin file.");
+            if (GUILayout.Button(findfilelabel, optionsButtonBrowse))
+            {
+                meshPath.stringValue = EditorUtility.OpenFilePanel("Mesh file", "", "ply,obj,bin");
+                serializedObject.ApplyModifiedProperties();
+            }
+
+            EditorGUILayout.EndHorizontal();
+            EditorGUILayout.BeginHorizontal();
+
+            GUILayout.FlexibleSpace();
+
+            GUI.enabled = System.IO.File.Exists(meshPath.stringValue) && cameraIsReady;
+            GUIContent loadlabel = new GUIContent("Load", "Load an existing mesh and .area file into the scene.");
+            if (GUILayout.Button(loadlabel))
+            {
+                manager.LoadMesh(meshPath.stringValue);
+            }
+
+            EditorGUILayout.EndHorizontal();
+            GUI.enabled = true;
+            EditorGUI.indentLevel--;
+
+        }
+        serializedObject.ApplyModifiedProperties();
+
+
+        ///////////////////////////////////////////////////////////////
+        ///  Object Detection layout  /////////////////////////////////
+        /////////////////////////////////////////////////////////////
+        GUILayout.Space(10);
+
+        showObjectDetection.boolValue = EditorGUILayout.Foldout(showObjectDetection.boolValue, "Object Detection / Body Tracking", boldfoldout);
+        if (showObjectDetection.boolValue)
+        {
+            bool cameraIsReady = false;
+            if (manager)
+                cameraIsReady = manager.zedCamera != null ? manager.zedCamera.IsCameraReady : false;
+
+            GUILayout.Space(10);
+            EditorGUILayout.LabelField("Detection Mode", EditorStyles.boldLabel);
+            GUILayout.Space(5);
+
+            EditorGUI.indentLevel++;
+
+            GUIContent ObjectDetectionModelLabel = new GUIContent("Object Detection Model", "Select the available object detection model. HUMAN_XXX for skeleton tracking");
+            OD_DetectionModel.enumValueIndex = (int)(sl.DETECTION_MODEL)EditorGUILayout.EnumPopup(ObjectDetectionModelLabel, (sl.DETECTION_MODEL)OD_DetectionModel.enumValueIndex);
+
+            EditorGUI.indentLevel--;
+
+            GUILayout.Space(10);
+            EditorGUILayout.LabelField("Init Parameters", EditorStyles.boldLabel);
+            GUILayout.Space(5);
+
+            EditorGUI.indentLevel++;
+
+            GUI.enabled = !cameraIsReady || !manager.IsObjectDetectionRunning;
+
+            GUIContent ImageSyncModeLabel = new GUIContent("Image Sync", "If enabled, object detection will be computed for each image before the next frame is available, " +
+                "locking the main thread if necessary.\r\n\nRecommended setting is false for real-time applications.");
+            OD_ImageSyncMode.boolValue = EditorGUILayout.Toggle(ImageSyncModeLabel, OD_ImageSyncMode.boolValue);
+
+            GUIContent ObjectTrackingLabel = new GUIContent("Enable Object Tracking", "Whether to track objects across multiple frames using the ZED's position relative to the floor.\r\n\n" +
+                "Requires tracking to be on. It's also recommended to enable Estimate Initial Position to find the floor.");
+            OD_ObjectTracking.boolValue = EditorGUILayout.Toggle(ObjectTrackingLabel, OD_ObjectTracking.boolValue);
+
+            if (OD_DetectionModel.enumValueIndex == (int)sl.DETECTION_MODEL.MULTI_CLASS_BOX || OD_DetectionModel.enumValueIndex == (int)sl.DETECTION_MODEL.MULTI_CLASS_BOX_MEDIUM || OD_DetectionModel.enumValueIndex == (int)sl.DETECTION_MODEL.MULTI_CLASS_BOX_ACCURATE ||
+                OD_DetectionModel.enumValueIndex == (int)sl.DETECTION_MODEL.CUSTOM_BOX_OBJECTS || OD_DetectionModel.enumValueIndex == (int)sl.DETECTION_MODEL.PERSON_HEAD_BOX)
+            {
+                GUIContent Object2DMaskLabel = new GUIContent("Enable 2D Mask", "Whether to calculate 2D masks for each object, showing exactly which pixels within the 2D bounding box are the object.\r\n\n" +
+                "Must be on when Object Detection starts. Requires more performance, so do not enable unless needed.");
+                OD_2DMask.boolValue = EditorGUILayout.Toggle(Object2DMaskLabel, OD_2DMask.boolValue);
+            }
+            else
+            {
+                GUIContent BodyFittingLabel = new GUIContent("Enable Body Fitting", "Defines if the body fitting will be applied.\r\n\n" +
+                "Requires tracking to be on. It's also recommended to enable Estimate Initial Position to find the floor.");
+                OD_BodyFitting.boolValue = EditorGUILayout.Toggle(BodyFittingLabel, OD_BodyFitting.boolValue);
+            }
+
+            GUIContent MaxRangeLabel = new GUIContent("Max Range", "Defines a upper depth range for detections.");
+            OD_MaxRange.floatValue = EditorGUILayout.Slider(MaxRangeLabel, OD_MaxRange.floatValue, 0, 40.0f);
+
+            GUIContent FilteringModeLabel = new GUIContent("Filtering Mode", "Defines the bounding box preprocessor used.");
+            OD_FilteringMode.enumValueIndex = (int)(sl.OBJECT_FILTERING_MODE)EditorGUILayout.EnumPopup(FilteringModeLabel, (sl.OBJECT_FILTERING_MODE)OD_FilteringMode.enumValueIndex);
+
+            GUI.enabled = true;
+
+            EditorGUI.indentLevel--;
+            GUILayout.Space(10);
+
+
+            if (OD_DetectionModel.enumValueIndex == (int)sl.DETECTION_MODEL.MULTI_CLASS_BOX || OD_DetectionModel.enumValueIndex == (int)sl.DETECTION_MODEL.MULTI_CLASS_BOX_MEDIUM || OD_DetectionModel.enumValueIndex == (int)sl.DETECTION_MODEL.MULTI_CLASS_BOX_ACCURATE)
+            {
+
+                EditorGUILayout.LabelField("Runtime Parameters", EditorStyles.boldLabel);
+                GUILayout.Space(5);
+                EditorGUI.indentLevel++;
+
+                GUIContent OD_personDetectionConfidenceThresholdLabel = new GUIContent("Person Confidence Threshold", "Detection sensitivity.Represents how sure the SDK must be that " +
+                "an object exists to report it.\r\n\nEx: If the threshold is 80, then only objects where the SDK is 80% sure or greater will appear in the list of detected objects.");
+                OD_PersonDetectionConfidence.intValue = EditorGUILayout.IntSlider(OD_personDetectionConfidenceThresholdLabel, OD_PersonDetectionConfidence.intValue, 1, 99);
+
+                GUIContent vehicleDetectionConfidenceThresholdLabel = new GUIContent("Vehicle Confidence Threshold", "Detection sensitivity.Represents how sure the SDK must be that " +
+                "an object exists to report it.\r\n\nEx: If the threshold is 80, then only objects where the SDK is 80% sure or greater will appear in the list of detected objects.");
+                OD_VehicleDetectionConfidence.intValue = EditorGUILayout.IntSlider(vehicleDetectionConfidenceThresholdLabel, OD_VehicleDetectionConfidence.intValue, 1, 99);
+
+                GUIContent bagDetectionConfidenceThresholdLabel = new GUIContent("Bag Confidence Threshold", "Detection sensitivity.Represents how sure the SDK must be that " +
+                "an object exists to report it.\r\n\nEx: If the threshold is 80, then only objects where the SDK is 80% sure or greater will appear in the list of detected objects.");
+                OD_BagDetectionConfidence.intValue = EditorGUILayout.IntSlider(bagDetectionConfidenceThresholdLabel, OD_BagDetectionConfidence.intValue, 1, 99);
+
+                GUIContent animalDetectionConfidenceThresholdLabel = new GUIContent("Animal Confidence Threshold", "Detection sensitivity.Represents how sure the SDK must be that " +
+                "an object exists to report it.\r\n\nEx: If the threshold is 80, then only objects where the SDK is 80% sure or greater will appear in the list of detected objects.");
+                OD_AnimalDetectionConfidence.intValue = EditorGUILayout.IntSlider(animalDetectionConfidenceThresholdLabel, OD_AnimalDetectionConfidence.intValue, 1, 99);
+
+                GUIContent electronicsDetectionConfidenceThresholdLabel = new GUIContent("Electronics Confidence Threshold", "Detection sensitivity.Represents how sure the SDK must be that " +
+                "an object exists to report it.\r\n\nEx: If the threshold is 80, then only objects where the SDK is 80% sure or greater will appear in the list of detected objects.");
+                OD_ElectronicsDetectionConfidence.intValue = EditorGUILayout.IntSlider(electronicsDetectionConfidenceThresholdLabel, OD_ElectronicsDetectionConfidence.intValue, 1, 99);
+
+                GUIContent fruitVegetableDetectionConfidenceThresholdLabel = new GUIContent("Fruit and Vegetable Confidence Threshold", "Detection sensitivity.Represents how sure the SDK must be that " +
+                "an object exists to report it.\r\n\nEx: If the threshold is 80, then only objects where the SDK is 80% sure or greater will appear in the list of detected objects.");
+                OD_FruitVegetableDetectionConfidence.intValue = EditorGUILayout.IntSlider(fruitVegetableDetectionConfidenceThresholdLabel, OD_FruitVegetableDetectionConfidence.intValue, 1, 99);
+
+                GUIContent sportDetectionConfidenceThresholdLabel = new GUIContent("Sport Confidence Threshold", "Detection sensitivity.Represents how sure the SDK must be that " +
+                "an object exists to report it.\r\n\nEx: If the threshold is 80, then only objects where the SDK is 80% sure or greater will appear in the list of detected objects.");
+                OD_SportDetectionConfidence.intValue = EditorGUILayout.IntSlider(sportDetectionConfidenceThresholdLabel, OD_SportDetectionConfidence.intValue, 1, 99);
+
+                GUILayout.Space(5);
+
+                GUIContent PersonFilterLabel = new GUIContent("Person Filter", "Whether to detect people during object detection.");
+                OD_PersonFilter.boolValue = EditorGUILayout.Toggle(PersonFilterLabel, OD_PersonFilter.boolValue);
+
+                GUIContent VehicleFilterLabel = new GUIContent("Vehicle Filter", "Whether to detect vehicles during object detection.");
+                OD_VehicleFilter.boolValue = EditorGUILayout.Toggle(VehicleFilterLabel, OD_VehicleFilter.boolValue);
+
+                GUIContent BagFilterLabel = new GUIContent("Bag Filter", "Whether to detect bags during object detection.");
+                OD_BagFilter.boolValue = EditorGUILayout.Toggle(BagFilterLabel, OD_BagFilter.boolValue);
+
+                GUIContent AnimalFilterLabel = new GUIContent("Animal Filter", "Whether to detect animals during object detection.");
+                OD_AnimalFilter.boolValue = EditorGUILayout.Toggle(AnimalFilterLabel, OD_AnimalFilter.boolValue);
+
+                GUIContent ElectronicsFilterLabel = new GUIContent("Electronics Filter", "Whether to detect electronics devices during object detection.");
+                OD_ElectronicsFilter.boolValue = EditorGUILayout.Toggle(ElectronicsFilterLabel, OD_ElectronicsFilter.boolValue);
+
+                GUIContent FruitVegetableFilterLabel = new GUIContent("Fruit and Vegetable Filter", "Whether to detect fruits and vegetablesduring object detection.");
+                OD_FruitVegetableFilter.boolValue = EditorGUILayout.Toggle(FruitVegetableFilterLabel, OD_FruitVegetableFilter.boolValue);
+
+                GUIContent SportFilterLabel = new GUIContent("Sport Filter", "Whether to detect sport related objects during object detection.");
+                OD_SportFilter.boolValue = EditorGUILayout.Toggle(SportFilterLabel, OD_SportFilter.boolValue);
+
+                EditorGUI.indentLevel--;
+            }
+            else if (OD_DetectionModel.enumValueIndex == (int)sl.DETECTION_MODEL.PERSON_HEAD_BOX)
+            {
+
+                EditorGUILayout.LabelField("Runtime Parameters", EditorStyles.boldLabel);
+                GUILayout.Space(5);
+                EditorGUI.indentLevel++;
+
+                GUIContent OD_personDetectionConfidenceThresholdLabel = new GUIContent("Person head Confidence Threshold", "Detection sensitivity.Represents how sure the SDK must be that " +
+                "an object exists to report it.\r\n\nEx: If the threshold is 80, then only objects where the SDK is 80% sure or greater will appear in the list of detected objects.");
+                OD_PersonDetectionConfidence.intValue = EditorGUILayout.IntSlider(OD_personDetectionConfidenceThresholdLabel, OD_PersonDetectionConfidence.intValue, 1, 99);
+            }
+            else if (OD_DetectionModel.enumValueIndex == (int)sl.DETECTION_MODEL.CUSTOM_BOX_OBJECTS) { 
+            }
+            else //SKELETON
+            {
+                EditorGUILayout.LabelField("Runtime Parameters", EditorStyles.boldLabel);
+                GUILayout.Space(5);
+                EditorGUI.indentLevel++;
+
+                GUIContent SK_personDetectionConfidenceThresholdLabel = new GUIContent("Person Confidence Threshold", "Detection sensitivity.Represents how sure the SDK must be that " +
+                "an object exists to report it.\r\n\nEx: If the threshold is 80, then only objects where the SDK is 80% sure or greater will appear in the list of detected objects.");
+                SK_PersonDetectionConfidence.intValue = EditorGUILayout.IntSlider(SK_personDetectionConfidenceThresholdLabel, SK_PersonDetectionConfidence.intValue, 1, 99);
+            }
+
+            GUI.enabled = cameraIsReady;
+
+            GUILayout.Space(10);
+            if (!manager.IsObjectDetectionRunning)
+            {
+                GUIContent startODlabel = new GUIContent("Start Object Detection", "Begin the OD process.");
+                if (GUILayout.Button(startODlabel))
+                {
+                    manager.StartObjectDetection();
+                }
+            }
+            else
+            {
+                GUIContent stopODlabel = new GUIContent("Stop Object Detection", "Stop the OD process.");
+                if (GUILayout.Button(stopODlabel))
+                {
+                    manager.StopObjectDetection();
+                }
+            }
+
+            GUI.enabled = true;
+        }
+
+        ///////////////////////////////////////////////////////////////
+        ///     Recording layout     /////////////////////////////////
+        /////////////////////////////////////////////////////////////
+        GUILayout.Space(10);
+        showRecording.boolValue = EditorGUILayout.Foldout(showRecording.boolValue, "Recording", boldfoldout);
+        if (showRecording.boolValue)
+        {
+
+            EditorGUI.indentLevel++;
+            GUILayout.Space(5);
+            bool cameraIsReady = false;
+            if (manager)
+                cameraIsReady = manager.zedCamera != null ? manager.zedCamera.IsCameraReady : false;
+
+            GUIContent svoOutFileNameLabel = new GUIContent("SVO File", "SVO file name");
+            svoOutputFileNameProperty.stringValue = EditorGUILayout.TextField(svoOutFileNameLabel, svoOutputFileNameProperty.stringValue, GUILayout.ExpandWidth(true));
+
+            GUIContent svoCompressionModeLabel = new GUIContent("SVO Compression", "SVO Compression mode for the recorded SVO file");
+            svoOutputCompressionModeProperty.enumValueIndex = (int)(sl.SVO_COMPRESSION_MODE)EditorGUILayout.EnumPopup(svoCompressionModeLabel, (sl.SVO_COMPRESSION_MODE)svoOutputCompressionModeProperty.enumValueIndex, GUILayout.ExpandWidth(true));
+
+            GUIContent svoOutBitrateLabel = new GUIContent("Bitrate", "Bitrate for H264/5 recording");
+            svoOutputBitrateProperty.intValue = EditorGUILayout.IntField(svoOutBitrateLabel, svoOutputBitrateProperty.intValue);
+
+            GUIContent svoOutTargetFPSLabel = new GUIContent("Target FPS", "Target FPS for SVO recording");
+            svoOutputTargetFPSProperty.intValue = EditorGUILayout.IntField(svoOutTargetFPSLabel, svoOutputTargetFPSProperty.intValue);
+
+            GUIContent svoOutputTranscodeLabel = new GUIContent("Transcode", "If streaming input, set to false to avoid transcoding (decoding+ re-encoding for SVO). Recommended to leave at false.");
+            svoOutputTranscodeProperty.boolValue = EditorGUILayout.Toggle(svoOutputTranscodeLabel, svoOutputTranscodeProperty.boolValue);
+
+            EditorGUILayout.BeginHorizontal();
+            GUI.enabled = cameraIsReady;
+            string recordLabel = manager.needRecordFrame ? "Stop Recording" : "Start Recording";
+            string recordtooltip = manager.needRecordFrame ? "Stop Recording" : "Start Recording";
+            GUIContent displaylabel = new GUIContent(recordLabel, recordtooltip);
+            GUILayout.Space(EditorGUIUtility.labelWidth);
+            if (GUILayout.Button(recordLabel))
+            {
+                if (manager.needRecordFrame)
+                {
+                    manager.zedCamera.DisableRecording();
+                    manager.needRecordFrame = false;
+                }
+                else
+                {
+
+                    if (manager.zedCamera.EnableRecording(svoOutputFileNameProperty.stringValue, (sl.SVO_COMPRESSION_MODE)svoOutputCompressionModeProperty.enumValueIndex,(int)svoOutputBitrateProperty.intValue,(int)svoOutputTargetFPSProperty.intValue,svoOutputTranscodeProperty.boolValue) == sl.ERROR_CODE.SUCCESS)
+                        manager.needRecordFrame = true;
+                    else
+                    {
+                        Debug.LogError("Failed to start SVO Recording");
+                        manager.needRecordFrame = false;
+                    }
+                }
+            }
+            EditorGUI.indentLevel--;
+            GUI.enabled = true;
+            EditorGUILayout.EndHorizontal();
+        }
+
+
+        ///////////////////////////////////////////////////////////////
+        ///     Streaming Out layout     /////////////////////////////////
+        /////////////////////////////////////////////////////////////
+        GUILayout.Space(10);
+        showStreamingOut.boolValue = EditorGUILayout.Foldout(showStreamingOut.boolValue, "Streaming", boldfoldout);
+        if (showStreamingOut.boolValue)
+        {
+            EditorGUI.indentLevel++;
+            GUILayout.Space(5);
+            GUIContent streamingOutPropertyLabel = new GUIContent("Enable Streaming Output", "Enable Streaming Output with below settings");
+            streamingOutProperty.boolValue = EditorGUILayout.Toggle(streamingOutPropertyLabel, streamingOutProperty.boolValue);
+
+            GUIContent streamingOutCodecPropertyLabel = new GUIContent("Codec", "Codec used for images compression");
+            streamingOutCodecProperty.enumValueIndex = (int)(sl.STREAMING_CODEC)EditorGUILayout.EnumPopup(streamingOutCodecPropertyLabel, (sl.STREAMING_CODEC)streamingOutCodecProperty.enumValueIndex);
+
+            GUIContent streamingOutPortPropertyLabel = new GUIContent("Port", "Port where stream is sent to ");
+            streamingOutPortProperty.intValue = EditorGUILayout.IntField(streamingOutPortPropertyLabel, streamingOutPortProperty.intValue);
+
+            GUIContent streamingOutBitratePropertyLabel = new GUIContent("Bitrate", "Target Bitrate for the codec");
+            streamingOutBitrateProperty.intValue = EditorGUILayout.IntField(streamingOutBitratePropertyLabel, streamingOutBitrateProperty.intValue);
+
+            GUIContent streamingOutGopSizePropertyLabel = new GUIContent("Gop", "Maximum Gop size for the codec");
+            streamingOutGopSizeProperty.intValue = EditorGUILayout.IntField(streamingOutGopSizePropertyLabel, streamingOutGopSizeProperty.intValue);
+
+            GUIContent streamingOutAdaptBitratePropertyLabel = new GUIContent("Adaptative Bitrate", "Adaptative bitrate for the codec");
+            streamingOutAdaptBitrateProperty.boolValue = EditorGUILayout.Toggle(streamingOutAdaptBitratePropertyLabel, streamingOutAdaptBitrateProperty.boolValue);
+
+            GUIContent streamingOutChunkSizePropertyLabel = new GUIContent("Payload", "Chunk size for packet streaming");
+            streamingOutChunkSizeProperty.intValue = EditorGUILayout.IntField(streamingOutChunkSizePropertyLabel, streamingOutChunkSizeProperty.intValue);
+
+            GUIContent streamingOutTargetFPSPropertyLabel = new GUIContent("Target FPS", "Target FPS for streaming output");
+            streamingOutTargetFPSProperty.intValue = EditorGUILayout.IntField(streamingOutTargetFPSPropertyLabel, streamingOutTargetFPSProperty.intValue);
+
+            EditorGUI.indentLevel--;
+        }
+
+
+        ///////////////////////////////////////////////////////////////
+        ///  Advanced Settings layout  ///////////////////////////////
+        /////////////////////////////////////////////////////////////
+        GUILayout.Space(10);
+        showadvanced.boolValue = EditorGUILayout.Foldout(showadvanced.boolValue, "Advanced Settings", boldfoldout);
+        if (showadvanced.boolValue)
+        {
+            EditorGUI.indentLevel++;
+
+            GUILayout.Space(5);
+
+            GUIContent sensingModeLabel = new GUIContent("Sensing Mode", "FILL approximates depth in areas where depth can't be measured. " +
+                "FILL is almost always better for augmented/mixed reality applications.");
+            sensingModeProperty.enumValueIndex = (int)(sl.SENSING_MODE)EditorGUILayout.EnumPopup(sensingModeLabel, (sl.SENSING_MODE)sensingModeProperty.enumValueIndex);
+
+            GUIContent maxDepthPropertyLabel = new GUIContent("Max Depth Range", "Maximum depth at which the camera will display the real world, in meters. " +
+                "Pixels further than this value will be invisible.");
+            maxDepthProperty.floatValue = EditorGUILayout.Slider(maxDepthPropertyLabel, maxDepthProperty.floatValue, 0f, 40f);
+
+
+
+            GUIContent confidenceThresholdPropertyLabel = new GUIContent("Confidence Threshold", "How tolerant the ZED SDK is to low confidence values. Lower values filter more pixels based on stereo matching score.");
+            if (Application.isPlaying)
+            {
+                manager.confidenceThreshold = EditorGUILayout.IntSlider(confidenceThresholdPropertyLabel, manager.confidenceThreshold, 0, 100);
+            }
+            else
+            {
+                confidenceThresholdProperty.intValue = EditorGUILayout.IntSlider(confidenceThresholdPropertyLabel, confidenceThresholdProperty.intValue, 0, 100);
+            }
+
+            GUIContent textureConfidenceThresholdPropertyLabel = new GUIContent("Texture Confidence Threshold", "How tolerant the ZED SDK is to homogenous block. Lower values filter more pixels based on textureness.");
+            if (Application.isPlaying)
+            {
+                manager.textureConfidenceThreshold = EditorGUILayout.IntSlider(textureConfidenceThresholdPropertyLabel, manager.textureConfidenceThreshold, 0, 100);
+            }
+            else
+            {
+                textureConfidenceThresholdProperty.intValue = EditorGUILayout.IntSlider(textureConfidenceThresholdPropertyLabel, textureConfidenceThresholdProperty.intValue, 0, 100);
+            }
+
+
+
+            GUILayout.Space(12);
+
+            //Enable image enhancement toggle
+            EditorGUI.BeginDisabledGroup(Application.isPlaying);
+            GUIContent imageenhancementlabel = new GUIContent("Image Enhancement", "Whether to enable the new color/gamma curve added to the ZED SDK in v3.0.\r\n" +
+                "Exposes more detail in darker regions and removes a slight red bias.");
+            enableImageEnhancementProperty.boolValue = EditorGUILayout.Toggle(imageenhancementlabel, manager.enableImageEnhancement);
+            EditorGUI.EndDisabledGroup();
+
+            GUIContent enalbeIMUFusionLabel = new GUIContent("Visual-Inertial Tracking", "If true, and you are using a ZED2 or ZED Mini, IMU fusion uses data from the camera's IMU to improve tracking results. ");
+            enableIMUFusionProperty.boolValue = EditorGUILayout.Toggle(enalbeIMUFusionLabel, enableIMUFusionProperty.boolValue);
+
+            //Whether to enable the ZED SDK's self-calibration feature. 
+            GUIContent enableselfcaliblabel = new GUIContent("Self-Calibration", "If true, the ZED SDK will subtly adjust the ZED's calibration " +
+                "during runtime to account for heat and other factors. Reasons to disable this are rare. ");
+            enableSelfCalibrationProperty.boolValue = EditorGUILayout.Toggle(enableselfcaliblabel, enableSelfCalibrationProperty.boolValue);
+
+            //Grey Skybox toggle.
+            GUIContent greyskyboxlabel = new GUIContent("Grey Out Skybox on Start", "True to set the background to a neutral gray when the scene starts.\n\r" +
+                "Recommended for AR so that lighting on virtual objects better matches the real world.");
+            greyskybox.boolValue = EditorGUILayout.Toggle(greyskyboxlabel, manager.greySkybox);
+
+            //Don't Destroy On Load toggle.
+            GUIContent dontdestroylabel = new GUIContent("Don't Destroy on Load", "When enabled, applies DontDestroyOnLoad() on the ZED rig in Awake(), " +
+                "preserving it between scene transitions.");
+            dontdestroyonload.boolValue = EditorGUILayout.Toggle(dontdestroylabel, manager.dontDestroyOnLoad);
+
+            GUIContent openCalibPathlabel = new GUIContent("Opencv Calibration File ", "Optional, Set an optional file path where the SDK can find a file containing the calibration information of the camera computed by OpenCV. ");
+            opencvCalibFilePath.stringValue = EditorGUILayout.TextField(openCalibPathlabel, opencvCalibFilePath.stringValue);
+
+            GUILayout.Space(12);
+
+            EditorGUI.indentLevel--;
+
+            EditorGUILayout.LabelField("AR Passthrough Settings", EditorStyles.boldLabel);
+            GUILayout.Space(5);
+
+            EditorGUI.indentLevel++;
+
+            //Style for the AR layer box. 
+            GUIStyle layerboxstyle = new GUIStyle(EditorStyles.numberField);
+            layerboxstyle.fixedWidth = 30;
+            layerboxstyle.stretchWidth = false;
+            layerboxstyle.alignment = TextAnchor.MiddleCenter;
+
+            GUIStyle layerboxstylewarning = new GUIStyle(layerboxstyle);
+            layerboxstylewarning.normal.textColor = new Color(.9f, .9f, 0); //Red color if layer number is invalid.
+
+            GUIStyle layerboxstyleerror = new GUIStyle(layerboxstyle);
+            layerboxstyleerror.normal.textColor = new Color(.8f, 0, 0); //Red color if layer number is invalid.
+
+            GUIContent arlayerlabel = new GUIContent("AR Layer", "Layer that a final, normally-hidden AR rig sees. Used to confine it from the rest of the scene.\r\n " +
+                "You can assign this to any empty layer, and multiple ZEDs can share the same layer.");
+            arlayer = EditorGUILayout.IntField(arlayerlabel, ZEDLayers.arlayer, arlayer < 32 ? layerboxstyle : layerboxstyleerror);
+
+            //Show an error message if the set layer is invalid.
+            GUIStyle errormessagestyle = new GUIStyle(EditorStyles.label);
+            errormessagestyle.normal.textColor = layerboxstyleerror.normal.textColor;
+            errormessagestyle.wordWrap = true;
+            errormessagestyle.fontSize = 10;
+
+            //Show small error message if user set layer to below zero.
+            if (arlayer < 0)
+            {
+                string errortext = "Unity layers must be above zero to be visible.";
+                Rect labelrect = GUILayoutUtility.GetRect(new GUIContent(errortext, ""), errormessagestyle);
+                EditorGUI.LabelField(labelrect, errortext, errormessagestyle);
+            }
+
+            //Show small error message if user set layer higher than 31, which is invalid because Unity layers only go up to 31.
+            if (arlayer > 31)
+            {
+                string errortext = "Unity doesn't support layers above 31.";
+                Rect labelrect = GUILayoutUtility.GetRect(new GUIContent(errortext, ""), errormessagestyle);
+                EditorGUI.LabelField(labelrect, errortext, errormessagestyle);
+            }
+
+            //Show warnings if the layer is valid but not recommended.
+            GUIStyle warningmessagestyle = new GUIStyle(EditorStyles.label);
+            warningmessagestyle.normal.textColor = layerboxstylewarning.normal.textColor;
+            warningmessagestyle.wordWrap = true;
+            warningmessagestyle.fontSize = 10;
+
+            //Show small warning message if user set layer to 31, which is technically valid but Unity reserves it for other uses.
+            if (arlayer == 31)
+            {
+                string warningext = "Warning: Unity reserves layer 31 for previews in the editor. Assigning to layer 31 can cause conflicts.";
+                Rect labelrect = GUILayoutUtility.GetRect(new GUIContent(warningext, ""), warningmessagestyle);
+                EditorGUI.LabelField(labelrect, warningext, warningmessagestyle);
+            }
+
+            //Show small warning message if user set layer to 0
+            if (arlayer == 0)
+            {
+                string warningext = "Warning: Setting the AR rig to see the Default layer means other objects will be drawn in the background, " +
+                    "and in unexpected positions as the AR rig position is not synced with the ZED_Rig_Stereo object.";
+                Rect labelrect = GUILayoutUtility.GetRect(new GUIContent(warningext, ""), warningmessagestyle);
+                EditorGUI.LabelField(labelrect, warningext, warningmessagestyle);
+            }
+            ZEDLayersManager.ClearLayer(ZEDLayers.ID_arlayer);
+            ZEDLayersManager.CreateLayer(ZEDLayers.ID_arlayer, arlayer);
+
+            //Show AR Rig toggle.
+            GUIContent showarlabel = new GUIContent("Show Final AR Rig", "Whether to show the hidden camera rig used in stereo AR mode to " +
+                "prepare images for HMD output. You normally shouldn't tamper with this rig, but seeing it can be useful for " +
+                "understanding how the ZED output works.");
+            bool lastshowar = manager.showARRig;
+            showarrig.boolValue = EditorGUILayout.Toggle(showarlabel, manager.showARRig);
+
+            if (showarrig.boolValue != lastshowar)
+            {
+                LayerMask arlayers = (1 << manager.arLayer);
+
+                if (showarrig.boolValue == true)
+                {
+                    Tools.visibleLayers |= arlayers;
+                }
+                else
+                {
+                    Tools.visibleLayers &= ~(arlayers);
+                }
+
+                if (manager.zedRigDisplayer != null && Application.isPlaying)
+                {
+                    manager.zedRigDisplayer.hideFlags = showarrig.boolValue ? HideFlags.None : HideFlags.HideInHierarchy;
+                }
+            }
+
+            //GUILayout.Space(12);
+
+            EditorGUI.BeginDisabledGroup(Application.isPlaying);
+            GUIContent rightDepthLabel = new GUIContent("Enable Right Depth", "Whether to enable depth measurements from the right camera. Required for depth effects in AR pass-through, " +
+                "but requires performance even if not used.\r\n\n'AUTO' enables it only if a ZEDRenderingPlane component set to the right eye is detected as a child of ZEDManager's " +
+                "GameObject (as in the ZED rig prefabs.)");
+            rightDepthProperty.enumValueIndex = (int)(ZEDManager.RightDepthEnabledMode)EditorGUILayout.EnumPopup(rightDepthLabel, (ZEDManager.RightDepthEnabledMode)rightDepthProperty.enumValueIndex);
+
+            GUIContent allowPassThroughLabel = new GUIContent("Allow AR Pass-Through", "If true, the ZED rig will enter 'pass-through' mode if it detects a stereo rig - at least " +
+                "two cameras as children with ZEDRenderingPlane components, each with a different eye) - and a VR headset is connected. If false, it will never enter pass-through mode.");
+            allowPassThroughProperty.boolValue = EditorGUILayout.Toggle(allowPassThroughLabel, allowPassThroughProperty.boolValue);
+
+            //Whether to set the IMU prior in AR passthrough mode.
+            GUIContent setimupriorlabel = new GUIContent("Set IMU Prior in AR", "In AR pass-through mode, whether to compare the " +
+                "ZED's IMU data against the reported position of the VR headset. This helps compensate for drift and should " +
+                "usually be left on. However, in some setups, like when using a custom mount, this can cause tracking errors.");
+            setIMUPrior.boolValue = EditorGUILayout.Toggle(setimupriorlabel, manager.setIMUPriorInAR);
+
+            //Fade In At Start toggle. 
+            GUIContent fadeinlabel = new GUIContent("Fade In at Start", "When enabled, makes the ZED image fade in from black when the application starts.");
+            fadeinonstart.boolValue = EditorGUILayout.Toggle(fadeinlabel, manager.fadeInOnStart);
+
+            GUILayout.Space(12);
+
+            GUI.enabled = true;
+
+            GUIContent camRebootButton = new GUIContent("Reboot Camera", "Reboot the camera.");
+            if (GUILayout.Button(camRebootButton))
+            {
+                if (Application.isPlaying && manager.zedCamera.IsCameraReady)
+                {
+                    manager.Reboot();
+                }
+            }
+
+            EditorGUI.EndDisabledGroup();
+            EditorGUI.indentLevel--;
+        }
+
+        serializedObject.ApplyModifiedProperties();
+
+
+
+        ///////////////////////////////////////////////////////////////
+        ///  Camera control layout ///////////////////////////////////
+        /////////////////////////////////////////////////////////////
+
+        /*//TEST: Try loading starting settings.
+        if (Application.isPlaying && manager.zedCamera.IsCameraReady)
+        {
+            if (!hasLoadedSettings)
+            {
+                Debug.Log("Loaded settings.");
+
+                LoadCurrentVideoSettings();
+
+                hasLoadedSettings = true;
+            }
+        }
+        else hasLoadedSettings = false;*/
+
+
+        GUILayout.Space(10);
+        showcamcontrol.boolValue = EditorGUILayout.Foldout(showcamcontrol.boolValue, "Camera Controls", boldfoldout);
+        if (showcamcontrol.boolValue)
+        {
+            GUILayout.Space(5);
+            EditorGUI.indentLevel++;
+
+            //usbResolutionProperty.enumValueIndex = (int)(sl.RESOLUTION)EditorGUILayout.EnumPopup(cameraResolutionLabel, (sl.RESOLUTION)usbResolutionProperty.enumValueIndex);
+            //(ZEDManager.VideoSettingsInitMode)
+
+            GUIContent videoInitModeLabel = new GUIContent("Load From: ", "Where the ZED's settings come from when you start the scene.\r\n\n" +
+                "- Custom: Applies settings as set below before runtime.\r\n\n- Load From SDK: Camera will load settings last applied to the ZED. " +
+                "May have been from a source outside Unity.\r\n\n- Default: Camera will load default video settings.");
+            videoSettingsInitModeProperty.enumValueIndex = (int)(ZEDManager.VideoSettingsInitMode)EditorGUILayout.EnumPopup(videoInitModeLabel,
+                (ZEDManager.VideoSettingsInitMode)videoSettingsInitModeProperty.enumValueIndex);
+
+            if (manager.zedCamera == null && videoSettingsInitModeProperty.enumValueIndex != (int)ZEDManager.VideoSettingsInitMode.Custom)
+                GUI.enabled = false;
+            else
+                GUI.enabled = true;
+
+
+            EditorGUI.BeginChangeCheck();
+            brightnessProperty.intValue = EditorGUILayout.IntSlider("Brightness", brightnessProperty.intValue, 0, 8);
+            if (EditorGUI.EndChangeCheck())
+            {
+                if (manager.zedCamera != null && manager.zedCamera.IsCameraReady)
+                    manager.zedCamera.SetCameraSettings(sl.CAMERA_SETTINGS.BRIGHTNESS, brightnessProperty.intValue);
+            }
+
+            EditorGUI.BeginChangeCheck();
+            contrastProperty.intValue = EditorGUILayout.IntSlider("Contrast", contrastProperty.intValue, 0, 8);
+            if (EditorGUI.EndChangeCheck())
+            {
+                if (manager.zedCamera != null && manager.zedCamera.IsCameraReady)
+                    manager.zedCamera.SetCameraSettings(sl.CAMERA_SETTINGS.CONTRAST, contrastProperty.intValue);
+            }
+
+            EditorGUI.BeginChangeCheck();
+            hueProperty.intValue = EditorGUILayout.IntSlider("Hue", hueProperty.intValue, 0, 11);
+            if (EditorGUI.EndChangeCheck())
+            {
+                if (manager.zedCamera != null && manager.zedCamera.IsCameraReady)
+                    manager.zedCamera.SetCameraSettings(sl.CAMERA_SETTINGS.HUE, hueProperty.intValue);
+            }
+
+            EditorGUI.BeginChangeCheck();
+            saturationProperty.intValue = EditorGUILayout.IntSlider("Saturation", saturationProperty.intValue, 0, 8);
+            if (EditorGUI.EndChangeCheck())
+            {
+                if (manager.zedCamera != null && manager.zedCamera.IsCameraReady)
+                    manager.zedCamera.SetCameraSettings(sl.CAMERA_SETTINGS.SATURATION, saturationProperty.intValue);
+            }
+
+            EditorGUI.BeginChangeCheck();
+            sharpnessProperty.intValue = EditorGUILayout.IntSlider("Sharpness", sharpnessProperty.intValue, 0, 8);
+            if (EditorGUI.EndChangeCheck())
+            {
+                if (manager.zedCamera != null && manager.zedCamera.IsCameraReady)
+                    manager.zedCamera.SetCameraSettings(sl.CAMERA_SETTINGS.SHARPNESS, sharpnessProperty.intValue);
+            }
+
+            EditorGUI.BeginChangeCheck();
+            gammaProperty.intValue = EditorGUILayout.IntSlider("Gamma", gammaProperty.intValue, 1, 9);
+            if (EditorGUI.EndChangeCheck())
+            {
+                if (manager.zedCamera != null && manager.zedCamera.IsCameraReady)
+                    manager.zedCamera.SetCameraSettings(sl.CAMERA_SETTINGS.GAMMA, gammaProperty.intValue);
+            }
+
+
+            EditorGUI.BeginChangeCheck();
+            ledStatus.boolValue = EditorGUILayout.Toggle("LED Status", ledStatus.boolValue, EditorStyles.toggle);
+            if (EditorGUI.EndChangeCheck())
+            {
+                if (manager.zedCamera != null && manager.zedCamera.IsCameraReady)
+                {
+                    int lst = ledStatus.boolValue ? 1 : 0;
+                    manager.zedCamera.SetCameraSettings(sl.CAMERA_SETTINGS.LED_STATUS, lst);
+                }
+            }
+
+            EditorGUI.BeginChangeCheck();
+            autoGainExposureProperty.boolValue = EditorGUILayout.Toggle("AEC / AGC ", autoGainExposureProperty.boolValue, EditorStyles.toggle);
+            if (Application.isPlaying && manager.zedCamera != null && manager.zedCamera.IsCameraReady)
+            {
+                if (EditorGUI.EndChangeCheck())
+                {
+                    if (autoGainExposureProperty.boolValue)
+                    {
+                        manager.zedCamera.SetCameraSettings(sl.CAMERA_SETTINGS.AEC_AGC, 1);
+                    }
+                    else
+                    {
+                        manager.zedCamera.SetCameraSettings(sl.CAMERA_SETTINGS.AEC_AGC, 0);
+
+                        gainProperty.intValue = manager.zedCamera.GetCameraSettings(sl.CAMERA_SETTINGS.GAIN);
+                        exposureProperty.intValue = manager.zedCamera.GetCameraSettings(sl.CAMERA_SETTINGS.EXPOSURE);
+
+                        manager.zedCamera.SetCameraSettings(sl.CAMERA_SETTINGS.GAIN, gainProperty.intValue); //Apply last settings immediately.
+                        manager.zedCamera.SetCameraSettings(sl.CAMERA_SETTINGS.EXPOSURE, exposureProperty.intValue);
+
+                    }
+                }
+
+            }
+
+            GUI.enabled = !autoGainExposureProperty.boolValue;
+            EditorGUI.BeginChangeCheck();
+            EditorGUI.indentLevel++;
+            gainProperty.intValue = EditorGUILayout.IntSlider("Gain", gainProperty.intValue, 0, 100);
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                if (manager.zedCamera != null && !autoGainExposureProperty.boolValue)
+                {
+                    manager.zedCamera.SetCameraSettings(sl.CAMERA_SETTINGS.GAIN, gainProperty.intValue);
+                }
+            }
+            EditorGUI.BeginChangeCheck();
+            exposureProperty.intValue = EditorGUILayout.IntSlider("Exposure", exposureProperty.intValue, 0, 100);
+            if (EditorGUI.EndChangeCheck())
+            {
+                if (manager.zedCamera != null && manager.zedCamera.IsCameraReady && !autoGainExposureProperty.boolValue)
+                {
+                    manager.zedCamera.SetCameraSettings(sl.CAMERA_SETTINGS.EXPOSURE, exposureProperty.intValue);
+                }
+
+            }
+            if (manager.zedCamera == null && videoSettingsInitModeProperty.enumValueIndex != (int)ZEDManager.VideoSettingsInitMode.Custom)
+                GUI.enabled = false;
+            else
+                GUI.enabled = true;
+
+            EditorGUI.indentLevel--;
+
+            EditorGUI.BeginChangeCheck();
+            autoWhiteBalanceProperty.boolValue = EditorGUILayout.Toggle(" AWB ", autoWhiteBalanceProperty.boolValue, EditorStyles.toggle);
+            if (Application.isPlaying && manager.zedCamera.IsCameraReady)
+            {
+                if (EditorGUI.EndChangeCheck())
+                {
+                    if (autoWhiteBalanceProperty.boolValue)
+                    {
+                        manager.zedCamera.SetCameraSettings(sl.CAMERA_SETTINGS.AUTO_WHITEBALANCE, 1);
+                    }
+                    else
+                    {
+                        manager.zedCamera.SetCameraSettings(sl.CAMERA_SETTINGS.AUTO_WHITEBALANCE, 0);
+                        whitebalanceProperty.intValue = manager.zedCamera.GetCameraSettings(sl.CAMERA_SETTINGS.WHITEBALANCE) * 100;
+                        manager.zedCamera.SetCameraSettings(sl.CAMERA_SETTINGS.WHITEBALANCE, whitebalanceProperty.intValue / 100);
+
+                    }
+                }
+
+            }
+            EditorGUI.indentLevel++;
+            GUI.enabled = !autoWhiteBalanceProperty.boolValue;
+            EditorGUI.BeginChangeCheck();
+            whitebalanceProperty.intValue = 100 * EditorGUILayout.IntSlider("White balance", whitebalanceProperty.intValue / 100, 26, 65);
+            if (!autoWhiteBalanceProperty.boolValue && EditorGUI.EndChangeCheck())
+            {
+                if (manager.zedCamera != null && manager.zedCamera.IsCameraReady)
+                    manager.zedCamera.SetCameraSettings(sl.CAMERA_SETTINGS.WHITEBALANCE, whitebalanceProperty.intValue);
+            }
+
+
+
+            EditorGUI.indentLevel--;
+            EditorGUI.indentLevel--;
+
+
+            GUILayout.Space(7);
+            if (manager.zedCamera == null && videoSettingsInitModeProperty.enumValueIndex != (int)ZEDManager.VideoSettingsInitMode.Custom)
+                GUI.enabled = false;
+            else
+                GUI.enabled = true;
+
+            EditorGUILayout.BeginHorizontal();
+            GUILayout.Space(EditorGUIUtility.labelWidth);
+            GUIContent camcontrolbuttonreset = new GUIContent("Reset to Default", "Reset camera controls to default.");
+            if (GUILayout.Button(camcontrolbuttonreset))
+            {
+                if (Application.isPlaying && manager.zedCamera.IsCameraReady)
+                {
+                    manager.zedCamera.ResetCameraSettings();
+                    LoadCurrentVideoSettings();
+                }
+                else
+                {
+                    brightnessProperty.intValue = sl.ZEDCamera.brightnessDefault;
+                    contrastProperty.intValue = sl.ZEDCamera.contrastDefault;
+                    hueProperty.intValue = sl.ZEDCamera.hueDefault;
+                    saturationProperty.intValue = sl.ZEDCamera.saturationDefault;
+
+                    autoGainExposureProperty.boolValue = true;
+                    autoWhiteBalanceProperty.boolValue = true;
+
+                    sharpnessProperty.intValue = sl.ZEDCamera.sharpnessDefault;
+                    gammaProperty.intValue = sl.ZEDCamera.gammaDefault;
+                    ledStatus.boolValue = true;
+                }
+            }
+
+            EditorGUILayout.EndHorizontal();
+            GUI.enabled = true;
+        }
+        serializedObject.ApplyModifiedProperties();
+
+
+
+        ///////////////////////////////////////////////////////////////
+        ///  Status layout //////////////////////////////////////////
+        /////////////////////////////////////////////////////////////
+
+        serializedObject.ApplyModifiedProperties();
+
+        GUIStyle standardStyle = new GUIStyle(EditorStyles.textField);
+        GUIStyle errorStyle = new GUIStyle(EditorStyles.textField);
+        errorStyle.normal.textColor = Color.red;
+
+
+        GUILayout.Space(10);
+        EditorGUILayout.LabelField("Status", EditorStyles.boldLabel);
+        EditorGUI.BeginDisabledGroup(true);
+        EditorGUI.indentLevel++;
+        GUILayout.Space(5);
+        GUIContent cameraModellabel = new GUIContent("Camera Model:", "Model of the targeted camera.");
+        EditorGUILayout.TextField(cameraModellabel, manager.cameraModel);
+
+        GUIContent cameraSerialNumberlabel = new GUIContent("Camera S/N:", "Serial number of the targeted camera.");
+        EditorGUILayout.TextField(cameraSerialNumberlabel, manager.cameraSerialNumber);
+
+        GUIContent cameraFWlabel = new GUIContent("Camera Firmware:", "Firmware of the targeted camera.");
+        EditorGUILayout.TextField(cameraFWlabel, manager.cameraFirmware);
+
+        GUIContent sdkversionlabel = new GUIContent("SDK Version:", "Version of the installed ZED SDK.");
+        EditorGUILayout.TextField(sdkversionlabel, manager.versionZED);
+
+        GUIContent enginefpslabel = new GUIContent("Engine FPS:", "How many frames per second the engine is rendering.");
+        EditorGUILayout.TextField(enginefpslabel, manager.engineFPS);
+
+        GUIContent camerafpslabel = new GUIContent("Camera FPS:", "How many images per second are received from the ZED.");
+        EditorGUILayout.TextField(camerafpslabel, manager.cameraFPS);
+
+        GUIContent trackingstatelabel = new GUIContent("Tracking State:", "Whether the ZED's tracking is on, off, or searching (lost position, trying to recover).");
+        if (manager.IsCameraTracked || !manager.IsZEDReady)
+            EditorGUILayout.TextField(trackingstatelabel, manager.trackingState, standardStyle);
+        else
+            EditorGUILayout.TextField(trackingstatelabel, manager.trackingState, errorStyle);
+
+        GUIContent odfpslabel = new GUIContent("Obj Detection FPS:", "How many images per second are used for OD");
+        EditorGUILayout.TextField(odfpslabel, manager.objectDetectionFPS);
+
+        EditorGUI.indentLevel--;
+        EditorGUI.EndDisabledGroup();
+    }
+
+    /// <summary>
+    /// Check if something has changed that requires restarting the camera.
+    /// Used to know if the Restart Camera button and a prompt to press it should be visible.
+    /// </summary>
+    /// <returns>True if a setting was changed that won't go into effect until a restart. </returns>
+    private bool CheckChange()
+    {
+        if (resolution != manager.resolution ||
+            depthmode != manager.depthMode)
+        {
+            return true;
+        }
+        else return false;
+    }
+
+    /// <summary>
+    /// If the given layer name is equal to the provided string, it clears it.
+    /// Used when a ZED layer is moved to a different layer.
+    /// </summary>
+    /// <param name="layer"></param>
+    /// <param name="constname"></param>
+    private void ClearLayerNameIfNeeded(int layer, string constname)
+    {
+        if (layer < 0 || layer > 31) return; //Invalid ID.
+        SerializedObject tagManager = new SerializedObject(AssetDatabase.LoadAllAssetsAtPath("ProjectSettings/TagManager.asset")[0]);
+        SerializedProperty layerNames = tagManager.FindProperty("layers");
+        if (layerNames.GetArrayElementAtIndex(layer).stringValue == constname)
+        {
+            layerNames.GetArrayElementAtIndex(layer).stringValue = "";
+            tagManager.ApplyModifiedProperties();
+        }
+
+
+    }
+
+    /// <summary>
+    /// Loads all current camera video settings from the ZED SDK into the buffer values (brightness, contrast, etc.)
+    /// </summary>
+    private void LoadCurrentVideoSettings()
+    {
+        brightnessProperty.intValue = manager.zedCamera.GetCameraSettings(sl.CAMERA_SETTINGS.BRIGHTNESS);
+        contrastProperty.intValue = manager.zedCamera.GetCameraSettings(sl.CAMERA_SETTINGS.CONTRAST);
+        hueProperty.intValue = manager.zedCamera.GetCameraSettings(sl.CAMERA_SETTINGS.HUE);
+        saturationProperty.intValue = manager.zedCamera.GetCameraSettings(sl.CAMERA_SETTINGS.SATURATION);
+        sharpnessProperty.intValue = manager.zedCamera.GetCameraSettings(sl.CAMERA_SETTINGS.SHARPNESS);
+        gammaProperty.intValue = manager.zedCamera.GetCameraSettings(sl.CAMERA_SETTINGS.GAMMA);
+        gainProperty.intValue = manager.zedCamera.GetCameraSettings(sl.CAMERA_SETTINGS.GAIN);
+        exposureProperty.intValue = manager.zedCamera.GetCameraSettings(sl.CAMERA_SETTINGS.EXPOSURE);
+        whitebalanceProperty.intValue = manager.zedCamera.GetCameraSettings(sl.CAMERA_SETTINGS.WHITEBALANCE);
+
+        autoGainExposureProperty.boolValue = manager.zedCamera.GetCameraSettings(sl.CAMERA_SETTINGS.AEC_AGC) == 1 ? true : false;
+        autoWhiteBalanceProperty.boolValue = manager.zedCamera.GetCameraSettings(sl.CAMERA_SETTINGS.AUTO_WHITEBALANCE) == 1 ? true : false;
+        ledStatus.boolValue = manager.zedCamera.GetCameraSettings(sl.CAMERA_SETTINGS.LED_STATUS) == 1 ? true : false;
+    }
+
+}

Assets/ZED/Editor/Scripts/ZEDCameraEditor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 03b0e3705ef780a44bd436f87506364f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/Editor/Scripts/ZEDPluginInspector.cs

@@ -0,0 +1,548 @@
+//======= Copyright (c) Stereolabs Corporation, All rights reserved. ===============
+
+using UnityEngine;
+using UnityEditor;
+using System.Collections;
+
+/// <summary>
+/// Checks your system for the required ZED SDK version, and displays an error window with instructions if it's missing. 
+/// Runs automatically when Unity loads. Remove the [InitializeOnLoad] tag to disable this.
+/// </summary>
+[InitializeOnLoad]
+public class ZEDPluginInspector : EditorWindow
+{
+    /// <summary>
+    /// ZED unity logo
+    /// </summary>
+    static Texture2D image = null;
+
+    private static EditorWindow window;
+
+    private static bool showErrorMode = false;
+    private static bool showSettingsMode = false;
+    private static string errorMessage = "";
+
+    const bool forceSettingsShow = false;
+    bool showErrorPlugin = false;
+
+    const string ignore = "ignore.";
+    const string useRecommended = "Use recommended ({0})";
+    const string currentValue = " (current = {0})";
+
+    const string buildTarget = "Build Target";
+    const string showUnitySplashScreen = "Show Unity Splashscreen";
+    const string displayResolutionDialog = "Display Resolution Dialog";
+    const string resizableWindow = "Resizable Window";
+    const string colorSpace = "Color Space";
+    const string gpuSkinning = "GPU Skinning";
+    const string MSAAValue = "Anti Aliasing";
+    const string runInBackground = "Run In Background";
+    const string visibleInBackground = "Visible In Background";
+
+
+    const BuildTarget needed_BuildTarget = BuildTarget.StandaloneWindows64;
+    const bool needed_ShowUnitySplashScreen = false;
+    const bool needed_ResizableWindow = true;
+    const ColorSpace needed_ColorSpace = ColorSpace.Linear;
+    const bool needed_GPUSkinning = true;
+    const int needed_MSAAValue = 4;
+    const bool needed_RunInBackground = true;
+    const bool needed_VisibleInBackground = true;
+    static ZEDPluginInspector()
+    {
+        EditorApplication.update += OnInit;
+    }
+
+    static void OnInit()
+    {
+        EditorApplication.update -= OnInit;
+        if (!EditorApplication.isPlayingOrWillChangePlaymode && !EditorApplication.isCompiling && !EditorApplication.isUpdating)
+        {
+            if (!EditorPrefs.HasKey("ZED_NoWarning_Plugin"))
+                EditorApplication.update += UpdateWnd;
+        }
+        else
+            EditorApplication.update += UpdateLog;
+
+        EditorApplication.update += UpdateSettingsWnd;
+
+    }
+
+    void OnEnable()
+    {
+        addMissingTag();
+    }
+
+    /// <summary>
+    /// Makes sure the project's tags are loaded, as they are used in some samples but may get deleted on import or
+    /// if shared via source control. 
+    /// </summary>
+	static public void addMissingTag()
+    {
+        // Open tag manager
+        SerializedObject tagManager = new SerializedObject(AssetDatabase.LoadAllAssetsAtPath("ProjectSettings/TagManager.asset")[0]);
+        SerializedProperty tagsProp = tagManager.FindProperty("tags");
+        // Adding a Tag
+        string s = "HelpObject";
+
+        // Check if not here already
+        bool found = false;
+        for (int i = 0; i < tagsProp.arraySize; i++)
+        {
+            SerializedProperty t = tagsProp.GetArrayElementAtIndex(i);
+            if (t.stringValue.Equals(s)) { found = true; break; }
+        }
+
+        //If not found, add it since we use it in GreenScreen. 
+        //This tag may be used anywhere, since it tags helper object that may have a specific behavior
+
+        if (!found)
+        {
+            tagsProp.InsertArrayElementAtIndex(0);
+            SerializedProperty n = tagsProp.GetArrayElementAtIndex(0);
+            n.stringValue = s;
+        }
+
+
+        // and to save the changes
+        tagManager.ApplyModifiedProperties();
+    }
+
+    static void UpdateLog()
+    {
+        if (!sl.ZEDCamera.CheckPlugin())
+        {
+            Debug.Log("ZED SDK is not installed or needs to be updated");
+        }
+
+        EditorApplication.update -= UpdateLog;
+    }
+
+
+
+    static void UpdateSettingsWnd()
+    {
+        showSettingsMode =
+            (!EditorPrefs.HasKey(ignore + buildTarget) &&
+                EditorUserBuildSettings.activeBuildTarget != needed_BuildTarget) ||
+            (!EditorPrefs.HasKey(ignore + showUnitySplashScreen) &&
+                PlayerSettings.SplashScreen.show != needed_ShowUnitySplashScreen) ||
+            (!EditorPrefs.HasKey(ignore + resizableWindow) &&
+                PlayerSettings.resizableWindow != needed_ResizableWindow) ||
+            (!EditorPrefs.HasKey(ignore + colorSpace) &&
+                PlayerSettings.colorSpace != needed_ColorSpace) ||
+            (!EditorPrefs.HasKey(ignore + gpuSkinning) &&
+                PlayerSettings.gpuSkinning != needed_GPUSkinning) ||
+            (!EditorPrefs.HasKey(ignore + runInBackground) &&
+                PlayerSettings.runInBackground != needed_RunInBackground) ||
+            (!EditorPrefs.HasKey(ignore + visibleInBackground) &&
+                PlayerSettings.visibleInBackground != needed_VisibleInBackground) ||
+            (!EditorPrefs.HasKey(ignore + MSAAValue) &&
+                QualitySettings.antiAliasing != needed_MSAAValue) ||
+            forceSettingsShow;
+
+        if (showSettingsMode)
+        {
+            window = GetWindow<ZEDPluginInspector>(true);
+            window.maxSize = new Vector2(400, 400);
+            window.minSize = window.maxSize;
+            window.Show(true);
+        }
+
+
+        EditorApplication.update -= UpdateSettingsWnd;
+    }
+
+    static void UpdateWnd()
+    {
+
+        if (!sl.ZEDCamera.CheckPlugin())
+        {
+            errorMessage = ZEDLogMessage.Error2Str(ZEDLogMessage.ERROR.SDK_DEPENDENCIES_ISSUE);
+            showErrorMode = true;
+            window = GetWindow<ZEDPluginInspector>(true);
+            window.maxSize = new Vector2(400, 600);
+            window.minSize = window.maxSize;
+            window.Show(true);
+        }
+
+        EditorApplication.update -= UpdateWnd;
+
+    }
+
+
+
+    void OnGUI()
+    {
+        if (showErrorMode)
+        {
+            showErrorWindow();
+        }
+        else if (showSettingsMode)
+        {
+            showSettingsWindow();
+        }
+    }
+
+    /// <summary>
+    /// Displays a popup window when the correct ZED SDK version isn't installed.
+    /// </summary>
+	public void showErrorWindow()
+    {
+        if (image == null)
+        {
+            image = Resources.Load("Textures/logo", typeof(Texture2D)) as Texture2D;
+
+        }
+        var rect = GUILayoutUtility.GetRect(position.width, 150, GUI.skin.box);
+
+        if (image)
+        {
+            GUI.DrawTexture(rect, image, ScaleMode.ScaleToFit);
+        }
+        GUIStyle myStyle = new GUIStyle(GUI.skin.label);
+        myStyle.normal.textColor = Color.red;
+        myStyle.fontStyle = FontStyle.Bold;
+
+        GUILayout.Space(20);
+        GUILayout.BeginHorizontal();
+        GUILayout.FlexibleSpace();
+        GUILayout.Label("ZED SDK is not installed or needs to be updated", myStyle);
+        GUILayout.FlexibleSpace();
+        GUILayout.EndHorizontal();
+        myStyle = new GUIStyle(GUI.skin.box);
+        myStyle.normal.textColor = Color.red;
+
+
+        GUI.Box(new Rect(0, position.height / 2, position.width, 100), errorMessage, myStyle);
+
+        GUILayout.FlexibleSpace();
+        GUILayout.BeginHorizontal();
+        myStyle.normal.textColor = Color.black;
+        myStyle.fontStyle = FontStyle.Bold;
+        GUILayout.Label("Do not ask me again...");
+        showErrorPlugin = EditorGUILayout.Toggle("", showErrorPlugin);
+        GUILayout.EndHorizontal();
+
+
+        GUILayout.Space(10);
+        if (GUILayout.Button("Close"))
+        {
+
+            if (showErrorPlugin)
+            {
+                EditorPrefs.SetBool("ZED_NoWarning_Plugin", true);
+            }
+
+            this.Close();
+        }
+    }
+
+
+    Vector2 scrollPosition;
+    /// <summary>
+    /// Shows a window prompting the user to change project settings to recommended settings, with
+    /// buttons to automatically do so. 
+    /// </summary>
+	public void showSettingsWindow()
+    {
+        if (image == null)
+        {
+            image = Resources.Load("Textures/logo", typeof(Texture2D)) as Texture2D;
+
+        }
+        var rect = GUILayoutUtility.GetRect(position.width, 150, GUI.skin.box);
+
+        if (image)
+        {
+            GUI.DrawTexture(rect, image, ScaleMode.ScaleToFit);
+        }
+
+        EditorGUILayout.HelpBox("Recommended project settings for ZED Unity Plugin", MessageType.Warning);
+
+        scrollPosition = GUILayout.BeginScrollView(scrollPosition);
+
+        int numItems = 0;
+
+        if (!EditorPrefs.HasKey(ignore + buildTarget) &&
+            EditorUserBuildSettings.activeBuildTarget != needed_BuildTarget)
+        {
+            ++numItems;
+
+            GUILayout.Label(buildTarget + string.Format(currentValue, EditorUserBuildSettings.activeBuildTarget));
+
+            GUILayout.BeginHorizontal();
+
+            if (GUILayout.Button(string.Format(useRecommended, needed_BuildTarget)))
+            {
+                EditorUserBuildSettings.SwitchActiveBuildTarget(BuildTargetGroup.Standalone, needed_BuildTarget);
+            }
+
+            GUILayout.FlexibleSpace();
+
+            if (GUILayout.Button("Ignore"))
+            {
+                EditorPrefs.SetBool(ignore + buildTarget, true);
+            }
+
+            GUILayout.EndHorizontal();
+        }
+
+        if (!EditorPrefs.HasKey(ignore + showUnitySplashScreen) &&
+            PlayerSettings.SplashScreen.show != needed_ShowUnitySplashScreen)
+        {
+            ++numItems;
+
+            GUILayout.Label(showUnitySplashScreen + string.Format(currentValue, PlayerSettings.SplashScreen.show));
+
+            GUILayout.BeginHorizontal();
+
+            if (GUILayout.Button(string.Format(useRecommended, needed_ShowUnitySplashScreen)))
+            {
+                PlayerSettings.SplashScreen.show = needed_ShowUnitySplashScreen;
+            }
+
+            GUILayout.FlexibleSpace();
+
+            if (GUILayout.Button("Ignore"))
+            {
+                EditorPrefs.SetBool(ignore + showUnitySplashScreen, true);
+            }
+
+            GUILayout.EndHorizontal();
+        }
+        if (!EditorPrefs.HasKey(ignore + resizableWindow) &&
+            PlayerSettings.resizableWindow != needed_ResizableWindow)
+        {
+            ++numItems;
+
+            GUILayout.Label(resizableWindow + string.Format(currentValue, PlayerSettings.resizableWindow));
+
+            GUILayout.BeginHorizontal();
+
+            if (GUILayout.Button(string.Format(useRecommended, needed_ResizableWindow)))
+            {
+                PlayerSettings.resizableWindow = needed_ResizableWindow;
+            }
+
+            GUILayout.FlexibleSpace();
+
+            if (GUILayout.Button("Ignore"))
+            {
+                EditorPrefs.SetBool(ignore + resizableWindow, true);
+            }
+
+            GUILayout.EndHorizontal();
+        }
+
+        if (!EditorPrefs.HasKey(ignore + visibleInBackground) &&
+            PlayerSettings.visibleInBackground != needed_VisibleInBackground)
+        {
+            ++numItems;
+
+            GUILayout.Label(visibleInBackground + string.Format(currentValue, PlayerSettings.visibleInBackground));
+
+            GUILayout.BeginHorizontal();
+
+            if (GUILayout.Button(string.Format(useRecommended, needed_VisibleInBackground)))
+            {
+                PlayerSettings.visibleInBackground = needed_VisibleInBackground;
+            }
+
+            GUILayout.FlexibleSpace();
+
+            if (GUILayout.Button("Ignore"))
+            {
+                EditorPrefs.SetBool(ignore + visibleInBackground, true);
+            }
+
+            GUILayout.EndHorizontal();
+        }
+
+        if (!EditorPrefs.HasKey(ignore + runInBackground) &&
+            PlayerSettings.runInBackground != needed_RunInBackground)
+        {
+            ++numItems;
+
+            GUILayout.Label(runInBackground + string.Format(currentValue, PlayerSettings.runInBackground));
+
+            GUILayout.BeginHorizontal();
+
+            if (GUILayout.Button(string.Format(useRecommended, needed_RunInBackground)))
+            {
+                PlayerSettings.runInBackground = needed_RunInBackground;
+            }
+
+            GUILayout.FlexibleSpace();
+
+            if (GUILayout.Button("Ignore"))
+            {
+                EditorPrefs.SetBool(ignore + runInBackground, true);
+            }
+
+            GUILayout.EndHorizontal();
+        }
+
+
+        if (!EditorPrefs.HasKey(ignore + gpuSkinning) &&
+            PlayerSettings.gpuSkinning != needed_GPUSkinning)
+        {
+            ++numItems;
+
+            GUILayout.Label(gpuSkinning + string.Format(currentValue, PlayerSettings.gpuSkinning));
+
+            GUILayout.BeginHorizontal();
+
+            if (GUILayout.Button(string.Format(useRecommended, needed_GPUSkinning)))
+            {
+                PlayerSettings.gpuSkinning = needed_GPUSkinning;
+            }
+
+            GUILayout.FlexibleSpace();
+
+            if (GUILayout.Button("Ignore"))
+            {
+                EditorPrefs.SetBool(ignore + gpuSkinning, true);
+            }
+
+            GUILayout.EndHorizontal();
+        }
+
+        if (!EditorPrefs.HasKey(ignore + colorSpace) &&
+            PlayerSettings.colorSpace != needed_ColorSpace)
+        {
+            ++numItems;
+
+            GUILayout.Label(colorSpace + string.Format(currentValue, PlayerSettings.colorSpace));
+
+            GUILayout.BeginHorizontal();
+
+            if (GUILayout.Button(string.Format(useRecommended, needed_ColorSpace) + " - requires reloading scene"))
+            {
+                PlayerSettings.colorSpace = needed_ColorSpace;
+            }
+
+            GUILayout.FlexibleSpace();
+
+            if (GUILayout.Button("Ignore"))
+            {
+                EditorPrefs.SetBool(ignore + colorSpace, true);
+            }
+
+            GUILayout.EndHorizontal();
+        }
+
+
+        if (!EditorPrefs.HasKey(ignore + MSAAValue) &&
+            QualitySettings.antiAliasing != needed_MSAAValue)
+        {
+            ++numItems;
+
+            GUILayout.Label(MSAAValue + string.Format(currentValue, QualitySettings.antiAliasing) + "x Multi Sampling");
+
+            GUILayout.BeginHorizontal();
+
+            if (GUILayout.Button(string.Format(useRecommended, needed_MSAAValue)))
+            {
+                QualitySettings.antiAliasing = needed_MSAAValue;
+            }
+
+            GUILayout.FlexibleSpace();
+
+            if (GUILayout.Button("Ignore"))
+            {
+                EditorPrefs.SetBool(ignore + MSAAValue, true);
+            }
+
+            GUILayout.EndHorizontal();
+        }
+
+
+        GUILayout.BeginHorizontal();
+
+        GUILayout.FlexibleSpace();
+
+        if (GUILayout.Button("Clear All Ignores"))
+        {
+            EditorPrefs.DeleteKey(ignore + buildTarget);
+            EditorPrefs.DeleteKey(ignore + showUnitySplashScreen);
+            EditorPrefs.DeleteKey(ignore + displayResolutionDialog);
+            EditorPrefs.DeleteKey(ignore + resizableWindow);
+            EditorPrefs.DeleteKey(ignore + colorSpace);
+            EditorPrefs.DeleteKey(ignore + gpuSkinning);
+            EditorPrefs.DeleteKey(ignore + MSAAValue);
+            EditorPrefs.DeleteKey(ignore + visibleInBackground);
+            EditorPrefs.DeleteKey(ignore + runInBackground);
+            EditorPrefs.DeleteKey(ignore + MSAAValue);
+
+        }
+
+
+        GUILayout.EndHorizontal();
+
+        GUILayout.EndScrollView();
+
+        GUILayout.FlexibleSpace();
+
+        GUILayout.BeginHorizontal();
+
+        if (numItems > 0)
+        {
+            if (GUILayout.Button("Accept All"))
+            {
+                // Only set those that have not been explicitly ignored.
+                if (!EditorPrefs.HasKey(ignore + buildTarget))
+                    EditorUserBuildSettings.SwitchActiveBuildTarget(BuildTargetGroup.Standalone, needed_BuildTarget);
+                if (!EditorPrefs.HasKey(ignore + showUnitySplashScreen))
+                    PlayerSettings.SplashScreen.show = needed_ShowUnitySplashScreen;
+                if (!EditorPrefs.HasKey(ignore + resizableWindow))
+                    PlayerSettings.resizableWindow = needed_ResizableWindow;
+                if (!EditorPrefs.HasKey(ignore + colorSpace))
+                    PlayerSettings.colorSpace = needed_ColorSpace;
+                if (!EditorPrefs.HasKey(ignore + gpuSkinning))
+                    PlayerSettings.gpuSkinning = needed_GPUSkinning;
+                if (!EditorPrefs.HasKey(ignore + runInBackground))
+                    PlayerSettings.runInBackground = needed_RunInBackground;
+                if (!EditorPrefs.HasKey(ignore + visibleInBackground))
+                    PlayerSettings.visibleInBackground = needed_VisibleInBackground;
+                if (!EditorPrefs.HasKey(ignore + MSAAValue))
+                    QualitySettings.antiAliasing = needed_MSAAValue;
+
+                EditorUtility.DisplayDialog("Accept All", "Settings applied", "Ok");
+                Close();
+            }
+
+            if (GUILayout.Button("Ignore All"))
+            {
+                if (EditorUtility.DisplayDialog("Ignore All", "Are you sure?", "Yes, Ignore All", "Cancel"))
+                {
+                    // Only ignore those that do not currently match our recommended settings.
+                    if (EditorUserBuildSettings.activeBuildTarget != needed_BuildTarget)
+                        EditorPrefs.SetBool(ignore + buildTarget, true);
+                    if (PlayerSettings.SplashScreen.show != needed_ShowUnitySplashScreen)
+                        EditorPrefs.SetBool(ignore + showUnitySplashScreen, true);
+                    if (PlayerSettings.resizableWindow != needed_ResizableWindow)
+                        EditorPrefs.SetBool(ignore + resizableWindow, true);
+                    if (PlayerSettings.colorSpace != needed_ColorSpace)
+                        EditorPrefs.SetBool(ignore + colorSpace, true);
+                    if (PlayerSettings.gpuSkinning != needed_GPUSkinning)
+                        EditorPrefs.SetBool(ignore + gpuSkinning, true);
+                    if (PlayerSettings.runInBackground != needed_RunInBackground)
+                        EditorPrefs.SetBool(ignore + runInBackground, true);
+                    if (PlayerSettings.visibleInBackground != needed_VisibleInBackground)
+                        EditorPrefs.SetBool(ignore + visibleInBackground, true);
+                    if (QualitySettings.antiAliasing != needed_MSAAValue)
+                        EditorPrefs.SetBool(ignore + MSAAValue, true);
+
+                    Close();
+                }
+            }
+        }
+        else if (GUILayout.Button("Close"))
+        {
+            Close();
+        }
+
+        GUILayout.EndHorizontal();
+    }
+}

Assets/ZED/Editor/Scripts/ZEDPluginInspector.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: eb3886527f920e748ab8a81335d73d4d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/New Scene.unity

@@ -0,0 +1,182 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!29 &1
+OcclusionCullingSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_OcclusionBakeSettings:
+    smallestOccluder: 5
+    smallestHole: 0.25
+    backfaceThreshold: 100
+  m_SceneGUID: 00000000000000000000000000000000
+  m_OcclusionCullingData: {fileID: 0}
+--- !u!104 &2
+RenderSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 9
+  m_Fog: 0
+  m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+  m_FogMode: 3
+  m_FogDensity: 0.01
+  m_LinearFogStart: 0
+  m_LinearFogEnd: 300
+  m_AmbientSkyColor: {r: 0.212, g: 0.227, b: 0.259, a: 1}
+  m_AmbientEquatorColor: {r: 0.114, g: 0.125, b: 0.133, a: 1}
+  m_AmbientGroundColor: {r: 0.047, g: 0.043, b: 0.035, a: 1}
+  m_AmbientIntensity: 1
+  m_AmbientMode: 0
+  m_SubtractiveShadowColor: {r: 0.42, g: 0.478, b: 0.627, a: 1}
+  m_SkyboxMaterial: {fileID: 10304, guid: 0000000000000000f000000000000000, type: 0}
+  m_HaloStrength: 0.5
+  m_FlareStrength: 1
+  m_FlareFadeSpeed: 3
+  m_HaloTexture: {fileID: 0}
+  m_SpotCookie: {fileID: 10001, guid: 0000000000000000e000000000000000, type: 0}
+  m_DefaultReflectionMode: 0
+  m_DefaultReflectionResolution: 128
+  m_ReflectionBounces: 1
+  m_ReflectionIntensity: 1
+  m_CustomReflection: {fileID: 0}
+  m_Sun: {fileID: 0}
+  m_IndirectSpecularColor: {r: 0.12731749, g: 0.13414757, b: 0.1210787, a: 1}
+  m_UseRadianceAmbientProbe: 0
+--- !u!157 &3
+LightmapSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 12
+  m_GIWorkflowMode: 1
+  m_GISettings:
+    serializedVersion: 2
+    m_BounceScale: 1
+    m_IndirectOutputScale: 1
+    m_AlbedoBoost: 1
+    m_EnvironmentLightingMode: 0
+    m_EnableBakedLightmaps: 1
+    m_EnableRealtimeLightmaps: 0
+  m_LightmapEditorSettings:
+    serializedVersion: 12
+    m_Resolution: 2
+    m_BakeResolution: 40
+    m_AtlasSize: 1024
+    m_AO: 0
+    m_AOMaxDistance: 1
+    m_CompAOExponent: 1
+    m_CompAOExponentDirect: 0
+    m_ExtractAmbientOcclusion: 0
+    m_Padding: 2
+    m_LightmapParameters: {fileID: 0}
+    m_LightmapsBakeMode: 1
+    m_TextureCompression: 1
+    m_FinalGather: 0
+    m_FinalGatherFiltering: 1
+    m_FinalGatherRayCount: 256
+    m_ReflectionCompression: 2
+    m_MixedBakeMode: 2
+    m_BakeBackend: 1
+    m_PVRSampling: 1
+    m_PVRDirectSampleCount: 32
+    m_PVRSampleCount: 512
+    m_PVRBounces: 2
+    m_PVREnvironmentSampleCount: 256
+    m_PVREnvironmentReferencePointCount: 2048
+    m_PVRFilteringMode: 1
+    m_PVRDenoiserTypeDirect: 1
+    m_PVRDenoiserTypeIndirect: 1
+    m_PVRDenoiserTypeAO: 1
+    m_PVRFilterTypeDirect: 0
+    m_PVRFilterTypeIndirect: 0
+    m_PVRFilterTypeAO: 0
+    m_PVREnvironmentMIS: 1
+    m_PVRCulling: 1
+    m_PVRFilteringGaussRadiusDirect: 1
+    m_PVRFilteringGaussRadiusIndirect: 5
+    m_PVRFilteringGaussRadiusAO: 2
+    m_PVRFilteringAtrousPositionSigmaDirect: 0.5
+    m_PVRFilteringAtrousPositionSigmaIndirect: 2
+    m_PVRFilteringAtrousPositionSigmaAO: 1
+    m_ExportTrainingData: 0
+    m_TrainingDataDestination: TrainingData
+    m_LightProbeSampleCountMultiplier: 4
+  m_LightingDataAsset: {fileID: 0}
+  m_LightingSettings: {fileID: 0}
+--- !u!196 &4
+NavMeshSettings:
+  serializedVersion: 2
+  m_ObjectHideFlags: 0
+  m_BuildSettings:
+    serializedVersion: 2
+    agentTypeID: 0
+    agentRadius: 0.5
+    agentHeight: 2
+    agentSlope: 45
+    agentClimb: 0.4
+    ledgeDropHeight: 0
+    maxJumpAcrossDistance: 0
+    minRegionArea: 2
+    manualCellSize: 0
+    cellSize: 0.16666667
+    manualTileSize: 0
+    tileSize: 256
+    accuratePlacement: 0
+    maxJobWorkers: 0
+    preserveTilesOutsideBounds: 0
+    debug:
+      m_Flags: 0
+  m_NavMeshData: {fileID: 0}
+--- !u!1001 &51675794
+PrefabInstance:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_Modification:
+    m_TransformParent: {fileID: 0}
+    m_Modifications:
+    - target: {fileID: 1180261165772202, guid: 76db3eb81fd21ae45bab5204e324ae42, type: 3}
+      propertyPath: m_Name
+      value: ZED_Rig_Mono
+      objectReference: {fileID: 0}
+    - target: {fileID: 4329734432191940, guid: 76db3eb81fd21ae45bab5204e324ae42, type: 3}
+      propertyPath: m_RootOrder
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4329734432191940, guid: 76db3eb81fd21ae45bab5204e324ae42, type: 3}
+      propertyPath: m_LocalPosition.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4329734432191940, guid: 76db3eb81fd21ae45bab5204e324ae42, type: 3}
+      propertyPath: m_LocalPosition.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4329734432191940, guid: 76db3eb81fd21ae45bab5204e324ae42, type: 3}
+      propertyPath: m_LocalPosition.z
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4329734432191940, guid: 76db3eb81fd21ae45bab5204e324ae42, type: 3}
+      propertyPath: m_LocalRotation.w
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 4329734432191940, guid: 76db3eb81fd21ae45bab5204e324ae42, type: 3}
+      propertyPath: m_LocalRotation.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4329734432191940, guid: 76db3eb81fd21ae45bab5204e324ae42, type: 3}
+      propertyPath: m_LocalRotation.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4329734432191940, guid: 76db3eb81fd21ae45bab5204e324ae42, type: 3}
+      propertyPath: m_LocalRotation.z
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4329734432191940, guid: 76db3eb81fd21ae45bab5204e324ae42, type: 3}
+      propertyPath: m_LocalEulerAnglesHint.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4329734432191940, guid: 76db3eb81fd21ae45bab5204e324ae42, type: 3}
+      propertyPath: m_LocalEulerAnglesHint.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4329734432191940, guid: 76db3eb81fd21ae45bab5204e324ae42, type: 3}
+      propertyPath: m_LocalEulerAnglesHint.z
+      value: 0
+      objectReference: {fileID: 0}
+    m_RemovedComponents: []
+  m_SourcePrefab: {fileID: 100100000, guid: 76db3eb81fd21ae45bab5204e324ae42, type: 3}

Assets/ZED/New Scene.unity.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 72c141afc3cc00642aca64c361a570ba
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/Prefabs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: abf163d8537431141ae2b6fddd19980c
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/Prefabs/ZED_Rig_Mono.prefab

@@ -0,0 +1,363 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1 &1180261165772202
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 4329734432191940}
+  - component: {fileID: 114491592745282986}
+  - component: {fileID: 114452247113840790}
+  m_Layer: 0
+  m_Name: ZED_Rig_Mono
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &4329734432191940
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1180261165772202}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 4476058232863476}
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!114 &114491592745282986
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1180261165772202}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 75b2a3ff7b847ca4490808f4c0432cd4, type: 3}
+  m_Name:
+  m_EditorClassIdentifier:
+  cameraID: 0
+  depthMode: 1
+  inputType: 0
+  resolution: 2
+  FPS: 60
+  svoInputFileName: Assets/Recording.svo
+  opencvCalibFile:
+  svoLoopBack: 1
+  svoRealTimeMode: 0
+  currentFrame: 0
+  numberFrameMax: 0
+  pauseSVOReading: 0
+  pauseLiveReading: 0
+  NeedNewFrameGrab: 0
+  streamInputIP: 127.0.0.1
+  streamInputPort: 30000
+  enableTracking: 1
+  enableSpatialMemory: 1
+  pathSpatialMemory:
+  estimateInitialPosition: 0
+  trackingIsStatic: 0
+  mappingResolutionPreset: 1
+  mappingRangePreset: 1
+  isMappingFilteringEnable: 1
+  isMappingTextured: 0
+  saveMeshWhenOver: 0
+  meshPath: Assets/ZEDMesh.obj
+  meshFilterParameters: 0
+  objectDetectionImageSyncMode: 0
+  objectDetectionTracking: 1
+  objectDetection2DMask: 0
+  objectDetectionModel: 1
+  bodyFitting: 0
+  maxRange: 40
+  bodyFormat: 1
+  SK_personDetectionConfidenceThreshold: 50
+  OD_personDetectionConfidenceThreshold: 60
+  vehicleDetectionConfidenceThreshold: 60
+  bagDetectionConfidenceThreshold: 60
+  animalDetectionConfidenceThreshold: 60
+  electronicsDetectionConfidenceThreshold: 60
+  fruitVegetableDetectionConfidenceThreshold: 60
+  sportDetectionConfidenceThreshold: 60
+  objectClassPersonFilter: 1
+  objectClassVehicleFilter: 1
+  objectClassBagFilter: 1
+  objectClassAnimalFilter: 1
+  objectClassElectronicsFilter: 1
+  objectClassFruitVegetableFilter: 1
+  objectClassSportFilter: 1
+  depthOcclusion: 1
+  postProcessing: 1
+  m_cameraBrightness: 100
+  enableImageEnhancement: 1
+  m_maxDepthRange: 40
+  svoOutputFileName: Assets/Recording.svo
+  svoOutputCompressionMode: 1
+  svoOutputBitrate: 0
+  svoOutputTargetFPS: 0
+  svoOutputTranscodeStreaming: 0
+  needRecordFrame: 0
+  enableStreaming: 0
+  streamingCodec: 0
+  streamingPort: 30000
+  bitrate: 8000
+  gopSize: -1
+  adaptativeBitrate: 0
+  chunkSize: 32768
+  streamingTargetFramerate: 0
+  fadeInOnStart: 1
+  dontDestroyOnLoad: 0
+  greySkybox: 1
+  m_confidenceThreshold: 100
+  m_textureConfidenceThreshold: 100
+  enableRightDepthMeasure: 0
+  showarrig: 0
+  enableIMUFusion: 1
+  enableSelfCalibration: 1
+  videoSettingsInitMode: 0
+  videoBrightness: 4
+  videoContrast: 4
+  videoHue: 0
+  videoSaturation: 4
+  videoAutoGainExposure: 1
+  videoGain: 10
+  videoExposure: 100
+  videoAutoWhiteBalance: 1
+  videoWhiteBalance: 3200
+  videoSharpness: 3
+  videoGamma: 5
+  videoLEDStatus: 1
+  cameraModel: '-'
+  cameraSerialNumber: '-'
+  cameraFirmware: '-'
+  versionZED: '-'
+  engineFPS: '-'
+  cameraFPS: '-'
+  HMDDevice: '-'
+  trackingState: '-'
+  objectDetectionFPS: '-'
+  sensingMode: 1
+  ZEDGrabError: 1
+  setIMUPriorInAR: 1
+  allowARPassThrough: 1
+  gravityRotation: {x: 0, y: 0, z: 0, w: 1}
+  ZEDSyncPosition: {x: 0, y: 0, z: 0}
+  HMDSyncPosition: {x: 0, y: 0, z: 0}
+  ZEDSyncRotation: {x: 0, y: 0, z: 0, w: 0}
+  HMDSyncRotation: {x: 0, y: 0, z: 0, w: 0}
+  advancedPanelOpen: 0
+  spatialMappingFoldoutOpen: 0
+  objectDetectionFoldoutOpen: 0
+  recordingFoldoutOpen: 0
+  streamingOutFoldoutOpen: 0
+  camControlFoldoutOpen: 0
+  zedRigDisplayer: {fileID: 0}
+--- !u!114 &114452247113840790
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1180261165772202}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 7c602d2dc840f0144911c39c566846cb, type: 3}
+  m_Name:
+  m_EditorClassIdentifier:
+--- !u!1 &1215292335019620
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 4213858372801928}
+  - component: {fileID: 33108888876671232}
+  - component: {fileID: 23936732132281150}
+  - component: {fileID: 114589286496521468}
+  m_Layer: 0
+  m_Name: Frame
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 0
+--- !u!4 &4213858372801928
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1215292335019620}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 1}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 4476058232863476}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!33 &33108888876671232
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1215292335019620}
+  m_Mesh: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!23 &23936732132281150
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1215292335019620}
+  m_Enabled: 1
+  m_CastShadows: 0
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_MotionVectors: 2
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RayTracingMode: 2
+  m_RayTraceProcedural: 0
+  m_RenderingLayerMask: 4294967295
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 2100000, guid: 851b6eeee88b1e04c8a22454a27421a1, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_ReceiveGI: 1
+  m_PreserveUVs: 1
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+  m_AdditionalVertexStreams: {fileID: 0}
+--- !u!114 &114589286496521468
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1215292335019620}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 313514277d565454383ea4c1a1f8beb9, type: 3}
+  m_Name:
+  m_EditorClassIdentifier:
+  showInNonZEDCameras: 0
+--- !u!1 &1795562263255876
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 4476058232863476}
+  - component: {fileID: 20287226139793380}
+  - component: {fileID: 114177934168037988}
+  m_Layer: 0
+  m_Name: Camera_Left
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &4476058232863476
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1795562263255876}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 4213858372801928}
+  m_Father: {fileID: 4329734432191940}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!20 &20287226139793380
+Camera:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1795562263255876}
+  m_Enabled: 1
+  serializedVersion: 2
+  m_ClearFlags: 3
+  m_BackGroundColor: {r: 0, g: 0, b: 0, a: 0}
+  m_projectionMatrixMode: 1
+  m_GateFitMode: 2
+  m_FOVAxisMode: 0
+  m_SensorSize: {x: 36, y: 24}
+  m_LensShift: {x: 0, y: 0}
+  m_FocalLength: 50
+  m_NormalizedViewPortRect:
+    serializedVersion: 2
+    x: 0
+    y: 0
+    width: 1
+    height: 1
+  near clip plane: 0.3
+  far clip plane: 1000
+  field of view: 60
+  orthographic: 0
+  orthographic size: 5
+  m_Depth: 0
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_RenderingPath: 1
+  m_TargetTexture: {fileID: 0}
+  m_TargetDisplay: 0
+  m_TargetEye: 0
+  m_HDR: 0
+  m_AllowMSAA: 1
+  m_AllowDynamicResolution: 0
+  m_ForceIntoRT: 0
+  m_OcclusionCulling: 0
+  m_StereoConvergence: 10
+  m_StereoSeparation: 0.022
+--- !u!114 &114177934168037988
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1795562263255876}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 0e14eefa25813a3489cc8b38d2027ac8, type: 3}
+  m_Name:
+  m_EditorClassIdentifier:
+  canvas: {fileID: 1215292335019620}
+  viewSide: 0
+  viewMode: 0
+  numberPointLights: 0
+  numberSpotLights: 0

Assets/ZED/Prefabs/ZED_Rig_Mono.prefab.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 76db3eb81fd21ae45bab5204e324ae42
+timeCreated: 1498041047
+licenseType: Free
+NativeFormatImporter:
+  mainObjectFileID: 100100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/Prefabs/ZED_Rig_Stereo.prefab

@@ -0,0 +1,775 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1 &1082135366421468
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 4795017531386668}
+  - component: {fileID: 20426257081025226}
+  - component: {fileID: 114025688240506870}
+  m_Layer: 0
+  m_Name: Right_eye
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &4795017531386668
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1082135366421468}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 4371821831063078}
+  m_Father: {fileID: 4138687653623062}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!20 &20426257081025226
+Camera:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1082135366421468}
+  m_Enabled: 1
+  serializedVersion: 2
+  m_ClearFlags: 2
+  m_BackGroundColor: {r: 0, g: 0, b: 0, a: 0}
+  m_projectionMatrixMode: 1
+  m_GateFitMode: 2
+  m_FOVAxisMode: 0
+  m_SensorSize: {x: 36, y: 24}
+  m_LensShift: {x: 0, y: 0}
+  m_FocalLength: 50
+  m_NormalizedViewPortRect:
+    serializedVersion: 2
+    x: 0
+    y: 0
+    width: 1
+    height: 1
+  near clip plane: 0.1
+  far clip plane: 1000
+  field of view: 56
+  orthographic: 0
+  orthographic size: 5
+  m_Depth: -1.1
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 3221225471
+  m_RenderingPath: 1
+  m_TargetTexture: {fileID: 0}
+  m_TargetDisplay: 0
+  m_TargetEye: 2
+  m_HDR: 1
+  m_AllowMSAA: 1
+  m_AllowDynamicResolution: 0
+  m_ForceIntoRT: 0
+  m_OcclusionCulling: 1
+  m_StereoConvergence: 10
+  m_StereoSeparation: 0.022
+--- !u!114 &114025688240506870
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1082135366421468}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 0e14eefa25813a3489cc8b38d2027ac8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  canvas: {fileID: 1473301405527320}
+  viewSide: 1
+  viewMode: 0
+  numberPointLights: 0
+  numberSpotLights: 0
+--- !u!1 &1175467483869550
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 4327115905062700}
+  - component: {fileID: 20846656237544980}
+  - component: {fileID: 114495480594432558}
+  m_Layer: 0
+  m_Name: Left_eye
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &4327115905062700
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1175467483869550}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 4552186382818458}
+  m_Father: {fileID: 4138687653623062}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!20 &20846656237544980
+Camera:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1175467483869550}
+  m_Enabled: 1
+  serializedVersion: 2
+  m_ClearFlags: 2
+  m_BackGroundColor: {r: 0, g: 0, b: 0, a: 0}
+  m_projectionMatrixMode: 1
+  m_GateFitMode: 2
+  m_FOVAxisMode: 0
+  m_SensorSize: {x: 36, y: 24}
+  m_LensShift: {x: 0, y: 0}
+  m_FocalLength: 50
+  m_NormalizedViewPortRect:
+    serializedVersion: 2
+    x: 0
+    y: 0
+    width: 1
+    height: 1
+  near clip plane: 0.1
+  far clip plane: 1000
+  field of view: 56
+  orthographic: 0
+  orthographic size: 5
+  m_Depth: -1
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 3221225471
+  m_RenderingPath: 1
+  m_TargetTexture: {fileID: 0}
+  m_TargetDisplay: 0
+  m_TargetEye: 1
+  m_HDR: 1
+  m_AllowMSAA: 1
+  m_AllowDynamicResolution: 0
+  m_ForceIntoRT: 0
+  m_OcclusionCulling: 1
+  m_StereoConvergence: 10
+  m_StereoSeparation: 0.022
+--- !u!114 &114495480594432558
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1175467483869550}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 0e14eefa25813a3489cc8b38d2027ac8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  canvas: {fileID: 1386713500692820}
+  viewSide: 0
+  viewMode: 0
+  numberPointLights: 0
+  numberSpotLights: 0
+--- !u!1 &1352114948813630
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 4138687653623062}
+  - component: {fileID: 81231073789856822}
+  - component: {fileID: 82354056950723132}
+  m_Layer: 0
+  m_Name: Camera_eyes
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &4138687653623062
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1352114948813630}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 4327115905062700}
+  - {fileID: 4795017531386668}
+  - {fileID: 4916666210046898}
+  m_Father: {fileID: 4309805032874704}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!81 &81231073789856822
+AudioListener:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1352114948813630}
+  m_Enabled: 1
+--- !u!82 &82354056950723132
+AudioSource:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1352114948813630}
+  m_Enabled: 1
+  serializedVersion: 4
+  OutputAudioMixerGroup: {fileID: 0}
+  m_audioClip: {fileID: 0}
+  m_PlayOnAwake: 1
+  m_Volume: 1
+  m_Pitch: 1
+  Loop: 0
+  Mute: 0
+  Spatialize: 0
+  SpatializePostEffects: 0
+  Priority: 128
+  DopplerLevel: 1
+  MinDistance: 1
+  MaxDistance: 500
+  Pan2D: 0
+  rolloffMode: 0
+  BypassEffects: 0
+  BypassListenerEffects: 0
+  BypassReverbZones: 0
+  rolloffCustomCurve:
+    serializedVersion: 2
+    m_Curve:
+    - serializedVersion: 3
+      time: 0
+      value: 1
+      inSlope: 0
+      outSlope: 0
+      tangentMode: 0
+      weightedMode: 0
+      inWeight: 0.33333334
+      outWeight: 0.33333334
+    - serializedVersion: 3
+      time: 1
+      value: 0
+      inSlope: 0
+      outSlope: 0
+      tangentMode: 0
+      weightedMode: 0
+      inWeight: 0.33333334
+      outWeight: 0.33333334
+    m_PreInfinity: 2
+    m_PostInfinity: 2
+    m_RotationOrder: 4
+  panLevelCustomCurve:
+    serializedVersion: 2
+    m_Curve:
+    - serializedVersion: 3
+      time: 0
+      value: 0
+      inSlope: 0
+      outSlope: 0
+      tangentMode: 0
+      weightedMode: 0
+      inWeight: 0.33333334
+      outWeight: 0.33333334
+    m_PreInfinity: 2
+    m_PostInfinity: 2
+    m_RotationOrder: 0
+  spreadCustomCurve:
+    serializedVersion: 2
+    m_Curve:
+    - serializedVersion: 3
+      time: 0
+      value: 0
+      inSlope: 0
+      outSlope: 0
+      tangentMode: 0
+      weightedMode: 0
+      inWeight: 0.33333334
+      outWeight: 0.33333334
+    m_PreInfinity: 2
+    m_PostInfinity: 2
+    m_RotationOrder: 0
+  reverbZoneMixCustomCurve:
+    serializedVersion: 2
+    m_Curve:
+    - serializedVersion: 3
+      time: 0
+      value: 1
+      inSlope: 0
+      outSlope: 0
+      tangentMode: 0
+      weightedMode: 0
+      inWeight: 0.33333334
+      outWeight: 0.33333334
+    m_PreInfinity: 2
+    m_PostInfinity: 2
+    m_RotationOrder: 0
+--- !u!1 &1386713500692820
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 4552186382818458}
+  - component: {fileID: 33967978859279694}
+  - component: {fileID: 23931263026373856}
+  - component: {fileID: 114833973883948664}
+  m_Layer: 0
+  m_Name: Frame
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &4552186382818458
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1386713500692820}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 1}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 4327115905062700}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!33 &33967978859279694
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1386713500692820}
+  m_Mesh: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!23 &23931263026373856
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1386713500692820}
+  m_Enabled: 1
+  m_CastShadows: 0
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_MotionVectors: 2
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RayTracingMode: 2
+  m_RenderingLayerMask: 4294967295
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 2100000, guid: 851b6eeee88b1e04c8a22454a27421a1, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_ReceiveGI: 1
+  m_PreserveUVs: 1
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+--- !u!114 &114833973883948664
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1386713500692820}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 313514277d565454383ea4c1a1f8beb9, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  showInNonZEDCameras: 1
+--- !u!1 &1473301405527320
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 4371821831063078}
+  - component: {fileID: 33507802862957374}
+  - component: {fileID: 23084009649085918}
+  - component: {fileID: 114346753093240460}
+  m_Layer: 0
+  m_Name: Frame
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &4371821831063078
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1473301405527320}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 1}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 4795017531386668}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!33 &33507802862957374
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1473301405527320}
+  m_Mesh: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!23 &23084009649085918
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1473301405527320}
+  m_Enabled: 1
+  m_CastShadows: 0
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_MotionVectors: 2
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RayTracingMode: 2
+  m_RenderingLayerMask: 4294967295
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 2100000, guid: 851b6eeee88b1e04c8a22454a27421a1, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_ReceiveGI: 1
+  m_PreserveUVs: 1
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+--- !u!114 &114346753093240460
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1473301405527320}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 313514277d565454383ea4c1a1f8beb9, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  showInNonZEDCameras: 1
+--- !u!1 &1603769914748404
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 4309805032874704}
+  - component: {fileID: 114878768509821778}
+  - component: {fileID: 114711245158774928}
+  m_Layer: 0
+  m_Name: ZED_Rig_Stereo
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &4309805032874704
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1603769914748404}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 4138687653623062}
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!114 &114878768509821778
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1603769914748404}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 7c602d2dc840f0144911c39c566846cb, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+--- !u!114 &114711245158774928
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1603769914748404}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 75b2a3ff7b847ca4490808f4c0432cd4, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  cameraID: 0
+  depthMode: 1
+  inputType: 0
+  resolution: 2
+  FPS: 60
+  svoInputFileName: 
+  opencvCalibFile: 
+  svoLoopBack: 1
+  svoRealTimeMode: 0
+  currentFrame: 0
+  numberFrameMax: 0
+  pauseSVOReading: 0
+  pauseLiveReading: 0
+  NeedNewFrameGrab: 0
+  streamInputIP: 127.0.0.1
+  streamInputPort: 30000
+  enableTracking: 1
+  enableSpatialMemory: 1
+  pathSpatialMemory: 
+  estimateInitialPosition: 0
+  trackingIsStatic: 0
+  mappingResolutionPreset: 1
+  mappingRangePreset: 1
+  isMappingFilteringEnable: 0
+  isMappingTextured: 0
+  saveMeshWhenOver: 0
+  meshPath: Assets/ZEDMesh.obj
+  meshFilterParameters: 0
+  objectDetectionImageSyncMode: 0
+  objectDetectionTracking: 1
+  objectDetection2DMask: 0
+  objectDetectionModel: 0
+  bodyFitting: 0
+  maxRange: 40
+  SK_personDetectionConfidenceThreshold: 50
+  OD_personDetectionConfidenceThreshold: 60
+  vehicleDetectionConfidenceThreshold: 60
+  bagDetectionConfidenceThreshold: 60
+  animalDetectionConfidenceThreshold: 60
+  electronicsDetectionConfidenceThreshold: 60
+  fruitVegetableDetectionConfidenceThreshold: 60
+  objectClassPersonFilter: 1
+  objectClassVehicleFilter: 1
+  objectClassBagFilter: 1
+  objectClassAnimalFilter: 1
+  objectClassElectronicsFilter: 1
+  objectClassFruitVegetableFilter: 1
+  depthOcclusion: 1
+  postProcessing: 1
+  m_cameraBrightness: 100
+  enableImageEnhancement: 1
+  m_maxDepthRange: 40
+  svoOutputFileName: Assets/Recording.svo
+  svoOutputCompressionMode: 1
+  svoOutputBitrate: 0
+  svoOutputTargetFPS: 0
+  svoOutputTranscodeStreaming: 0
+  needRecordFrame: 0
+  enableStreaming: 0
+  streamingCodec: 0
+  streamingPort: 30000
+  bitrate: 8000
+  gopSize: -1
+  adaptativeBitrate: 0
+  chunkSize: 8096
+  streamingTargetFramerate: 0
+  fadeInOnStart: 1
+  dontDestroyOnLoad: 0
+  greySkybox: 1
+  m_confidenceThreshold: 100
+  m_textureConfidenceThreshold: 100
+  enableRightDepthMeasure: 0
+  showarrig: 0
+  enableIMUFusion: 1
+  enableSelfCalibration: 1
+  videoSettingsInitMode: 0
+  videoBrightness: 4
+  videoContrast: 4
+  videoHue: 0
+  videoSaturation: 4
+  videoAutoGainExposure: 1
+  videoGain: 10
+  videoExposure: 100
+  videoAutoWhiteBalance: 1
+  videoWhiteBalance: 3200
+  videoSharpness: 3
+  videoGamma: 5
+  videoLEDStatus: 1
+  cameraModel: '-'
+  cameraSerialNumber: '-'
+  cameraFirmware: '-'
+  versionZED: '-'
+  engineFPS: '-'
+  cameraFPS: '-'
+  HMDDevice: '-'
+  trackingState: '-'
+  objectDetectionFPS: '-'
+  sensingMode: 1
+  setIMUPriorInAR: 1
+  allowARPassThrough: 1
+  gravityRotation: {x: 0, y: 0, z: 0, w: 1}
+  ZEDSyncPosition: {x: 0, y: 0, z: 0}
+  HMDSyncPosition: {x: 0, y: 0, z: 0}
+  ZEDSyncRotation: {x: 0, y: 0, z: 0, w: 0}
+  HMDSyncRotation: {x: 0, y: 0, z: 0, w: 0}
+  advancedPanelOpen: 0
+  spatialMappingFoldoutOpen: 0
+  objectDetectionFoldoutOpen: 0
+  recordingFoldoutOpen: 0
+  streamingOutFoldoutOpen: 0
+  camControlFoldoutOpen: 0
+  zedRigDisplayer: {fileID: 0}
+--- !u!1 &1721814514466412
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 4916666210046898}
+  - component: {fileID: 33546770458599288}
+  - component: {fileID: 65873696903358950}
+  - component: {fileID: 23993465884346736}
+  m_Layer: 0
+  m_Name: Body
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 0
+--- !u!4 &4916666210046898
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1721814514466412}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 1}
+  m_LocalScale: {x: 0.1, y: 0.1, z: 0.1}
+  m_Children: []
+  m_Father: {fileID: 4138687653623062}
+  m_RootOrder: 2
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!33 &33546770458599288
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1721814514466412}
+  m_Mesh: {fileID: 10202, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!65 &65873696903358950
+BoxCollider:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1721814514466412}
+  m_Material: {fileID: 0}
+  m_IsTrigger: 0
+  m_Enabled: 1
+  serializedVersion: 2
+  m_Size: {x: 1, y: 1, z: 1}
+  m_Center: {x: 0, y: 0, z: 0}
+--- !u!23 &23993465884346736
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1721814514466412}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RayTracingMode: 2
+  m_RenderingLayerMask: 4294967295
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 10303, guid: 0000000000000000f000000000000000, type: 0}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_ReceiveGI: 1
+  m_PreserveUVs: 1
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0

Assets/ZED/Prefabs/ZED_Rig_Stereo.prefab.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: e13ee7e0790c7d243b7aa67fe604acac
+timeCreated: 1508143571
+licenseType: Free
+NativeFormatImporter:
+  mainObjectFileID: 100100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 87c0c7dfaee0d064aaac41b0e8a30172
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 19694ee8b13410846876b1cb3f7e44dc
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: a454527171be9de4e80f21714cabdbd9
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 986029355532d1e4d808b63634886175
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/GUI.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 6f51af423be728442b7a2b00df2b8720
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/GUI/Mat_ZED_Fade.mat

@@ -0,0 +1,77 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Mat_ZED_Fade
+  m_Shader: {fileID: 4800000, guid: 43bb64123ea14da43b05700aac6454e4, type: 3}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _FadeColor: {r: 0, g: 0, b: 0, a: 1}

Assets/ZED/SDK/Helpers/Resources/Materials/GUI/Mat_ZED_Fade.mat.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 00c0cf49a09a01642b7e3c4b889b25f8
+timeCreated: 1497361641
+licenseType: Free
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/GUI/Mat_ZED_UITop.mat

@@ -0,0 +1,83 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Mat_ZED_UITop
+  m_Shader: {fileID: 4800000, guid: 5858f212fb4e7c64180b7d9a541fc41f, type: 3}
+  m_ShaderKeywords: _EMISSION
+  m_LightmapFlags: 1
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _ColorMask: 15
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _Stencil: 0
+    - _StencilComp: 8
+    - _StencilOp: 0
+    - _StencilReadMask: 255
+    - _StencilWriteMask: 148
+    - _UVSec: 0
+    - _UseUIAlphaClip: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/ZED/SDK/Helpers/Resources/Materials/GUI/Mat_ZED_UITop.mat.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 2f69e3c5db673ac4bb12f553d1dcc24e
+timeCreated: 1493218205
+licenseType: Free
+NativeFormatImporter:
+  mainObjectFileID: -1
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/Lighting.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 5abbe3cbc1a714c43be5d7c8fd93f32e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/Lighting/Mat_ZED_Deferred.mat

@@ -0,0 +1,40 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Mat_ZED_Deferred
+  m_Shader: {fileID: 4800000, guid: 9ed9dd24a1668264aa670d2bac004684, type: 3}
+  m_ShaderKeywords: _EMISSION
+  m_LightmapFlags: 1
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - <noninit>:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CameraTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DepthXYZTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - <noninit>: 1
+    m_Colors:
+    - <noninit>: {r: 1, g: 1, b: 1, a: 1}

Assets/ZED/SDK/Helpers/Resources/Materials/Lighting/Mat_ZED_Deferred.mat.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: ef1a21d25d23a3f4690512c2d75a67a1
+timeCreated: 1490201219
+licenseType: Free
+NativeFormatImporter:
+  mainObjectFileID: -1
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/Lighting/Mat_ZED_Deferred_Lighting.mat

@@ -0,0 +1,88 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Mat_ZED_Deferred_Lighting
+  m_Shader: {fileID: 4800000, guid: fc101261ffd098d4182e59354a4e5e85, type: 3}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _LightTexture0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _LightTextureB0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ShadowMapTexture:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/ZED/SDK/Helpers/Resources/Materials/Lighting/Mat_ZED_Deferred_Lighting.mat.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: e9b21b07f1d69d846b0ce5efde2c42a5
+timeCreated: 1493719959
+licenseType: Free
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/Lighting/Mat_ZED_Forward.mat

@@ -0,0 +1,44 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Mat_ZED_Forward
+  m_Shader: {fileID: 4800000, guid: 4ab87418df3c64d4680282c62e272194, type: 3}
+  m_ShaderKeywords: _EMISSION
+  m_LightmapFlags: 1
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - <noninit>:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CameraTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DepthXYZTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - <noninit>: 1
+    m_Colors:
+    - <noninit>: {r: 1, g: 1, b: 1, a: 1}

Assets/ZED/SDK/Helpers/Resources/Materials/Lighting/Mat_ZED_Forward.mat.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: a4099156e089e9146b1a4eb5c870ce56
+timeCreated: 1489659519
+licenseType: Free
+NativeFormatImporter:
+  mainObjectFileID: -1
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/Lighting/Mat_ZED_Forward_Lighting.mat

@@ -0,0 +1,103 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Mat_ZED_Forward_Lighting
+  m_Shader: {fileID: 4800000, guid: 9a7011437ca03a24c8c5d45ccdf91e30, type: 3}
+  m_ShaderKeywords: DIRECTIONALLIGHTEFFECT_ON _EMISSION
+  m_LightmapFlags: 1
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CameraTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DepthXYZTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _LightTexture0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _LightTextureB0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ShadowMapTexture:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _MaxDepth: 20
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    - directionalLightEffect: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/ZED/SDK/Helpers/Resources/Materials/Lighting/Mat_ZED_Forward_Lighting.mat.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 851b6eeee88b1e04c8a22454a27421a1
+timeCreated: 1485269531
+licenseType: Free
+NativeFormatImporter:
+  mainObjectFileID: -1
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/Lighting/Mat_ZED_Forward_Lighting_URP.mat

@@ -0,0 +1,104 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Mat_ZED_Forward_Lighting_URP
+  m_Shader: {fileID: 4800000, guid: 2809325ac48130642a19c357ce7d5200, type: 3}
+  m_ShaderKeywords: DIRECTIONALLIGHTEFFECT_ON _EMISSION
+  m_LightmapFlags: 1
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CameraTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DepthXYZTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _LightTexture0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _LightTextureB0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ShadowMapTexture:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _MaxDepth: 20
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    - directionalLightEffect: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+  m_BuildTextureStacks: []

Assets/ZED/SDK/Helpers/Resources/Materials/Lighting/Mat_ZED_Forward_Lighting_URP.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 27e47bd369171664d8041076064c4862
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/Lighting/Mat_ZED_HDRP_Lit.mat

@@ -0,0 +1,181 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &-7498311340297174645
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 11
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Mat_ZED_HDRP_Lit
+  m_Shader: {fileID: -6465566751694194690, guid: 82f08abc9c8ae3842b12da59567af90e,
+    type: 3}
+  m_ShaderKeywords: _DEPTHOFFSET_ON _DISABLE_DECALS _DISABLE_SSR _DISABLE_SSR_TRANSPARENT
+  m_LightmapFlags: 1
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 2000
+  stringTagMap: {}
+  disabledShaderPasses:
+  - TransparentDepthPrepass
+  - TransparentDepthPostpass
+  - TransparentBackface
+  - RayTracingPrepass
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CameraTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DepthXYZTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _LightTexture0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _LightTextureB0:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ShadowMapTexture:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_Lightmaps:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_LightmapsInd:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_ShadowMasks:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AddPrecomputedVelocity: 0
+    - _AlphaCutoffEnable: 0
+    - _AlphaDstBlend: 0
+    - _AlphaSrcBlend: 1
+    - _AlphaToMask: 0
+    - _AlphaToMaskInspectorValue: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _CullModeForward: 2
+    - _Cutoff: 0.5
+    - _DepthOffsetEnable: 1
+    - _DetailNormalMapScale: 1
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedNormalMode: 2
+    - _DstBlend: 0
+    - _EnableBlendModePreserveSpecularLighting: 1
+    - _EnableFogOnTransparent: 1
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _MaxDepth: 20
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _OpaqueCullMode: 2
+    - _Parallax: 0.02
+    - _RayTracing: 0
+    - _ReceivesSSR: 0
+    - _ReceivesSSRTransparent: 0
+    - _RefractionModel: 0
+    - _RenderQueueType: 1
+    - _RequireSplitLighting: 0
+    - _Smoothness: 0
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _StencilRef: 0
+    - _StencilRefDepth: 0
+    - _StencilRefDistortionVec: 4
+    - _StencilRefGBuffer: 2
+    - _StencilRefMV: 32
+    - _StencilWriteMask: 6
+    - _StencilWriteMaskDepth: 8
+    - _StencilWriteMaskDistortionVec: 4
+    - _StencilWriteMaskGBuffer: 14
+    - _StencilWriteMaskMV: 40
+    - _SupportDecals: 0
+    - _SurfaceType: 0
+    - _TransparentBackfaceEnable: 0
+    - _TransparentCullMode: 2
+    - _TransparentDepthPostpassEnable: 0
+    - _TransparentDepthPrepassEnable: 0
+    - _TransparentSortPriority: 0
+    - _TransparentWritingMotionVec: 0
+    - _TransparentZWrite: 0
+    - _UVSec: 0
+    - _UseShadowThreshold: 0
+    - _ZEDFactorAffectReal: 0.5
+    - _ZTestDepthEqualForOpaque: 3
+    - _ZTestGBuffer: 4
+    - _ZTestTransparent: 4
+    - _ZWrite: 1
+    - directionalLightEffect: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
+    - _EmissionColor: {r: 1, g: 1, b: 1, a: 1}
+  m_BuildTextureStacks: []

Assets/ZED/SDK/Helpers/Resources/Materials/Lighting/Mat_ZED_HDRP_Lit.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 87c74431273690341b3fbecaa08efb00
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/Lighting/Mat_ZED_Hide.mat

@@ -0,0 +1,76 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Mat_ZED_Hide
+  m_Shader: {fileID: 4800000, guid: 9efc7125da4425d428044fc4c0d72ff7, type: 3}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/ZED/SDK/Helpers/Resources/Materials/Lighting/Mat_ZED_Hide.mat.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: d3cc4ab8bb8b08649bd486af3dc7f689
+timeCreated: 1492502480
+licenseType: Free
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/PlaneDetection.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: cb9f7fadc6274d9429b2a774bfcf69d3
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/PlaneDetection/Mat_ZED_Geometry_WirePlane.mat

@@ -0,0 +1,87 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Mat_ZED_Geometry_WirePlane
+  m_Shader: {fileID: 4800000, guid: 0a38398fb6c3e8e4f82320212680ec72, type: 3}
+  m_ShaderKeywords: _ALPHAPREMULTIPLY_ON _EMISSION _GLOSSYREFLECTIONS_OFF _SPECULARHIGHLIGHTS_OFF
+  m_LightmapFlags: 0
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _Bump:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _Alpha: 1
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 10
+    - _Gain: 1.5
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 0
+    - _Metallic: 0
+    - _Mode: 3
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _Specular: 15
+    - _SpecularHighlights: 0
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _WireThickness: 18
+    - _ZWrite: 0
+    m_Colors:
+    - _BaseColor: {r: 0, g: 0.91724133, b: 1, a: 0.08}
+    - _Color: {r: 0, g: 0.747, b: 1, a: 0.422}
+    - _DiffuseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 1, g: 1, b: 1, a: 1}
+    - _WireColor: {r: 0.86764705, g: 0.076557115, b: 0.5839459, a: 0.684}

Assets/ZED/SDK/Helpers/Resources/Materials/PlaneDetection/Mat_ZED_Geometry_WirePlane.mat.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: c075616f3f471c14f9237aa9d8ef5a7b
+timeCreated: 1521648099
+licenseType: Free
+NativeFormatImporter:
+  mainObjectFileID: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/PointCloud.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 7fe5ad5909f6551499e1e4d0d6ae288f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/PointCloud/Mat_ZED_FusedPC_Disk.mat

@@ -0,0 +1,79 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Mat_ZED_FusedPC_Disk
+  m_Shader: {fileID: 4800000, guid: fce2bfdde1b07ed498f963759f3823aa, type: 3}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _PointSize: 0.05
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _Tint: {r: 0.5, g: 0.5, b: 0.5, a: 1}

Assets/ZED/SDK/Helpers/Resources/Materials/PointCloud/Mat_ZED_FusedPC_Disk.mat.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+<<<<<<< HEAD
+guid: 0f0e0f258a10d9d4582614d34e40ef46
+=======
+<<<<<<< HEAD:ZEDCamera/Assets/ZED/SDK/Helpers/Resources/Materials/PointCloud/Ressources/Textures/Unlit_UnlitWithMask.mat.meta
+guid: 501a9c78f0d9ebb40846d33511ab14af
+=======
+guid: 0f0e0f258a10d9d4582614d34e40ef46
+>>>>>>> cc28bdd3ae6ca1ad7e437fa7af45876ea2fe1e1c:ZEDCamera/Assets/ZED/SDK/Helpers/Resources/Materials/PointCloud/Mat_ZED_FusedPC_Disk.mat.meta
+>>>>>>> cc28bdd3ae6ca1ad7e437fa7af45876ea2fe1e1c
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/PointCloud/Mat_ZED_FusedPC_Point.mat

@@ -0,0 +1,80 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Mat_ZED_FusedPC_Point
+  m_Shader: {fileID: 4800000, guid: 5dcaf6248241a0545a4ebba9b0c93c68, type: 3}
+  m_ShaderKeywords: _DISTANCE_ON
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _Distance: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _PointSize: 0.05
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _Tint: {r: 0.5, g: 0.5, b: 0.5, a: 1}

Assets/ZED/SDK/Helpers/Resources/Materials/PointCloud/Mat_ZED_FusedPC_Point.mat.meta

@@ -0,0 +1,23 @@
+fileFormatVersion: 2
+<<<<<<< HEAD
+guid: 71b4e64e2d9a25c40972bcca9d0d5aef
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 0
+  userData:
+  assetBundleName:
+  assetBundleVariant:
+=======
+<<<<<<< HEAD:ZEDCamera/Assets/ZED/SDK/Helpers/Resources/Materials/PointCloud/Scene/SkeletonDemo.unity.meta
+guid: f535049b49f244347b6c7b6622796d14
+DefaultImporter:
+=======
+guid: 71b4e64e2d9a25c40972bcca9d0d5aef
+NativeFormatImporter:
+>>>>>>> cc28bdd3ae6ca1ad7e437fa7af45876ea2fe1e1c:ZEDCamera/Assets/ZED/SDK/Helpers/Resources/Materials/PointCloud/Mat_ZED_FusedPC_Point.mat.meta
+  externalObjects: {}
+  mainObjectFileID: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+>>>>>>> cc28bdd3ae6ca1ad7e437fa7af45876ea2fe1e1c

Assets/ZED/SDK/Helpers/Resources/Materials/PointCloud/Mat_ZED_PointCloud.mat

@@ -0,0 +1,78 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Mat_ZED_PointCloud
+  m_Shader: {fileID: 4800000, guid: e559735f38c1ab04bb202a47093cfd4f, type: 3}
+  m_ShaderKeywords: _EMISSION
+  m_LightmapFlags: 1
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _Size: 0.1
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/ZED/SDK/Helpers/Resources/Materials/PointCloud/Mat_ZED_PointCloud.mat.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 2de1863fc62ea7348a7813819b2c3573
+timeCreated: 1488185743
+licenseType: Free
+NativeFormatImporter:
+  mainObjectFileID: -1
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/PostProcessing.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 7852c1d35f3f12c4589f1a9d7dd1aaf2
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/PostProcessing/Mat_ZED_Blit.mat

@@ -0,0 +1,76 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Mat_ZED_Blit
+  m_Shader: {fileID: 4800000, guid: 0e1a1e36ac2ada24ca19515d7e86836c, type: 3}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/ZED/SDK/Helpers/Resources/Materials/PostProcessing/Mat_ZED_Blit.mat.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 03161342bc5544849bea0803c778c5e1
+timeCreated: 1497516400
+licenseType: Free
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/PostProcessing/Mat_ZED_Blur.mat

@@ -0,0 +1,76 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Mat_ZED_Blur
+  m_Shader: {fileID: 4800000, guid: ff7f942218f18e54d8ad8c85b234c74c, type: 3}
+  m_ShaderKeywords: _EMISSION
+  m_LightmapFlags: 1
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/ZED/SDK/Helpers/Resources/Materials/PostProcessing/Mat_ZED_Blur.mat.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 6a7ece4baaea8f24a9a21808bb3eacba
+timeCreated: 1487762593
+licenseType: Free
+NativeFormatImporter:
+  mainObjectFileID: -1
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/PostProcessing/Mat_ZED_MaskCompositor.mat

@@ -0,0 +1,76 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Mat_ZED_MaskCompositor
+  m_Shader: {fileID: 4800000, guid: cbcdddda683f5cd4fba55830221ff820, type: 3}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/ZED/SDK/Helpers/Resources/Materials/PostProcessing/Mat_ZED_MaskCompositor.mat.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: d7bb14bcaa5d48a4bac7de222d43b075
+timeCreated: 1504261949
+licenseType: Free
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/PostProcessing/Mat_ZED_PostProcessing.mat

@@ -0,0 +1,77 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Mat_ZED_PostProcessing
+  m_Shader: {fileID: 4800000, guid: 3a59afe186bbfc84281b438294e4f41a, type: 3}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _MinBlack: 0.01
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/ZED/SDK/Helpers/Resources/Materials/PostProcessing/Mat_ZED_PostProcessing.mat.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: d66b181e9abec0e4ca7331c61952ec6e
+timeCreated: 1493304484
+licenseType: Free
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/PostProcessing/Mat_ZED_Stencil2Mask.mat

@@ -0,0 +1,76 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Mat_ZED_Stencil2Mask
+  m_Shader: {fileID: 4800000, guid: 9c1bda7cee8bf92488dfaf7a2963af2b, type: 3}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/ZED/SDK/Helpers/Resources/Materials/PostProcessing/Mat_ZED_Stencil2Mask.mat.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 52e5832abee9d3f40baffe96ff2c7fe5
+timeCreated: 1504252789
+licenseType: Free
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/PostProcessing/Mat_ZED_Surface_PostProcessing.mat

@@ -0,0 +1,76 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Mat_ZED_Surface_PostProcessing
+  m_Shader: {fileID: 4800000, guid: f408df2c9d38f0a4788253fb1d9c106e, type: 3}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/ZED/SDK/Helpers/Resources/Materials/PostProcessing/Mat_ZED_Surface_PostProcessing.mat.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: dfb5c9589ed812b4aa5fc77e82cf8345
+timeCreated: 1509374688
+licenseType: Free
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/PostProcessing/Mat_ZED_Unlit_PostProcessing.mat

@@ -0,0 +1,76 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Mat_ZED_Unlit_PostProcessing
+  m_Shader: {fileID: 4800000, guid: 5efe839939b3d624b9bed96502a68c76, type: 3}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/ZED/SDK/Helpers/Resources/Materials/PostProcessing/Mat_ZED_Unlit_PostProcessing.mat.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 83e62a664f3d9974cb0d07cd7c52ff51
+timeCreated: 1509374659
+licenseType: Free
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/SpatialMapping.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 1e9ff365b7bf3db458f7be2c8b1a37f4
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/SpatialMapping/Mat_ZED_Geometry_Wireframe.mat

@@ -0,0 +1,87 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Mat_ZED_Geometry_Wireframe
+  m_Shader: {fileID: 4800000, guid: ff28f5e045891fc41ab0d0d9a402b51f, type: 3}
+  m_ShaderKeywords: _ALPHAPREMULTIPLY_ON _EMISSION _GLOSSYREFLECTIONS_OFF _SPECULARHIGHLIGHTS_OFF
+  m_LightmapFlags: 0
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _Bump:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _Alpha: 1
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 10
+    - _Gain: 1.5
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 0
+    - _Metallic: 0
+    - _Mode: 3
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _Specular: 15
+    - _SpecularHighlights: 0
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _WireThickness: 0
+    - _ZWrite: 0
+    m_Colors:
+    - _BaseColor: {r: 0, g: 0.91724133, b: 1, a: 0.08}
+    - _Color: {r: 0, g: 0.747, b: 1, a: 0.422}
+    - _DiffuseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 1, g: 1, b: 1, a: 1}
+    - _WireColor: {r: 0.17254902, g: 0.6156863, b: 0.87058824, a: 0.684}

Assets/ZED/SDK/Helpers/Resources/Materials/SpatialMapping/Mat_ZED_Geometry_Wireframe.mat.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: bd72e0c92cbd1f14ca6810f4cfbfaabb
+timeCreated: 1507191536
+licenseType: Free
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/SpatialMapping/Mat_ZED_PostProcess_Blend.mat

@@ -0,0 +1,77 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Mat_ZED_PostProcess_Blend
+  m_Shader: {fileID: 4800000, guid: c5e2b5e6e2fe3274bbda6f48f9af188e, type: 3}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _WireColor: {r: 0.17254902, g: 0.6156863, b: 0.87058824, a: 1}

Assets/ZED/SDK/Helpers/Resources/Materials/SpatialMapping/Mat_ZED_PostProcess_Blend.mat.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: ac9fb22227b6d2e46bf891b6a64c97fe
+timeCreated: 1492505149
+licenseType: Free
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/SpatialMapping/Mat_ZED_Texture.mat

@@ -0,0 +1,78 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Mat_ZED_Texture
+  m_Shader: {fileID: 4800000, guid: bde3233f98eca534c877a46041c3801f, type: 3}
+  m_ShaderKeywords: _EMISSION
+  m_LightmapFlags: 1
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+  m_BuildTextureStacks: []

Assets/ZED/SDK/Helpers/Resources/Materials/SpatialMapping/Mat_ZED_Texture.mat.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: c787298985314f945a4a7c3d080cd89f
+timeCreated: 1490888912
+licenseType: Free
+NativeFormatImporter:
+  mainObjectFileID: -1
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/SpatialMapping/Mat_ZED_Wireframe_Video_Overlay.mat

@@ -0,0 +1,77 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Mat_ZED_Wireframe_Video_Overlay
+  m_Shader: {fileID: 4800000, guid: 332ca72ae3411344e82dcf92913f57dd, type: 3}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 3000
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _WireColor: {r: 0.17254902, g: 0.6156863, b: 0.87058824, a: 1}

Assets/ZED/SDK/Helpers/Resources/Materials/SpatialMapping/Mat_ZED_Wireframe_Video_Overlay.mat.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 274cca6d7c9a5c0498aa8e144d3b06e2
+NativeFormatImporter:
+  mainObjectFileID: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/Unlit.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e3c76162805e85c4bb57e3609e8e041d
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/Unlit/Mat_ZED_Unlit.mat

@@ -0,0 +1,76 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Mat_ZED_Unlit
+  m_Shader: {fileID: 4800000, guid: e3ce76ae505317a40b8f52c2aac6fb9c, type: 3}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/ZED/SDK/Helpers/Resources/Materials/Unlit/Mat_ZED_Unlit.mat.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 2c8135c078212eb4d960bd36b9d8e9f5
+timeCreated: 1508144330
+licenseType: Free
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/Materials/Unlit/Mat_ZED_Unlit_BGRA.mat

@@ -0,0 +1,82 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Mat_ZED_Unlit_BGRA
+  m_Shader: {fileID: 4800000, guid: 22452c6b17a58c84cb92a9c44daee63f, type: 3}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - <noninit>:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - <noninit>: 1
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - <noninit>: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/ZED/SDK/Helpers/Resources/Materials/Unlit/Mat_ZED_Unlit_BGRA.mat.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: b09f48c1b07e9c7499e146e91844a0c7
+timeCreated: 1493743949
+licenseType: Free
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/PrefabsUI.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c047047898635b744ada4a26825bc70f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ZED/SDK/Helpers/Resources/PrefabsUI/Animation.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 928930a422c0a8347a787cc89ff8078f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: