public void Awake()
{
arTrackedImageManager = FindObjectOfType <ARTrackedImageManager>();
foreach (GameObject prefab in objectPrefabs)
{
GameObject newPrefab = Instantiate(prefab, Vector3.zero, Quaternion.identity);
newPrefab.name = prefab.name;
spawnedPrefabs.Add(prefab.name, newPrefab);
}
/*nextObjectRed = Instantiate(redObject, Vector3.zero, Quaternion.identity);
* nextObjectBlue = Instantiate(blueObject, Vector3.zero, Quaternion.identity);
* nextObjectGreen = Instantiate(greenObject, Vector3.zero, Quaternion.identity);*/
objectController = GetComponent <ObjectController>();
menuController = GameObject.Find("Canvas").GetComponent <MenuController>();
objectNameText = objectName.GetComponent <TextMeshProUGUI>();
objectDescriptionText = objectDescription.GetComponent <TextMeshProUGUI>();
}
// Start is called before the first frame update
void Start()
{
// set session origion transform to transform of the instantionated object
ARSessionOrigin origin = FindObjectOfType <ARSessionOrigin>();
origin.transform.position = transform.position;
origin.transform.rotation = transform.rotation;
// disable image and object manager
ARTrackedImageManager imageManger = origin.GetComponent <ARTrackedImageManager>();
imageManger.enabled = false;
ARTrackedObjectManager objectManger = origin.GetComponent <ARTrackedObjectManager>();
objectManger.enabled = false;
if (OnSceneRootSet != null)
{
OnSceneRootSet.Raise();
}
}
// Instancie tous les objet et les rend invisible sinon ils sont tous affichés à l'origine de la caméra.
// On récupère aussi les composant dont on a besoin (trackedImageManager et SessionOrigin)
private void Awake()
{
trackedImageManager = FindObjectOfType <ARTrackedImageManager>();
arOrigin = FindObjectOfType <ARSessionOrigin>();
foreach (GameObject prefab in placeablePrefabs)
{
GameObject newPrefab = Instantiate(prefab, Vector3.zero, Quaternion.identity);
newPrefab.name = prefab.name;
spawnedPrefabs.Add(prefab.name, newPrefab);
spawnedPrefabs[prefab.name].SetActive(false);
}
imagesName = new List <string>();
foreach (GameObject image in spawnedPrefabs.Values)
{
imagesName.Add(image.name);
}
numImageFocused.text = focusPosition.ToString();
}
// Start is called before the first frame update
void Awake()
{
Screen.sleepTimeout = SleepTimeout.NeverSleep; //disable screen dimming on Mobile Devices. We might want to change so that it dims while in the menu.
Application.targetFrameRate = 60; //Set framerate to 60hz. This improves plane detection in my experience.
arOrigin = FindObjectOfType <ARSessionOrigin>();
arRaycast = arOrigin.GetComponent <ARRaycastManager>();
arPlanes = arOrigin.GetComponent <ARPlaneManager>();
arCloud = arOrigin.GetComponent <ARPointCloudManager>();
arCameraManager = Camera.main.GetComponent <ARCameraManager>();
arImageManager = arOrigin.GetComponent <ARTrackedImageManager>();
mapCreator = GetComponentInChildren <MapCreator>();
spawnedCans = new Dictionary <TrackableId, GameObject>();
spawnPoints = new List <Vector3>();
placeButton = GameObject.Find("PlaceScene");
resetButton = GameObject.Find("Reset");
resetButton.SetActive(false);
}
private void Awake()
{
// Cachen
_imageManager = GetComponent <ARTrackedImageManager>();
_raycastManager = GetComponent <ARRaycastManager>();
_anchorManager = GetComponent <ARAnchorManager>();
_planeManager = GetComponent <ARPlaneManager>();
_session = GetComponent <ARSessionOrigin>();
// Manager zunaechst deaktivieren
_raycastManager.subsystem?.Stop();
_planeManager.subsystem?.Stop();
_imageManager.subsystem?.Stop();
// IFC instantiieren
GameManager.Instance.PlacedIFC = Instantiate(_placedPrefab);
GameManager.Instance.PlacedIFC.SetActive(false);
// Event abonnieren
GameManager.Instance.PlacementModeSelected += X_ModeSelected;
// ggf. Touch aktivieren
if (!EnhancedTouchSupport.enabled)
{
EnhancedTouchSupport.Enable();
}
}
// Start is called before the first frame update
void Start()
{
// setup reference
trackerStates = new TrackingState[targetLib.count];
trackerImageNameDict = new Dictionary <string, int>();
for (int i = 0; i < trackerObjs.Length; i++)
{
trackerImageNameDict.Add(trackerObjs[i].name, i);
trackerStates[i] = TrackingState.None;
}
// init foundation ar image manager
_foundationTrackerManager = GameObject.FindObjectOfType <ARTrackedImageManager>();
Debug.Log("Get Manager: " + _foundationTrackerManager.gameObject.name);
//_foundationTrackerManager = gameObject.AddComponent<ARTrackedImageManager>();
_foundationTrackerManager.enabled = false;
_foundationTrackerManager.referenceLibrary = targetLib;
_foundationTrackerManager.enabled = true;
Debug.Log("Start AR Manager");
}
void Awake()
{
dismissButton.onClick.AddListener(Dismiss);
m_TrackedImageManager = GetComponent <ARTrackedImageManager>();
// setup all game objects in dictionary
foreach (GameObject arObject in arObjectsToPlace)
{
GameObject newARObject = Instantiate(arObject, Vector3.zero, Quaternion.identity);
newARObject.name = arObject.name;
arObjects.Add(arObject.name, newARObject);
Color newColor = arObject.GetComponent <Renderer>().material.color;
arColor.Add(arObject.name, newColor);
}
// defaultColor = new Color[arObjectsToPlace.Length];
// for (int i = 0; i < arObjectsToPlace.Length; i++)
// {
// defaultColor[i] = arObjectsToPlace[i].GetComponent<Renderer>().material.color;
// }
}
private void AfterInitialization(ARSessionStateChangedEventArgs stateArgument)
{
if (stateArgument.state == ARSessionState.SessionInitializing)
{
// Ready to set Runtime Library
mARTrackedImageManager = gameObject.AddComponent <ARTrackedImageManager>();
if (mARTrackedImageManager.descriptor.supportsMutableLibrary)
{
var myRuntimeReferenceImageLibrary =
mARTrackedImageManager.CreateRuntimeLibrary() as MutableRuntimeReferenceImageLibrary;
var allTexturesHere = new List <DynamicImageLibraryEntry>(5);
OnRequestImageAdd?.Invoke(allTexturesHere);
var jobs = new List <Unity.Jobs.JobHandle>(allTexturesHere.Count);
foreach (var item in allTexturesHere)
{
jobs.Add(myRuntimeReferenceImageLibrary
.ScheduleAddImageJob(item.texture, item.id, item.widthInMeters));
}
foreach (var item in jobs)
{
item.Complete();
}
if (myRuntimeReferenceImageLibrary != null)
{
Debug.Log("myRuntimeReferenceImageLibrary: " + myRuntimeReferenceImageLibrary.count);
Debug.Log("supportedTextureFormatCount: " + myRuntimeReferenceImageLibrary.supportedTextureFormatCount);
mARTrackedImageManager.referenceLibrary = myRuntimeReferenceImageLibrary;
}
mARTrackedImageManager.enabled = true;
}
}
}
protected override void Awake()
{
base.Awake();
// Initialize callbacks from ARTrackedImageManager
trackedImageManager = FindObjectOfType <ARTrackedImageManager>();
if (trackedImageManager)
{
trackedImageManager.trackedImagesChanged += On_TrackedImageManager_trackedImagesChanged;
}
// Initialize BAnchorsCollection
bAnchorsCollection = GetComponentWithCheck <BAnchorsCollection>();
// Initialize Tracked Images Map
foreach (TrackedImageTupple trackedImageTupple in trackedImagesTupples)
{
if (IS_NOT_NULL(trackedImageTupple.TrackedObject))
{
trackedImagesMap.Add(trackedImageTupple.ImageName, trackedImageTupple.TrackedObject);
trackedImageTupple.TrackedObject.gameObject.SetActive(false);
}
}
}
protected virtual void Awake()
{
Logger.Log("Creating Runtime Mutable Image Library\n");
if (GetComponent <ARTrackedImageManager>() == null)
{
trackImageManager = gameObject.AddComponent <ARTrackedImageManager>();
}
else
{
trackImageManager = GetComponent <ARTrackedImageManager>();
}
trackImageManager.maxNumberOfMovingImages = 1;
//todo not addding prefab via artrackedimagemanager
//trackImageManager.trackedImagePrefab = prefabOnTrack;
trackImageManager.trackedImagesChanged += OnTrackedImagesChanged;
// ShowTrackerInfo();
trackImageManager.enabled = false;
trackImageManager.referenceLibrary = trackImageManager.CreateRuntimeLibrary(runtimeImageLibrary);
trackImageManager.enabled = true;
}
void IInitializable.Initialize()
{
_arTrackedImageManager = _arTrackedImageManagerProvider.GetManager();
_arTrackedImageManager.trackedImagesChanged += HandleTrackedImagesChanged;
}
private void Awake()
{
m_trackedImageManager = GetComponent <ARTrackedImageManager>();
instanciatePrefab = new Dictionary <string, GameObject>();
}
private void Awake()
{
arTrackedImgManager = GetComponent <ARTrackedImageManager>();
prefabIsSet = false;
}
private void Awake()
{
m_image_tracker = GetComponent <ARTrackedImageManager>();
}
void OnTrackedImageChanged(ARTrackedImagesChangedEventArgs args_)
{
foreach (ARTrackedImage i in args_.added)
{
if (m_spawned_worlds.Count < 10)
{
if (i.referenceImage.name == "h2o")
{
m_spawned_worlds.Add(i.GetInstanceID(), Instantiate(h2o, i.transform.position, i.transform.rotation));
}
else if (i.referenceImage.name == "ch2o")
{
m_spawned_worlds.Add(i.GetInstanceID(), Instantiate(ch2o, i.transform.position, i.transform.rotation));
}
else if (i.referenceImage.name == "nh3")
{
m_spawned_worlds.Add(i.GetInstanceID(), Instantiate(nh3, i.transform.position, i.transform.rotation));
}
else if (i.referenceImage.name == "co2")
{
m_spawned_worlds.Add(i.GetInstanceID(), Instantiate(co2, i.transform.position, i.transform.rotation));
}
else if (i.referenceImage.name == "so2")
{
m_spawned_worlds.Add(i.GetInstanceID(), Instantiate(so2, i.transform.position, i.transform.rotation));
}
else if (i.referenceImage.name == "ch4")
{
m_spawned_worlds.Add(i.GetInstanceID(), Instantiate(ch4, i.transform.position, i.transform.rotation));
}
else if (i.referenceImage.name == "c2h5oh")
{
m_spawned_worlds.Add(i.GetInstanceID(), Instantiate(c2h5oh, i.transform.position, i.transform.rotation));
}
}
if (m_spawned_worlds.Count == 10)
{
Object.Destroy(m_spawned_worlds[1]);
m_spawned_worlds.Remove(1);
args_.added.Clear();
ARTrackedImageManager m_image_tracker;
m_image_tracker = GetComponent <ARTrackedImageManager>();
OnEnable();
}
}
foreach (ARTrackedImage i in args_.updated)
{
int id = i.GetInstanceID();
if (m_spawned_worlds.ContainsKey(id))
{
m_spawned_worlds[id].transform.position = i.transform.position;
m_spawned_worlds[id].transform.rotation = i.transform.rotation;
if (i.trackingState == TrackingState.Limited)
{
Debug.Log("Limited");
m_spawned_worlds[id].SetActive(false);
}
if (i.trackingState == TrackingState.Limited)
{
Debug.Log("Limited");
m_spawned_worlds[id].SetActive(false);
}
if (i.trackingState == TrackingState.Tracking)
{
Debug.Log("Tracking");
m_spawned_worlds[id].SetActive(true);
}
}
}
foreach (ARTrackedImage i in args_.removed)
{
int id = i.GetInstanceID();
if (m_spawned_worlds.ContainsKey(id))
{
Object.Destroy(m_spawned_worlds[id]);
m_spawned_worlds.Remove(id);
}
}
}
void Awake()
{
dismissButton.onClick.AddListener(Dismiss);
m_TrackedImageManager = GetComponent <ARTrackedImageManager>();
}
private void Start()
{
DebugText(null);
mARTrackedImageManager = sessionOrigin.gameObject.AddComponent <ARTrackedImageManager>();
}
void Awake()
{
Debug.Log("caaacc");
m_TrackedImageManager = GetComponent <ARTrackedImageManager>();
}
private void Awake()
{
_trackedImageManager = FindObjectOfType <ARTrackedImageManager>();
_sliderScrollbar = FindObjectOfType <Slider>();
_sliderScrollbar.onValueChanged.AddListener(delegate { SliderValueChanged(); });
}
void Awake()
{
arTrackedImageManager = GetComponent <ARTrackedImageManager>();
//debug.text = "Awake";
}
void Awake()
{
//ARTrackedImageManagerを取得します
arTrackedImageManager = GetComponent <ARTrackedImageManager>();
}
private void Awake()
{
_arTrackedImageManager = FindObjectOfType <ARTrackedImageManager>();
}
public void Awake()
{
trackedImageManager = GameObject.FindObjectOfType <ARSessionOrigin>().GetComponent <ARTrackedImageManager>();
imageTargetController = GetComponent <ImageTargetController>();
}
private void Awake()
{
_trackedImageManager = gameObject.GetComponent <ARTrackedImageManager>();
}
void Awake()
{
trackedImageManager = this.gameObject.GetComponent <ARTrackedImageManager>();
anchorManager = this.gameObject.GetComponent <ARAnchorManager>();
arCamera = FindObjectOfType <ARCameraManager>().GetComponent <Camera>();
}
void Start()
{
//dynamic image target or normal images target will add this component to its game object in awake so we searching it in start method
manager = GameObject.FindObjectOfType <ARTrackedImageManager>();
manager.trackedImagesChanged += Manager_trackedImagesChanged;
}
void Awake()
{
m_TrackedImageManager = GetComponent <ARTrackedImageManager>();
}
private void Awake()
{
_manager = FindObjectOfType <ARTrackedImageManager>();
myForm.SetActive(false);
}
//call Awake method to initialize tracked image manager
void Awake()
{
//initialized tracked image manager
m_TrackedImageManager = GetComponent <ARTrackedImageManager>();
isInstantiated = false;
}
void Awake()
{
//initialized tracked image manager
arTrackedImageManager = GetComponent <ARTrackedImageManager>();
}
