static void OnSceneSaving(Scene scene, string path)
{
// Creating a new scene can trigger this callback with an invalid scene
if (!scene.IsValid())
{
return;
}
// Hide the OnDestroyNotifier so it is not saved
foreach (var root in scene.GetRootGameObjects())
{
var notifier = root.GetComponentInChildren <OnDestroyNotifier>();
if (notifier != null)
{
notifier.gameObject.hideFlags = HideFlags.HideAndDontSave;
}
}
var session = MarsRuntimeUtils.GetMarsSessionInScene(scene);
if (session)
{
session.CheckCapabilities();
}
}
void InitializeCameraProvider()
{
var camera = MarsRuntimeUtils.GetActiveCamera(true);
if (camera)
{
m_ARCameraBackground = camera.GetComponent <ARCameraBackground>();
if (!m_ARCameraBackground)
{
m_ARCameraBackground = camera.gameObject.AddComponent <ARCameraBackground>();
m_NewARCameraBackground = m_ARCameraBackground;
m_ARCameraBackground.hideFlags = HideFlags.DontSave;
}
m_ARCameraManager = camera.GetComponent <ARCameraManager>();
if (!m_ARCameraManager)
{
m_ARCameraManager = camera.gameObject.AddComponent <ARCameraManager>();
m_NewARCameraManager = m_ARCameraManager;
m_ARCameraManager.hideFlags = HideFlags.DontSave;
}
m_ARCameraManager.frameReceived += ARCameraManagerOnFrameReceived;
}
m_CurrentProjectionMatrix = null;
}
void IFunctionalityProvider.LoadProvider()
{
ARFoundationSessionProvider.RequireARSession();
var camera = MarsRuntimeUtils.GetActiveCamera(true);
if (camera)
{
m_ARCameraManager = camera.gameObject.GetComponent <ARCameraManager>();
if (!m_ARCameraManager)
{
m_ARCameraManager = camera.gameObject.AddComponent <ARCameraManager>();
m_NewARCameraManager = m_ARCameraManager;
m_ARCameraManager.hideFlags = HideFlags.DontSave;
}
#if ARFOUNDATION_4_OR_NEWER
m_ARCameraManager.requestedLightEstimation = LightEstimation.AmbientColor
| LightEstimation.AmbientIntensity
| LightEstimation.AmbientSphericalHarmonics
| LightEstimation.MainLightIntensity
| LightEstimation.MainLightDirection;
#else
m_ARCameraManager.lightEstimationMode = LightEstimationMode.AmbientIntensity;
#endif
}
else
{
throw new InvalidOperationException("No camera found");
}
m_ARCameraManager.frameReceived += ARCameraFrameEvent;
}
void OnDrawGizmos()
{
#if UNITY_EDITOR
if (!MarsDebugSettings.SimDiscoveryImageMarkerDebug || m_SynthMarkers.Count == 0)
{
return;
}
// leaving blank frames helps with visual intelligibility of the debug data while moving the camera
const int drawingFrameInterval = 6;
if (Time.frameCount % drawingFrameInterval != 0)
{
return;
}
var marsCam = MarsRuntimeUtils.GetActiveCamera();
var camTrans = marsCam.transform;
var camPosition = camTrans.position;
// draw camera forward, as a visual reference for the tracking lines
Debug.DrawLine(camPosition, camPosition + camTrans.forward, Color.cyan, 0.1f);
foreach (var marker in m_SynthMarkers)
{
var trackingResult = GetMarsCameraTrackingQuality(marker, marsCam);
DrawMarkerTrackingDebugLine(marker.transform, camTrans, trackingResult);
}
#endif
}
public void SetupLandmark(ILandmarkController landmark)
{
// Use MARS session camera as the default target for "closest" landmark
if (landmark.landmarkDefinition.GetEnumName <BasicPolygonLandmarks>() == BasicPolygonLandmarks.Closest)
{
var settings = landmark.settings as ClosestLandmarkSettings;
if (settings != null)
{
if (settings.target != null)
{
return;
}
var sessionCamera = MarsRuntimeUtils.GetSessionAssociatedCamera();
if (sessionCamera != null)
{
settings.target = sessionCamera.transform;
}
}
else
{
Debug.LogError("Closest landmark is missing valid settings component", gameObject);
}
}
}
void GetCameraParent()
{
var cam = MarsRuntimeUtils.GetActiveCamera(true);
if (cam == null)
{
m_CameraParentTransform = transform;
return;
}
m_CameraTransform = cam.transform;
// In case of custom camera setup, prefer session as camera parent, if it exists
var marsSession = m_CameraTransform.GetComponentInParent <MARSSession>();
if (marsSession != null)
{
m_CameraParentTransform = marsSession.transform;
}
if (!m_CameraParentTransform)
{
m_CameraParentTransform = m_CameraTransform.parent;
}
if (!m_CameraParentTransform)
{
m_CameraParentTransform = new GameObject("XRCameraRig").transform;
m_CameraTransform.SetParent(m_CameraParentTransform, false);
}
}
/// <summary>
/// Ensures that the active scene has a MARS Session
/// </summary>
/// <returns>Thew newly created MARSSession, or null if a session previously exists</returns>
public static MARSSession EnsureSessionInActiveScene()
{
var session = GameObjectUtils.GetComponentInActiveScene <MARSSession>();
if (SessionConfigured(session))
{
return(null);
}
using (var undoBlock = new UndoBlock("Ensure Session in Active Scene", TestMode))
{
if (!session)
{
var marsBehaviorsInScene = MarsRuntimeUtils.HasMarsBehaviors(SceneManager.GetActiveScene());
session = CreateSession(undoBlock, marsBehaviorsInScene);
var userRef = GameObjectUtils.Instantiate(MARSRuntimePrefabs.instance.UserPrefab).transform;
userRef.name = k_UserName;
userRef.parent = session.m_CameraReference.transform;
userRef.localPosition = Vector3.zero;
userRef.localRotation = Quaternion.identity;
userRef.localScale = Vector3.one;
undoBlock.RegisterCreatedObject(userRef.gameObject);
session.m_UserReference = userRef;
DirtySimulatableSceneIfNeeded();
return(session);
}
EnsureSessionConfigured(session, undoBlock);
}
return(null);
}
static void CheckMARSBehaviors(Scene scene)
{
// TODO: shut down MARS entirely if there are no MARS behaviors--the issue is starting it back up when adding them
if (MarsRuntimeUtils.HasMarsBehaviors(scene))
{
MARSSession.EnsureRuntimeState();
}
}
#pragma warning restore 649
void Start()
{
m_Camera = MarsRuntimeUtils.GetActiveCamera(true);
if (m_AgentPrefab == null)
{
m_Agent = GetComponent <MARSNavMeshAgent>();
}
}
static void ScaleClippingPlanes(float scaleFactor)
{
// Need to modify the clip planes of the mars session camera in the main scene as we scale the camera parent
var camera = MarsRuntimeUtils.GetSessionAssociatedCamera();
Undo.RecordObject(camera, "WorldScale");
camera.nearClipPlane *= scaleFactor;
camera.farClipPlane *= scaleFactor;
}
public void OnEnable()
{
titleContent.text = WindowTitle;
SwitchRatio();
m_OriginalSkybox = RenderSettings.skybox;
m_Session = MarsRuntimeUtils.GetMarsSessionInActiveScene();
EditorApplication.delayCall += SetupTextures;
EditorSceneManager.activeSceneChangedInEditMode += OnActiveSceneChange;
}
void Initialize()
{
m_Camera = MarsRuntimeUtils.GetActiveCamera(true);
m_PreviousCameraPose = m_Camera != null?m_Camera.transform.GetWorldPose() : default;
m_DistanceScale = this.GetCameraScale();
m_NormalData[m_TrackableId] = m_Normals;
MarsTime.MarsUpdate += OnMarsUpdate;
}
void IModuleDependency <FunctionalityInjectionModule> .ConnectDependency(FunctionalityInjectionModule dependency)
{
m_FIModule = dependency;
// TODO: Collect all scenes and add islands if modules persist between scene loads
#if UNITY_EDITOR
var session = Application.isPlaying ?
MARSSession.Instance :
MarsRuntimeUtils.GetMarsSessionInActiveScene();
#else
var session = MARSSession.Instance;
#endif
// TODO: Don't load modules for non-MARS scenes
if (session == null)
{
return;
}
FunctionalityIsland island = null;
if (session.island)
{
island = session.island;
}
#if UNITY_EDITOR
if (Application.isPlaying && m_SimulateInPlayMode)
{
if (m_SimulateDiscovery)
{
if (m_SimulatedDiscoveryIsland == null)
{
Debug.LogWarning("There is no simulated discovery island set in the MARSSceneModule to be used for play mode simulation");
return;
}
island = m_SimulatedDiscoveryIsland;
}
else
{
if (m_SimulationIsland == null)
{
Debug.LogWarning("There is no simulation island set in the MARSSceneModule to be used for play mode simulation");
return;
}
island = m_SimulationIsland;
}
}
#endif
if (island)
{
dependency.AddIsland(island);
}
}
void OnEnable()
{
var videoFeedTexture = this.GetVideoFeedTexture();
if (videoFeedTexture != null)
{
SetupFromVideoFeed(videoFeedTexture);
}
this.SubscribeVideoFeedTextureCreated(SetupFromVideoFeed);
m_ActiveCamera = MarsRuntimeUtils.GetActiveCamera();
}
void OnEnable()
{
m_Layer = m_PlaneLayer.GetFirstLayerIndex();
this.SubscribePlaneAdded(PlaneAddedHandler);
this.SubscribePlaneUpdated(PlaneUpdatedHandler);
this.SubscribePlaneRemoved(PlaneRemovedHandler);
m_RaycastLayers = m_PlaneLayer | m_ObjectLayer;
m_Camera = MarsRuntimeUtils.GetActiveCamera(true);
}
public override NativeArray <XRRaycastHit> Raycast(XRRaycastHit defaultRaycastHit, Vector2 screenPoint,
TrackableType trackableTypeMask, Allocator allocator)
{
// ARF normalizes to the Screen dimensions, so convert back to pixels.
screenPoint.x *= Screen.width;
screenPoint.y *= Screen.height;
var camera = MarsRuntimeUtils.GetActiveCamera(true);
var ray = camera.ScreenPointToRay(screenPoint);
return(Raycast(defaultRaycastHit, ray, trackableTypeMask, allocator));
}
public GameObject CreateHandle(GameObject prefab)
{
if (s_Context == null)
{
var camera = MarsRuntimeUtils.GetActiveCamera(true);
s_Context = new MouseInputRuntimeContext(camera);
}
var handle = s_Context.CreateHandle(prefab);
this.InjectFunctionalitySingle(handle);
return(handle);
}
void OnSceneGUI(SceneView sceneView)
{
var session = MarsRuntimeUtils.GetMarsSessionInActiveScene();
if (session && worldScaleControlsShown && !EditorApplication.isPlayingOrWillChangePlaymode)
{
UpdateScaleReference();
}
else if (m_ScaleReference != null)
{
DestroyImmediate(m_ScaleReference.gameObject);
}
}
static void DoSceneAnalysis(Scene scene)
{
if (!scene.IsValid())
{
return;
}
var session = MarsRuntimeUtils.GetMarsSessionInScene(scene);
if (!session)
{
return;
}
if (!scene.IsValid())
{
return;
}
// Static collections used below are cleared by the methods that use them
scene.GetRootGameObjects(k_RootObjects);
var marsObjectCount = 0;
var conditionComponentCount = 0;
foreach (var go in k_RootObjects)
{
go.GetComponentsInChildren(k_RealWorldObjects);
var clientCount = k_RealWorldObjects.Count;
if (clientCount == 0)
{
continue;
}
marsObjectCount += clientCount;
go.GetComponentsInChildren(k_Conditions);
conditionComponentCount += k_Conditions.Count;
}
EditorEvents.SceneAnalysis.Send(new SceneAnalysisArgs
{
name = "Scene Analysis",
scene_guid = AssetDatabase.AssetPathToGUID(scene.path),
world_scale = session.transform.localScale.x,
required_traits = session.requirements.TraitRequirements.Select(r => r.TraitName).ToArray(),
non_mars_object_count = scene.rootCount - marsObjectCount,
mars_object_count = marsObjectCount,
conditions_count = conditionComponentCount
});
}
void IModuleBehaviorCallbacks.OnBehaviorEnable()
{
if (!Application.isPlaying)
{
return;
}
var sessionCamera = MarsRuntimeUtils.GetActiveCamera(true);
if (sessionCamera != null)
{
SetupGameView(sessionCamera);
}
}
void UpdateTracking()
{
if (!m_EnvironmentScene.IsValid() || !m_EnvironmentPhysicsScene.IsValid())
{
return;
}
var marsCamera = MarsRuntimeUtils.GetActiveCamera(true);
if (marsCamera == null)
{
return;
}
foreach (var kvp in m_SimulatedTrackableObjects)
{
var synthTrackable = kvp.Key;
var simObject = kvp.Value;
var previouslyFound = m_DiscoveredTrackables.Contains(synthTrackable);
if (!synthTrackable.isActiveAndEnabled || !simObject.isActiveAndEnabled)
{
if (previouslyFound)
{
m_DiscoveredTrackables.Remove(synthTrackable);
RemoveTrackableData(synthTrackable);
}
continue;
}
var trackingState = GetTrackingState(synthTrackable, marsCamera);
var tracking = trackingState != MARSTrackingState.Unknown;
if (!previouslyFound)
{
if (!tracking)
{
return;
}
m_DiscoveredTrackables.Add(synthTrackable);
AddTrackableData(synthTrackable, trackingState);
}
else
{
UpdateTrackableData(synthTrackable, trackingState);
}
}
}
void Start()
{
m_Camera = MarsRuntimeUtils.GetActiveCamera(true);
m_CameraTransform = m_Camera.transform;
if (m_Cursor != null)
{
m_CursorTransform = m_Cursor.transform;
m_Cursor.SetActive(false);
}
if (m_ObjectToPlace != null)
{
m_ObjectToPlace.SetActive(false);
}
}
void UpdateImageMarkerConditionVisuals()
{
// There is no guarantee that the MarsSession singleton is going to be available at this stage so we need to get it like this
var loadedMARSSession = MarsRuntimeUtils.GetMarsSessionInActiveScene();
if (!loadedMARSSession)
{
return;
}
var loadedMarkerLibrary = loadedMARSSession.MarkerLibrary;
if (loadedMarkerLibrary == null)
{
return;
}
foreach (var entityVisualMarkerConditionKeyValuePair in m_ImageMarkerConditions)
{
if (entityVisualMarkerConditionKeyValuePair.Key == null || entityVisualMarkerConditionKeyValuePair.Value == null)
{
continue;
}
var foundMarkerId = false;
MarkerCondition currentMarkerCondition = entityVisualMarkerConditionKeyValuePair.Value;
for (var i = 0; i < loadedMarkerLibrary.Count; i++)
{
if (loadedMarkerLibrary[i].MarkerId.ToString() == currentMarkerCondition.MarkerGuid)
{
entityVisualMarkerConditionKeyValuePair.Key.SetScale(new Vector3(loadedMarkerLibrary[i].Size.x, loadedMarkerLibrary[i].Size.y, 0.01f));
entityVisualMarkerConditionKeyValuePair.Key.SetTextureForImageMarker(loadedMarkerLibrary[i].Texture, MarsUserPreferences.TintImageMarkers);
foundMarkerId = true;
break;
}
}
// Case when the user removes from the marker library an image marker already assigned.
if (!foundMarkerId)
{
// TODO: Perhaps tint this with magenta color? (Since no marker image is assigned anymore to this visual)
entityVisualMarkerConditionKeyValuePair.Key.SetTextureForImageMarker(Texture2D.whiteTexture, MarsUserPreferences.TintImageMarkers);
}
}
}
static void OnPlayModeStateChanged(PlayModeStateChange stateChange)
{
if (stateChange != PlayModeStateChange.ExitingEditMode)
{
return;
}
// TODO: What to do about dirtying the scene when you enter play mode?
// Update current scene info in case capabilities have changed
var session = MarsRuntimeUtils.GetMarsSessionInActiveScene();
if (session == null)
{
return;
}
session.CheckCapabilities();
}
static SerializedProperty GetWorldScaleProperty()
{
var session = MarsRuntimeUtils.GetMarsSessionInActiveScene();
if (session == null || session.transform == null)
{
return(null);
}
if (s_CachedSession != session || s_SerializedTransform == null)
{
s_CachedSession = session;
s_SerializedTransform = new SerializedObject(session.transform);
}
s_SerializedTransform.UpdateIfRequiredOrScript();
return(s_SerializedTransform.FindProperty("m_LocalScale"));
}
void UpdateTracking()
{
if (!m_EnvironmentScene.IsValid() || !m_EnvironmentPhysicsScene.IsValid())
{
return;
}
var marsCamera = MarsRuntimeUtils.GetActiveCamera(true);
if (marsCamera == null)
{
return;
}
foreach (var synthesizedBody in m_SynthMarkers)
{
UpdateTracking(synthesizedBody, marsCamera);
}
}
void Start()
{
#if INCLUDE_LEGACY_INPUT_HELPERS
SetPoseSource(DeviceType.GenericXRDevice, TrackedPose.ColorCamera);
UseRelativeTransform = false;
#endif
var marsCamera = MarsRuntimeUtils.GetActiveCamera(true);
if (marsCamera)
{
var cameraTransform = marsCamera.transform;
var cameraParent = cameraTransform.parent;
if (!cameraParent)
{
cameraParent = new GameObject("XRCameraRig").transform;
cameraTransform.parent = cameraParent;
}
transform.SetParent(cameraParent, false);
}
}
static ProxyForces EditorEnsureCameraProxy()
{
var cam = MarsRuntimeUtils.GetSessionAssociatedCamera(true);
if (cam == null)
{
return(null);
}
var proxy = cam.GetComponent <ProxyForces>();
if (proxy)
{
return(proxy);
}
proxy = cam.GetComponentInChildren <ProxyForces>();
if (proxy)
{
return(proxy);
}
var gm = new GameObject {
name = "MainCameraProxy"
};
gm.transform.parent = cam.transform;
gm.transform.localPosition = Vector3.zero;
gm.transform.localRotation = Quaternion.identity;
gm.transform.localScale = Vector3.one;
Undo.RegisterCreatedObjectUndo(gm, gm.name);
proxy = Undo.AddComponent <ProxyForces>(gm);
proxy.allowedMotion = ProxyForceMotionType.NotForced;
proxy.continuousSolve = true;
AfterConfiguredComponent(proxy);
return(proxy);
}
void CheckIfFaceScene()
{
var faceScene = false;
var session = MarsRuntimeUtils.GetMarsSessionInActiveScene();
if (session && session.requirements != null)
{
if (session.requirements.TraitRequirements.Any(r => r.TraitName == TraitNames.Face))
{
faceScene = true;
}
}
if (!faceScene)
{
// k_RootGameObjects is cleared by GetRootGameObjects
SceneManager.GetActiveScene().GetRootGameObjects(k_RootGameObjects);
foreach (var gameObject in k_RootGameObjects)
{
if (gameObject.GetComponentInChildren <IUsesFaceTracking>() != null)
{
faceScene = true;
break;
}
}
}
if (faceScene != currentSceneIsFaceScene)
{
currentSceneIsFaceScene = faceScene;
if (faceSceneStateChanged != null)
{
faceSceneStateChanged(faceScene);
}
}
}
void StopSimulation()
{
GameObjectUtils.gameObjectInstantiated -= m_SimulatedObjectsManager.AddSpawnedObjectToSimulation;
m_QueryBackend.onQueryMatchFound -= k_OnQueryMatchFound;
m_QueryBackend.onQueryMatchesFound -= k_OnQueryMatchesFound;
m_QueryBackend.onSetQueryMatchFound -= k_OnSetQueryMatchFound;
m_SlowTaskModule.ClearTasks();
foreach (var simView in SimulationView.SimulationViews)
{
var camera = simView.camera;
camera.ResetProjectionMatrix();
simView.isRotationLocked = false;
}
var marsSession = MarsRuntimeUtils.GetMarsSessionInActiveScene();
if (marsSession != null)
{
marsSession.StopRunInEditMode();
}
simulating = false;
}
