private static void SetUnityVersion()
{
// Set the Unity version for internal use
string path = Path.Combine(Application.dataPath, "StreamingAssets/QCAR");
QCARUnityImpl.SetUnityVersion(path);
}
// This method is called by Unity whenever assets are updated (deleted,
// moved or added)
public static void OnPostprocessAllAssets(string[] importedAssets,
string[] deletedAssets,
string[] movedAssets,
string[] movedFromAssetPaths)
{
// Set the Unity version for internal use
string path = Path.Combine(Application.dataPath, "StreamingAssets/QCAR");
QCARUnityImpl.SetUnityVersion(path);
}
private void Start()
{
if ((KeepAliveAbstractBehaviour.Instance != null) && KeepAliveAbstractBehaviour.Instance.KeepARCameraAlive)
{
UnityEngine.Object.DontDestroyOnLoad(base.gameObject);
}
Debug.Log("QCARWrapper.Start");
if (this.mAndroidUnityPlayer != null)
{
this.mAndroidUnityPlayer.Start();
}
if (QCARUnity.CheckInitializationError() != QCARUnity.InitError.INIT_SUCCESS)
{
this.mIsInitialized = false;
}
else
{
if (TrackerManager.Instance.GetTracker <MarkerTracker>() == null)
{
TrackerManager.Instance.InitTracker <MarkerTracker>();
}
if (TrackerManager.Instance.GetTracker <ImageTracker>() == null)
{
TrackerManager.Instance.InitTracker <ImageTracker>();
}
this.mCachedDrawVideoBackground = QCARManager.Instance.DrawVideoBackground;
this.mCachedCameraClearFlags = base.camera.clearFlags;
this.mCachedCameraBackgroundColor = base.camera.backgroundColor;
Screen.sleepTimeout = -1;
this.ResetCameraClearFlags();
this.mClearMaterial = new Material(Shader.Find("Diffuse"));
QCARUnity.SetHint(QCARUnity.QCARHint.HINT_MAX_SIMULTANEOUS_IMAGE_TARGETS, this.MaxSimultaneousImageTargets);
QCARUnityImpl.SetUnityVersion(Application.persistentDataPath, true);
((StateManagerImpl)TrackerManager.Instance.GetStateManager()).AssociateMarkerBehaviours();
this.StartQCAR();
QCARManager.Instance.WorldCenterMode = this.mWorldCenterMode;
QCARManager.Instance.WorldCenter = this.mWorldCenter;
QCARManager.Instance.ARCamera = base.camera;
QCARManager.Instance.Init();
this.mIsInitialized = true;
foreach (ITrackerEventHandler handler in this.mTrackerEventHandlers)
{
handler.OnInitialized();
}
this.mHasStartedOnce = true;
if (QCARRuntimeUtilities.IsPlayMode())
{
this.UpdateProjection(ScreenOrientation.Portrait);
}
}
}
private static void SetUnityVersion()
{
QCARUnityImpl.SetUnityVersion(Path.Combine(Application.dataPath, "StreamingAssets/QCAR"), false);
}
/// <summary>
/// Returns the QCAR projection matrix
/// </summary>
public static Matrix4x4 GetProjectionGL(float nearPlane, float farPlane, ScreenOrientation screenOrientation)
{
return(QCARUnityImpl.GetProjectionGL(nearPlane, farPlane, screenOrientation));
}
/// <summary>
/// Indicates whether the rendering surface needs to support an alpha channel
// for transparency
/// </summary>
public static bool RequiresAlpha()
{
return(QCARUnityImpl.RequiresAlpha());
}
/// <summary>
/// Sets a hint for the QCAR SDK
/// Hints help the SDK to understand the developer's needs.
/// However, depending on the device or SDK version the hints
/// might not be taken into consideration.
/// Returns false if the hint is unknown or deprecated.
/// </summary>
public static bool SetHint(QCARHint hint, int value)
{
return(QCARUnityImpl.SetHint(hint, value));
}
/// <summary>
/// Checks if the GL surface has changed
/// </summary>
public static bool IsRendererDirty()
{
return(QCARUnityImpl.IsRendererDirty());
}
/// <summary>
/// Retrieves initialization error code or success
/// </summary>
public static InitError CheckInitializationError()
{
return(QCARUnityImpl.CheckInitializationError());
}
// Starts up the QCAR extension with the properties that were set in the
// Unity inspector.
void Start()
{
// keeps the ARCamera object alive across scenes:
if (KeepAliveBehaviour.Instance != null && KeepAliveBehaviour.Instance.KeepARCameraAlive)
{
DontDestroyOnLoad(gameObject);
}
Debug.Log("QCARWrapper.Start");
// First we check if QCAR initialized correctly.
if (QCARUnity.CheckInitializationError() != QCARUnity.InitError.INIT_SUCCESS)
{
mIsInitialized = false;
return;
}
// Initialize the trackers if they haven't already been initialized.
if (TrackerManager.Instance.GetTracker(Tracker.Type.MARKER_TRACKER) == null)
{
TrackerManager.Instance.InitTracker(Tracker.Type.MARKER_TRACKER);
}
if (TrackerManager.Instance.GetTracker(Tracker.Type.IMAGE_TRACKER) == null)
{
TrackerManager.Instance.InitTracker(Tracker.Type.IMAGE_TRACKER);
}
// Cache the camera start values
mCachedDrawVideoBackground = QCARManager.Instance.DrawVideoBackground;
mCachedCameraClearFlags = this.camera.clearFlags;
mCachedCameraBackgroundColor = this.camera.backgroundColor;
// keep the device's screen turned on and bright.
Screen.sleepTimeout = SleepTimeout.NeverSleep;
// Reset the camera clear flags and create a simple material
ResetCameraClearFlags();
mClearMaterial = new Material(Shader.Find("Diffuse"));
// Set QCAR hints from the Inspector options
QCARUnity.SetHint(QCARUnity.QCARHint.HINT_MAX_SIMULTANEOUS_IMAGE_TARGETS,
MaxSimultaneousImageTargets);
// Set the Unity version for internal use
QCARUnityImpl.SetUnityVersion(Application.persistentDataPath, true);
// register markers in QCAR:
StateManagerImpl stateManager = (StateManagerImpl)TrackerManager.Instance.GetStateManager();
stateManager.AssociateMarkerBehaviours();
// Start the camera and tracker
StartQCAR();
// Initialize the QCARManager
QCARManager.Instance.WorldCenterMode = mWorldCenterMode;
QCARManager.Instance.WorldCenter = mWorldCenter;
QCARManager.Instance.ARCamera = camera;
QCARManager.Instance.Init();
// Initialize local variables
mIsInitialized = true;
// Let the trackable event handlers know that QCAR has been initialized
foreach (ITrackerEventHandler handler in mTrackerEventHandlers)
{
handler.OnInitialized();
}
mHasStartedOnce = true;
}
