// Update is called once per frame void Update() { if (Session.Status != SessionStatus.Tracking) { return; } if (detectedPlane == null) { return; } // Check for the plane being subsumed. // If the plane has been subsumed switch attachment to the subsuming plane. while (detectedPlane.SubsumedBy != null) { detectedPlane = detectedPlane.SubsumedBy; } transform.LookAt(firstPersonCamera.transform); // Move the position to stay consistent with the plane. transform.position = new Vector3(transform.position.x, detectedPlane.CenterPose.position.y + yOffset, transform.position.z); }
public static bool IsVerticalPlane(this DetectedPlane plane) { return(plane.PlaneType == DetectedPlaneType.Vertical); }
public void SetPlane(DetectedPlane plane) { detectedPlane = plane; // Spawn a new snake. SpawnSnake(); }
public void Update() { UpdateApplicationLifecycle(); if (gameObjectTemp != null) { gameObjectTemp.transform.Rotate(0, SliderRotate.value, 0, Space.Self); gameObjectTemp.transform.localScale += SliderScale.value * scale; } // If the player has not touched the screen, we are done with this update. Touch touch; if (Input.touchCount < 1 || (touch = Input.GetTouch(0)).phase != TouchPhase.Began) { return; } // Should not handle input if the player is pointing on UI. if (EventSystem.current.IsPointerOverGameObject(touch.fingerId)) { return; } // Raycast against the location the player touched to search for planes. TrackableHit hit; bool foundHit = false; if (InstantPlacementMenu.IsInstantPlacementEnabled()) { foundHit = Frame.RaycastInstantPlacement(touch.position.x, touch.position.y, 1.0f, out hit); } else { TrackableHitFlags raycastFilter = TrackableHitFlags.PlaneWithinPolygon | TrackableHitFlags.FeaturePointWithSurfaceNormal; foundHit = Frame.Raycast(touch.position.x, touch.position.y, raycastFilter, out hit); } if (foundHit) { // Choose the gameobject to place if (GameObjectIndex == 0) { GameObjectVerticalPlanePrefab = GameObjectRobot; GameObjectHorizontalPlanePrefab = GameObjectRobot; GameObjectPointPrefab = GameObjectRobot; InstantPlacementPrefab = GameObjectRobot; } else if (GameObjectIndex == 1) { GameObjectVerticalPlanePrefab = GameObjectFox; GameObjectHorizontalPlanePrefab = GameObjectFox; GameObjectPointPrefab = GameObjectFox; InstantPlacementPrefab = GameObjectFox; } else if (GameObjectIndex == 2) { GameObjectVerticalPlanePrefab = GameObjectCat; GameObjectHorizontalPlanePrefab = GameObjectCat; GameObjectPointPrefab = GameObjectCat; InstantPlacementPrefab = GameObjectCat; } else if (GameObjectIndex == 3) { GameObjectVerticalPlanePrefab = GameObjectWindow; GameObjectHorizontalPlanePrefab = GameObjectWindow; GameObjectPointPrefab = GameObjectWindow; InstantPlacementPrefab = GameObjectWindow; } // Use hit pose and camera pose to check if hittest is from the back of the plane, if it is, no need to create the anchor. if ((hit.Trackable is DetectedPlane) && Vector3.Dot(FirstPersonCamera.transform.position - hit.Pose.position, hit.Pose.rotation * Vector3.up) < 0) { Debug.Log("Hit at back of the current DetectedPlane"); } else { if (DepthMenu != null) { // Show depth card window if necessary. DepthMenu.ConfigureDepthBeforePlacingFirstAsset(); } // Choose the prefab based on the Trackable that got hit. GameObject prefab; if (hit.Trackable is InstantPlacementPoint) { prefab = InstantPlacementPrefab; } else if (hit.Trackable is FeaturePoint) { prefab = GameObjectPointPrefab; } else if (hit.Trackable is DetectedPlane) { DetectedPlane detectedPlane = hit.Trackable as DetectedPlane; if (detectedPlane.PlaneType == DetectedPlaneType.Vertical) { prefab = GameObjectVerticalPlanePrefab; } else { prefab = GameObjectHorizontalPlanePrefab; } } else { prefab = GameObjectHorizontalPlanePrefab; } // Instantiate prefab at the hit pose. gameObjectTemp = Instantiate(prefab, hit.Pose.position, hit.Pose.rotation); // Compensate for the hitPose rotation facing away from the raycast if (GameObjectIndex != 3) { gameObjectTemp.transform.Rotate(0, _prefabRotation, 0, Space.Self); } // Create an anchor to allow ARCore to track the hitpoint as understanding of the physical world evolves. var anchor = hit.Trackable.CreateAnchor(hit.Pose); // Make game object a child of the anchor. gameObjectTemp.transform.parent = anchor.transform; // Initialize Instant Placement Effect. if (hit.Trackable is InstantPlacementPoint) { gameObjectTemp.GetComponentInChildren <InstantPlacementEffect>().InitializeWithTrackable(hit.Trackable); } } } }
/// <summary> /// The Unity Update() method. /// </summary> public void Update() { _UpdateApplicationLifecycle(); // If the player has not touched the screen, we are done with this update. Touch touch; if (Input.touchCount < 1 || (touch = Input.GetTouch(0)).phase != TouchPhase.Began) { return; } // Should not handle input if the player is pointing on UI. if (EventSystem.current.IsPointerOverGameObject(touch.fingerId)) { return; } // Raycast against the location the player touched to search for planes. TrackableHit hit; TrackableHitFlags raycastFilter = TrackableHitFlags.PlaneWithinPolygon | TrackableHitFlags.FeaturePointWithSurfaceNormal; if (Frame.Raycast(touch.position.x, touch.position.y, raycastFilter, out hit)) { // Use hit pose and camera pose to check if hittest is from the // back of the plane, if it is, no need to create the anchor. if ((hit.Trackable is DetectedPlane) && Vector3.Dot(FirstPersonCamera.transform.position - hit.Pose.position, hit.Pose.rotation * Vector3.up) < 0) { Debug.Log("Hit at back of the current DetectedPlane"); } else { // Choose the Andy model for the Trackable that got hit. GameObject prefab; if (hit.Trackable is FeaturePoint) { prefab = AndyPointPrefab; } else if (hit.Trackable is DetectedPlane) { DetectedPlane detectedPlane = hit.Trackable as DetectedPlane; if (detectedPlane.PlaneType == DetectedPlaneType.Vertical) { prefab = AndyVerticalPlanePrefab; } else { prefab = AndyHorizontalPlanePrefab; } } else { prefab = AndyHorizontalPlanePrefab; } // Instantiate Andy model at the hit pose. var andyObject = Instantiate(prefab, hit.Pose.position, hit.Pose.rotation); // Compensate for the hitPose rotation facing away from the raycast (i.e. // camera). andyObject.transform.Rotate(0, k_ModelRotation, 0, Space.Self); // Create an anchor to allow ARCore to track the hitpoint as understanding of // the physical world evolves. var anchor = hit.Trackable.CreateAnchor(hit.Pose); // Make Andy model a child of the anchor. andyObject.transform.parent = anchor.transform; } } }
// Update is called once per frame void Update() { if (detectedPlane == null) { return; } if (detectedPlane.TrackingState != TrackingState.Tracking) { return; } // Check for the plane being subsumed // If the plane has been subsumed switch attachment to the subsuming plane. while (detectedPlane.SubsumedBy != null) { detectedPlane = detectedPlane.SubsumedBy; } //edamas senes if (foodInstance == null || foodInstance.activeSelf == false) { SpawnFoodInstance(); return; } foodAge += Time.deltaTime; if (foodAge >= maxAge) { DestroyObject(foodInstance); foodInstance = null; } //needamas senes if (foodInstance2 == null || foodInstance2.activeSelf == false) { SpawnFoodInstance2(); return; } foodAge += Time.deltaTime; if (foodAge >= maxAge) { DestroyObject(foodInstance2); foodInstance2 = null; } //augi if (foodInstance3 == null || foodInstance3.activeSelf == false) { SpawnFoodInstance3(); return; } foodAge += Time.deltaTime; if (foodAge >= maxAge) { DestroyObject(foodInstance3); foodInstance3 = null; } }
public void Update() { _UpdateApplicationLifecycle(); // If the player has not touched the screen, we are done with this update. Touch touch; if (Input.touchCount < 1 || (touch = Input.GetTouch(0)).phase != TouchPhase.Began) { return; } // Should not handle input if the player is pointing on UI. if (EventSystem.current.IsPointerOverGameObject(touch.fingerId)) { return; } // Raycast against the location the player touched to search for planes. TrackableHit hit; TrackableHitFlags raycastFilter = TrackableHitFlags.PlaneWithinPolygon | TrackableHitFlags.FeaturePointWithSurfaceNormal; if (Frame.Raycast(touch.position.x, touch.position.y, raycastFilter, out hit)) { // Use hit pose and camera pose to check if hittest is from the // back of the plane, if it is, no need to create the anchor. if ((hit.Trackable is DetectedPlane) && Vector3.Dot(FirstPersonCamera.transform.position - hit.Pose.position, hit.Pose.rotation * Vector3.up) < 0) { Debug.Log("Hit at back of the current DetectedPlane"); } else { // Choose the prefab based on the Trackable that got hit. GameObject prefab; if (hit.Trackable is FeaturePoint) { prefab = GameObjectPointPrefab; } else if (hit.Trackable is DetectedPlane) { DetectedPlane detectedPlane = hit.Trackable as DetectedPlane; if (detectedPlane.PlaneType == DetectedPlaneType.Vertical) { prefab = GameObjectVerticalPlanePrefab; } else { prefab = GameObjectHorizontalPlanePrefab; } } else { prefab = GameObjectHorizontalPlanePrefab; } // Instantiate prefab at the hit pose. var andyObject = Instantiate(prefab, hit.Pose.position, hit.Pose.rotation); Points.Add(andyObject); if (Points.Count >= 2) { andyObject.GetComponent <LineRenderer>().positionCount = 2; andyObject.GetComponent <LineRenderer>().SetPosition(0, andyObject.transform.position); andyObject.GetComponent <LineRenderer>().SetPosition(1, Points[Points.Count - 2].transform.position); var temp = Instantiate(Text, (andyObject.transform.position + Points[Points.Count - 2].transform.position) / 2, Quaternion.identity); temp.transform.LookAt(andyObject.transform.position); temp.transform.localEulerAngles = new Vector3(90, temp.transform.localEulerAngles.y + 90, 0); temp.GetComponent <TextMesh>().text = (Vector3.Distance(andyObject.transform.position, Points[Points.Count - 2].transform.position) * 100).ToString("0.00"); } // Compensate for the hitPose rotation facing away from the raycast (i.e. // camera). andyObject.transform.Rotate(0, k_PrefabRotation, 0, Space.Self); // Create an anchor to allow ARCore to track the hitpoint as understanding of // the physical world evolves. var anchor = hit.Trackable.CreateAnchor(hit.Pose); // Make game object a child of the anchor. andyObject.transform.parent = anchor.transform; } } }
/// <summary> /// The Unity Update() method. /// </summary> public void Update() { _UpdateApplicationLifecycle(); // If the player has not touched the screen, we are done with this update. Touch touch; if (Input.touchCount < 1 || (touch = Input.GetTouch(0)).phase != TouchPhase.Began) { return; } // Should not handle input if the player is pointing on UI. if (EventSystem.current.IsPointerOverGameObject(touch.fingerId)) { return; } // Raycast against the location the player touched to search for planes. TrackableHit hit; TrackableHitFlags raycastFilter = TrackableHitFlags.PlaneWithinPolygon | TrackableHitFlags.FeaturePointWithSurfaceNormal; if (Frame.Raycast(touch.position.x, touch.position.y, raycastFilter, out hit)) { // Use hit pose and camera pose to check if hittest is from the // back of the plane, if it is, no need to create the anchor. if ((hit.Trackable is DetectedPlane) && Vector3.Dot(FirstPersonCamera.transform.position - hit.Pose.position, hit.Pose.rotation * Vector3.up) < 0) { Debug.Log("Hit at back of the current DetectedPlane"); } else { // Choose the prefab based on the Trackable that got hit. GameObject prefab; if (hit.Trackable is FeaturePoint) { prefab = GameObjectPointPrefab; } else if (hit.Trackable is DetectedPlane) { DetectedPlane detectedPlane = hit.Trackable as DetectedPlane; if (detectedPlane.PlaneType == DetectedPlaneType.Vertical) { prefab = GameObjectVerticalPlanePrefab; } else { prefab = GameObjectHorizontalPlanePrefab; } } else { prefab = GameObjectHorizontalPlanePrefab; } //// Instantiate prefab at the hit pose. //var gameObject = Instantiate(prefab, hit.Pose.position, hit.Pose.rotation); //// Compensate for the hitPose rotation facing away from the raycast (i.e. //// camera). //gameObject.transform.Rotate(0, k_PrefabRotation, 0, Space.Self); // Create an anchor to allow ARCore to track the hitpoint as understanding of // the physical world evolves. var anchor = hit.Trackable.CreateAnchor(hit.Pose); // Выровнять якорь по горизонтали Vector3 myEu = anchor.transform.eulerAngles; myEu.x = 0.0f; myEu.z = 0.0f; //// Make game object a child of the anchor. //gameObject.transform.parent = anchor.transform; // Скрыть генератор поверхностей _PlaneGen.SetActive(false); // Открыть объекты сцены _GO_Root.transform.parent = anchor.transform; _GO_Root.transform.localPosition = Vector3.zero; _GO_Root.transform.localEulerAngles = Vector3.zero; _GO_Root.SetActive(true); _Text1.text = "Pos=" + _GO_Root.transform.position.ToString() + " Eu=" + _GO_Root.transform.eulerAngles.ToString(); // Установить поле зрения 45 градусов FirstPersonCamera.fieldOfView = 45; _RightCam.fieldOfView = 45; } } }
public bool EqualsPlane(DetectedPlane plane) { return(plane.GetHashCode() == this.PlaneCode); }
public DetectedPlatform(DetectedPlane plane) : base(plane.m_TrackableNativeHandle, plane.m_NativeSession) { PlaneCode = plane.GetHashCode(); }
void SetSelectedPlane(DetectedPlane selectedPlane) { // Plane controller set plane function planeController.SetSelectedPlane(selectedPlane); }
/// <summary> /// The Unity Update() method. /// </summary> public void Update() { UpdateApplicationLifecycle(); if (DepthMenu != null && !DepthMenu.CanPlaceAsset()) { return; } // If the player has not touched the screen, we are done with this update. Touch touch; if (Input.touchCount < 1 || (touch = Input.GetTouch(0)).phase != TouchPhase.Began) { return; } // Should not handle input if the player is pointing on UI. if (EventSystem.current.IsPointerOverGameObject(touch.fingerId)) { return; } // Raycast against the location the player touched to search for planes. TrackableHit hit; TrackableHitFlags raycastFilter = TrackableHitFlags.PlaneWithinPolygon | TrackableHitFlags.FeaturePointWithSurfaceNormal; // To use Instant Placement, which supports frame by frame 2D tracking and // automatically switches to 6DOF tracking once it's available, follow these steps: // 1. Use InstantPlacementMode.LocalYUp in ARCoreSessionConfig. // 2. Use Frame.RaycastInstantPlacement(float, float, float, out TrackableHit) method // with an approximate distance in meters. // 3. Create anchor with the hit result from previous step by: // hit.Trackable.CreateAnchor(hit.Pose). // // An anchor will be created at the approximate pose if there has been no Trackable // detected yet, and updates its pose to attach to the real world. // Note: there may be a noticeable jump in position during this tracking method change. // Use InstantPlacementPoint.TrackingMethod to customize pose update logic. // // See the Instant Placement Developer's Guide at: // https://developers.google.com/ar/develop/unity/instant-placement. if (Frame.Raycast(touch.position.x, touch.position.y, raycastFilter, out hit)) { // Use hit pose and camera pose to check if hittest is from the // back of the plane, if it is, no need to create the anchor. if ((hit.Trackable is DetectedPlane) && Vector3.Dot(FirstPersonCamera.transform.position - hit.Pose.position, hit.Pose.rotation * Vector3.up) < 0) { Debug.Log("Hit at back of the current DetectedPlane"); } else { if (DepthMenu != null) { // Show depth card window if necessary. DepthMenu.ConfigureDepthBeforePlacingFirstAsset(); } // Choose the prefab based on the Trackable that got hit. GameObject prefab; if (hit.Trackable is FeaturePoint) { prefab = GameObjectPointPrefab; } else if (hit.Trackable is DetectedPlane) { DetectedPlane detectedPlane = hit.Trackable as DetectedPlane; if (detectedPlane.PlaneType == DetectedPlaneType.Vertical) { prefab = GameObjectVerticalPlanePrefab; } else { prefab = GameObjectHorizontalPlanePrefab; } } else { prefab = GameObjectHorizontalPlanePrefab; } // Instantiate prefab at the hit pose. var gameObject = Instantiate(prefab, hit.Pose.position, hit.Pose.rotation); // Compensate for the hitPose rotation facing away from the raycast (i.e. // camera). gameObject.transform.Rotate(0, _prefabRotation, 0, Space.Self); // Create an anchor to allow ARCore to track the hitpoint as understanding of // the physical world evolves. var anchor = hit.Trackable.CreateAnchor(hit.Pose); // Make game object a child of the anchor. gameObject.transform.parent = anchor.transform; } } }
/// <summary> /// Function called when the manipulation is ended. /// </summary> /// <param name="gesture">The current gesture.</param> protected override void OnEndManipulation(TapGesture gesture) { if (gesture.WasCancelled) { return; } // If gesture is targeting an existing object we are done. if (gesture.TargetObject != null) { //Debug.Log("\nTarget Object != null"); return; } if (IsPointerOverUIObject()) { //Debug.Log("\n\nIsPointerOverUIObject"); return; } // Raycast against the location the player touched to search for planes. TrackableHit hit; TrackableHitFlags raycastFilter = TrackableHitFlags.PlaneWithinPolygon; if (Frame.Raycast( gesture.StartPosition.x, gesture.StartPosition.y, raycastFilter, out hit)) { // Use hit pose and camera pose to check if hittest is from the // back of the plane, if it is, no need to create the anchor. if ((hit.Trackable is DetectedPlane) && Vector3.Dot(FirstPersonCamera.transform.position - hit.Pose.position, hit.Pose.rotation * Vector3.up) < 0) { Debug.Log("Hit at back of the current DetectedPlane"); } else { // Instantiate game object at the hit pose. DetectedPlane detectedPlane = hit.Trackable as DetectedPlane; //Debug.Log("\n\n\n\n\ndetectedPlane.PlaneType=" + detectedPlane.PlaneType.ToString()); //Debug.Log("DetectedPlaneType.HorizontalUpwardFacing=" + DetectedPlaneType.HorizontalUpwardFacing.ToString()); //Debug.Log("currentNumberOfObjects=" + currentNumberOfObjects.ToString()); //Debug.Log("numberOfObjectsAllowed=" + numberOfObjectsAllowed.ToString()); //Debug.Log("===>Condition=" + (detectedPlane.PlaneType == DetectedPlaneType.HorizontalUpwardFacing && currentNumberOfObjects < numberOfObjectsAllowed).ToString()); //if (detectedPlane.PlaneType == DetectedPlaneType.Vertical && currentNumberOfVerticalObjects < numberOfObjectsAllowed) // { //GameObject modelprefab = Instantiate(GameObjectVerticalPlanePrefab, hit.Pose.position, hit.Pose.rotation); // GenerateModels(modelprefab, hit); // currentNumberOfVerticalObjects++; //} //else if (detectedPlane.PlaneType == DetectedPlaneType.HorizontalUpwardFacing && currentNumberOfObjects < numberOfObjectsAllowed ) //{ //floor //Debug.Log("\n\n hit horizontal !!!!!"); //int prefabval = SetValue.getprefab(); //if (prefabval == 0) //{ //GameObject modelprefab = Instantiate(tablePrefab, hit.Pose.position, hit.Pose.rotation); //GenerateModels(modelprefab, hit); //} //else //{ if (detectedPlane.PlaneType == DetectedPlaneType.Vertical || detectedPlane.PlaneType == DetectedPlaneType.HorizontalDownwardFacing || detectedPlane.PlaneType == DetectedPlaneType.HorizontalUpwardFacing) { Vector3 pos = hit.Pose.position; GameObject currGameObject = ItemListener.getSelectedGameObject(); if (currGameObject != null) { //hit.Pose.rotation GameObject modelprefab = Instantiate(currGameObject, pos, hit.Pose.rotation); //modelprefab.transform.localScale = new Vector3(0.01f, 0.01f, 0.01f); //modelprefab.AddComponent<BoxCollider>(); GenerateModels(modelprefab, hit); } } //} //currentNumberOfObjects++; //} //else if (detectedPlane.PlaneType == DetectedPlaneType.HorizontalDownwardFacing && currentNumberOfUpObjects < numberOfObjectsAllowed) //{ // GameObject modelprefab = Instantiate(GameObjectHorizontalUpwardPlanePrefab, hit.Pose.position, hit.Pose.rotation); // GenerateModels(modelprefab, hit); // currentNumberOfUpObjects++; //} } } }
/// <summary> /// The Unity Update() method. /// </summary> public void Update() { if ((Input.touchCount == 1) && (Input.GetTouch(0).phase == TouchPhase.Began)) { RaycastHit hitElem; Ray ray = Camera.main.ScreenPointToRay(Input.GetTouch(0).position); if (Physics.Raycast(ray, out hitElem)) { if (hitElem.collider.gameObject.tag == "QuitAnim") { //feedbackText.text = "Quit anim clicked!"; overlay.SetActive(false); cAnimController.SetActive(false); alAnimController.SetActive(false); hAnimController.SetActive(false); caAnimController.SetActive(false); oAnimController.SetActive(false); } if (hitElem.collider.gameObject.tag == "H") { //feedbackText.text = "H clicked!"; overlay.SetActive(true); hAnimController.SetActive(true); } if (hitElem.collider.gameObject.tag == "O") { //feedbackText.text = "O clicked!"; overlay.SetActive(true); oAnimController.SetActive(true); } if (hitElem.collider.gameObject.tag == "C") { //feedbackText.text = "C clicked!"; overlay.SetActive(true); cAnimController.SetActive(true); } if (hitElem.collider.gameObject.tag == "Ca") { //feedbackText.text = "Ca clicked!"; overlay.SetActive(true); caAnimController.SetActive(true); } if (hitElem.collider.gameObject.tag == "Al") { //feedbackText.text = "Al clicked!"; overlay.SetActive(true); alAnimController.SetActive(true); } } } _UpdateApplicationLifecycle(); if (!objInstantiated) { if (DepthMenu != null && !DepthMenu.CanPlaceAsset()) { return; } // If the player has not touched the screen, we are done with this update. Touch touch; if (Input.touchCount < 1 || (touch = Input.GetTouch(0)).phase != TouchPhase.Began) { return; } // Should not handle input if the player is pointing on UI. if (EventSystem.current.IsPointerOverGameObject(touch.fingerId)) { return; } // Raycast against the location the player touched to search for planes. TrackableHit hit; TrackableHitFlags raycastFilter = TrackableHitFlags.PlaneWithinPolygon | TrackableHitFlags.FeaturePointWithSurfaceNormal; if (Frame.Raycast(touch.position.x, touch.position.y, raycastFilter, out hit)) { // Use hit pose and camera pose to check if hittest is from the // back of the plane, if it is, no need to create the anchor. if ((hit.Trackable is DetectedPlane) && Vector3.Dot(FirstPersonCamera.transform.position - hit.Pose.position, hit.Pose.rotation * Vector3.up) < 0) { Debug.Log("Hit at back of the current DetectedPlane"); } else { if (DepthMenu != null) { // Show depth card window if necessary. DepthMenu.ConfigureDepthBeforePlacingFirstAsset(); } // Choose the prefab based on the Trackable that got hit. GameObject prefab; if (hit.Trackable is FeaturePoint) { prefab = GameObjectPointPrefab; } else if (hit.Trackable is DetectedPlane) { DetectedPlane detectedPlane = hit.Trackable as DetectedPlane; if (detectedPlane.PlaneType == DetectedPlaneType.Vertical) { prefab = GameObjectVerticalPlanePrefab; } else { prefab = GameObjectHorizontalPlanePrefab; } } else { prefab = GameObjectHorizontalPlanePrefab; } // Instantiate prefab at the hit pose. var gameObject = Instantiate(prefab, hit.Pose.position, hit.Pose.rotation); overlay = GameObject.FindWithTag("DarkOverlay"); cAnimController = GameObject.FindWithTag("CarbonAnimator"); alAnimController = GameObject.FindWithTag("AlluminumAnimator"); hAnimController = GameObject.FindWithTag("HydrogenAnimator"); caAnimController = GameObject.FindWithTag("CalciumAnimator"); oAnimController = GameObject.FindWithTag("OxygenAnimator"); overlay.SetActive(false); cAnimController.SetActive(false); alAnimController.SetActive(false); hAnimController.SetActive(false); caAnimController.SetActive(false); oAnimController.SetActive(false); // Compensate for the hitPose rotation facing away from the raycast (i.e. // camera). gameObject.transform.Rotate(0, k_PrefabRotation, 0, Space.Self); // Create an anchor to allow ARCore to track the hitpoint as understanding of // the physical world evolves. var anchor = hit.Trackable.CreateAnchor(hit.Pose); // Make game object a child of the anchor. gameObject.transform.parent = anchor.transform; gameObject.name = "Cube"; objInstantiated = true; } } } /*else * { * StopTrackingSurfaces(); * }*/ }
public void SetCurrentPlane(DetectedPlane plane) { CurrentPlane = plane; }
private void TestPlaneOn(DetectedPlane plane) { testPlaneDisplay.DisplayTestPlane(plane, selectedObjectCollider); testPlaneDisplayed = true; }
/// <summary> /// The Unity Update() method. /// </summary> public void UpdateObjectPlacer() { _UpdateApplicationLifecycle(); // If the player has not touched the screen, we are done with this update. Touch touch; if (Input.touchCount < 1 || (touch = Input.GetTouch(0)).phase != TouchPhase.Began) { return; } // Should not handle input if the player is pointing on UI. if (EventSystem.current.IsPointerOverGameObject(touch.fingerId)) { return; } //Check if it collided with another object if (!IsReplacing && !IsPlacing) { Ray ray = Camera.main.ScreenPointToRay(touch.position); RaycastHit firstHit; if (Physics.Raycast(ray, out firstHit)) { if (firstHit.collider.tag == "Object") { IsPlacing = true; IsReplacing = true; //SELECT OBJECT SelectedObject = firstHit.collider.gameObject; AppManager.Instance.ActivatePlacingUI(); //CHANTE MATERIAL ChangeObjectMaterial(SelectedObject, SelectedColor); return; } } } // Raycast against the location the player touched to search for planes. TrackableHit hit; TrackableHitFlags raycastFilter = TrackableHitFlags.PlaneWithinPolygon | TrackableHitFlags.FeaturePointWithSurfaceNormal; if (Frame.Raycast(touch.position.x, touch.position.y, raycastFilter, out hit)) { // Use hit pose and camera pose to check if hittest is from the // back of the plane, if it is, no need to create the anchor. if ((hit.Trackable is DetectedPlane) && Vector3.Dot(FirstPersonCamera.transform.position - hit.Pose.position, hit.Pose.rotation * Vector3.up) < 0) { Debug.Log("Hit at back of the current DetectedPlane"); } else { // Choose the Andy model for the Trackable that got hit. GameObject prefab; //Remove trackable points intantiation if (hit.Trackable is FeaturePoint) { prefab = AndyPointPrefab; } else if (hit.Trackable is DetectedPlane) { DetectedPlane detectedPlane = hit.Trackable as DetectedPlane; if (detectedPlane.PlaneType == DetectedPlaneType.Vertical) { //Vertical prefab = CurrentCatalogObject.Prefab; } else { //Horizontal plane prefab = CurrentCatalogObject.Prefab; } } else { //Horizontal prefab = CurrentCatalogObject.Prefab; } GameObject andyObject; if (IsPlacing) { if (IsReplacing) { andyObject = SelectedObject; andyObject.transform.position = hit.Pose.position; andyObject.transform.rotation = hit.Pose.rotation; } else { andyObject = placedModels[placedModels.Count - 1]; andyObject.transform.position = hit.Pose.position; andyObject.transform.rotation = hit.Pose.rotation; } } //If not placing a object, Instantiante new one else { //// Instantiate Andy model at the hit pose. andyObject = Instantiate(prefab, hit.Pose.position, hit.Pose.rotation); placedModels.Add(andyObject); IsPlacing = true; // Create an anchor to allow ARCore to track the hitpoint as understanding of // the physical world evolves. var anchor = hit.Trackable.CreateAnchor(hit.Pose); // Make Andy model a child of the anchor. andyObject.transform.parent = anchor.transform; //CHANGE COLOR ChangeObjectMaterial(andyObject, SelectedColor); AppManager.Instance.ActivatePlacingUI(); } // Compensate for the hitPose rotation facing away from the raycast (i.e. // camera). andyObject.transform.Rotate(0, k_ModelRotation, 0, Space.Self); } } }
private void PerformHitTest(Vector2 touchPos) { var planeType = DetectedPlaneType.HorizontalUpwardFacing; if (Application.platform == RuntimePlatform.IPhonePlayer) { #if ARCORE_IOS_SUPPORT var session = UnityARSessionNativeInterface.GetARSessionNativeInterface(); var viewportPoint = Controller.MainCamera.ScreenToViewportPoint(touchPos); ARPoint arPoint = new ARPoint { x = viewportPoint.x, y = viewportPoint.y }; _hitResultList = session.HitTest(arPoint, ARHitTestResultType.ARHitTestResultTypeExistingPlaneUsingExtent); if (_hitResultList.Count > 0) { // Fetch the closest hit result. int minDistanceIndex = GetMinDistanceIndex(_hitResultList); string identifier = _hitResultList[minDistanceIndex].anchorIdentifier; if (_arPlaneAligmentMapping.ContainsKey(identifier)) { planeType = _arPlaneAligmentMapping[identifier] == ARPlaneAnchorAlignment.ARPlaneAnchorAlignmentVertical ? DetectedPlaneType.Vertical : DetectedPlaneType.HorizontalUpwardFacing; } else { Debug.LogWarningFormat("Didn't find anchor identifier: {0}", identifier); return; } Pose hitPose = new Pose(); hitPose.position = UnityARMatrixOps.GetPosition( _hitResultList[minDistanceIndex].worldTransform); if (planeType == DetectedPlaneType.Vertical) { hitPose.rotation = UnityARMatrixOps.GetRotation( _hitResultList[minDistanceIndex].worldTransform); } else { // Point the hitPose rotation roughly away from the raycast/camera // to match ARCore. hitPose.rotation.eulerAngles = new Vector3(0.0f, Controller.MainCamera.transform.eulerAngles.y, 0.0f); } _hitPose = hitPose; var anchorGO = new GameObject("ARUserAnchor"); _anchorComponent = anchorGO.AddComponent <UnityARUserAnchorComponent>(); anchorGO.transform.position = hitPose.position; anchorGO.transform.rotation = hitPose.rotation; } #endif } else { TrackableHit arcoreHitResult = new TrackableHit(); if (Frame.Raycast(touchPos.x, touchPos.y, TrackableHitFlags.PlaneWithinPolygon, out arcoreHitResult)) { DetectedPlane plane = arcoreHitResult.Trackable as DetectedPlane; if (plane == null) { Debug.LogWarning("Hit test result has invalid trackable type: " + arcoreHitResult.Trackable.GetType()); return; } planeType = plane.PlaneType; _hitPose = arcoreHitResult.Pose; _anchorComponent = arcoreHitResult.Trackable.CreateAnchor(arcoreHitResult.Pose); } } if (_anchorComponent != null) { Instantiate(CloudAnchorPrefab, _anchorComponent.transform); // Attach map quality indicator to this pawn. var indicatorGO = Instantiate(MapQualityIndicatorPrefab, _anchorComponent.transform); _qualityIndicator = indicatorGO.GetComponent <MapQualityIndicator>(); _qualityIndicator.DrawIndicator(planeType, Controller.MainCamera); InstructionText.text = " To save this location, walk around the object to " + "capture it from different angles"; DebugText.text = "Waiting for sufficient mapping quaility..."; // Hide plane generator so users can focus on the object they placed. Controller.PlaneGenerator.SetActive(false); } }
public void SetSelectedPlane(DetectedPlane detectedPlane) { this.detectedPlane = detectedPlane; CreateAnchor(); }
/// <summary> /// Select the plane attached to the nutrition panel /// </summary> void SetSelectedPlane(DetectedPlane selectedPlane) { // Call for nutrition panel controller : Anchor scoreboard to the selected plane nutritionPanel.SetSelectedPlane(selectedPlane); }
/// <summary> /// The Unity Update() method. /// </summary> public void Update() { _UpdateApplicationLifecycle(); // If the player has not touched the screen, we are done with this update. Touch touch; if (Input.touchCount < 1 || (touch = Input.GetTouch(0)).phase != TouchPhase.Began) { return; } // Should not handle input if the player is pointing on UI. if (EventSystem.current.IsPointerOverGameObject(touch.fingerId)) { return; } // Raycast against the location the player touched to search for planes. TrackableHit hit; TrackableHitFlags raycastFilter = TrackableHitFlags.PlaneWithinPolygon | TrackableHitFlags.FeaturePointWithSurfaceNormal; if (Frame.Raycast(touch.position.x, touch.position.y, raycastFilter, out hit)) { // Use hit pose and camera pose to check if hittest is from the // back of the plane, if it is, no need to create the anchor. if ((hit.Trackable is DetectedPlane) && Vector3.Dot(FirstPersonCamera.transform.position - hit.Pose.position, hit.Pose.rotation * Vector3.up) < 0) { Debug.Log("Hit at back of the current DetectedPlane"); } else { // Choose the prefab based on the Trackable that got hit. GameObject prefab; if (hit.Trackable is FeaturePoint) { prefab = GameObjectPointPrefab; } else if (hit.Trackable is DetectedPlane) { DetectedPlane detectedPlane = hit.Trackable as DetectedPlane; if (detectedPlane.PlaneType == DetectedPlaneType.Vertical) { prefab = GameObjectVerticalPlanePrefab; } else { prefab = GameObjectHorizontalPlanePrefab; } } else { prefab = GameObjectHorizontalPlanePrefab; } // trying to instantiate only one dragon instead of the many that one can instantiate otherwise in HelloAR orignal code //one dragon is easier to control if (numDragons < 2) { // Instantiate prefab at the hit pose. gameObject2 = Instantiate(prefab, hit.Pose.position, hit.Pose.rotation); // Compensate for the hitPose rotation facing away from the raycast (i.e. // camera). gameObject2.transform.Rotate(0, k_PrefabRotation, 0, Space.Self); // Create an anchor to allow ARCore to track the hitpoint as understanding of // the physical world evolves. var anchor = hit.Trackable.CreateAnchor(hit.Pose); // Make game object a child of the anchor. gameObject2.transform.parent = anchor.transform; numDragons += 1; } //trying to move dragon around based on screen tilt if (Input.deviceOrientation == DeviceOrientation.FaceDown) { gameObject2.transform.Translate(Vector3.forward * Time.deltaTime, Space.World); } if (Input.deviceOrientation == DeviceOrientation.FaceUp) { gameObject2.transform.Translate(Vector3.back * Time.deltaTime, Space.World); } if (Input.deviceOrientation == DeviceOrientation.LandscapeLeft) { gameObject2.transform.Translate(Vector3.left * Time.deltaTime, Space.World); } if (Input.deviceOrientation == DeviceOrientation.LandscapeRight) { gameObject2.transform.Translate(Vector3.right * Time.deltaTime, Space.World); } if (Input.touchCount > 0) { //if there is any touch touchDuration += Time.deltaTime; touch = Input.GetTouch(0); if (touch.phase == TouchPhase.Ended && touchDuration < 0.2f) //making sure it only check the touch once && it was a short touch/tap and not a dragging. { StartCoroutine("singleOrDouble"); } } else { touchDuration = 0.0f; } } // trying to make the zombie jump on double tap IEnumerator singleOrDouble() { yield return(new WaitForSeconds(0.3f)); if (touch.tapCount == 1) { Debug.Log("Single"); } else if (touch.tapCount == 2) { //this coroutine has been called twice. We should stop the next one here otherwise we get two double tap StopCoroutine("singleOrDouble"); Debug.Log("Double"); gameObject2.transform.Translate(Vector3.up * 260 * Time.deltaTime, Space.World); } } } }
void SetSelectedPlane(DetectedPlane selectedPlane) { Debug.Log("Selected plane centered at " + selectedPlane.CenterPose.position); // Add to the end of SetSelectedPlane. scoreboard.SetSelectedPlane(selectedPlane); }
public GameObject[] plants; //augi public void SetSelectedPlane(DetectedPlane selectedPlane) { detectedPlane = selectedPlane; }
/// <summary> /// The Unity Update() method. /// </summary> public void Update() { // To use Recording API: // 1. Create an instance of ARCoreRecordingConfig. The Mp4DatasetFilepath needs to // be accessible by the app, e.g. Application.persistentDataPath, or you can request // the permission of external storage. // 2. Call Session.StartRecording(ARCoreRecordingConfig) when a valid ARCore session // is available. // 3. Call Session.StopRecording() to end the recording. When // ARCoreRecordingConfig.AutoStopOnPause is true, it can also stop recording when // the ARCoreSession component is disabled. // To use Playback API: // 1. Pause the session by disabling ARCoreSession component. // 2. In the next frame or later, call Session.SetPlaybackDataset(datasetFilepath) // where the datasetFilepath is the same one used by Recording API. // 3. In the next frame or later, resume the session by enabling ARCoreSession component // and the app will play the recorded camera stream install of using the real time // camera stream. UpdateApplicationLifecycle(); // If the player has not touched the screen, we are done with this update. Touch touch; if (Input.touchCount < 1 || (touch = Input.GetTouch(0)).phase != TouchPhase.Began) { return; } // Should not handle input if the player is pointing on UI. if (EventSystem.current.IsPointerOverGameObject(touch.fingerId)) { return; } // Raycast against the location the player touched to search for planes. TrackableHit hit; bool foundHit = false; TrackableHitFlags raycastFilter = TrackableHitFlags.PlaneWithinPolygon | TrackableHitFlags.FeaturePointWithSurfaceNormal; // Allows the depth image to be queried for hit tests. raycastFilter |= TrackableHitFlags.Depth; foundHit = Frame.Raycast(touch.position.x, touch.position.y, raycastFilter, out hit); if (!foundHit && InstantPlacementMenu.IsInstantPlacementEnabled()) { foundHit = Frame.RaycastInstantPlacement( touch.position.x, touch.position.y, 1.0f, out hit); } if (foundHit) { // Use hit pose and camera pose to check if hittest is from the // back of the plane, if it is, no need to create the anchor. if ((hit.Trackable is DetectedPlane) && Vector3.Dot(FirstPersonCamera.transform.position - hit.Pose.position, hit.Pose.rotation * Vector3.up) < 0) { Debug.Log("Hit at back of the current DetectedPlane"); } else { if (DepthMenu != null) { // Show depth card window if necessary. DepthMenu.ConfigureDepthBeforePlacingFirstAsset(); } // Choose the prefab based on the Trackable that got hit. GameObject prefab; if (hit.Trackable is InstantPlacementPoint) { prefab = InstantPlacementPrefab; } else if (hit.Trackable is FeaturePoint) { prefab = GameObjectPointPrefab; } else if (hit.Trackable is DepthPoint) { prefab = GameObjectDepthPointPrefab; } else if (hit.Trackable is DetectedPlane) { DetectedPlane detectedPlane = hit.Trackable as DetectedPlane; if (detectedPlane.PlaneType == DetectedPlaneType.Vertical) { prefab = GameObjectVerticalPlanePrefab; } else { prefab = GameObjectHorizontalPlanePrefab; } } else { prefab = GameObjectHorizontalPlanePrefab; } // Instantiate prefab at the hit pose. var gameObject = Instantiate(prefab, hit.Pose.position, hit.Pose.rotation); // Compensate for the hitPose rotation facing away from the raycast (i.e. // camera). gameObject.transform.Rotate(0, _prefabRotation, 0, Space.Self); // Create an anchor to allow ARCore to track the hitpoint as understanding of // the physical world evolves. var anchor = hit.Trackable.CreateAnchor(hit.Pose); // Make game object a child of the anchor. gameObject.transform.parent = anchor.transform; // Initialize Instant Placement Effect. if (hit.Trackable is InstantPlacementPoint) { gameObject.GetComponentInChildren <InstantPlacementEffect>() .InitializeWithTrackable(hit.Trackable); } } } }
/// <summary> /// Calculates the best position to place an object in AR based on screen position. /// Could be used for tapping a location on the screen, dragging an object, or using a fixed /// cursor in the center of the screen for placing and moving objects. /// /// Objects are placed along the x/z of the grounding plane. When placed on an AR plane /// below the grounding plane, the object will drop straight down onto it in world space. /// This prevents the object from being pushed deeper into the scene when moving from a /// higher plane to a lower plane. When moving from a lower plane to a higher plane, this /// function returns a new groundingPlane to replace the old one. /// </summary> /// <returns>The best placement position.</returns> /// <param name="currentAnchorPosition">Position of the parent anchor, i.e., where the /// object is before translation starts.</param> /// <param name="screenPos">Location on the screen in pixels to place the object at.</param> /// <param name="groundingPlaneHeight">The starting height of the plane that the object is /// being placed along.</param> /// <param name="hoverOffset">How much should the object hover above the groundingPlane /// before it has been placed.</param> /// <param name="maxTranslationDistance">The maximum distance that the object can be /// translated.</param> /// <param name="translationMode">The translation mode, indicating the plane types allowed. /// </param> public static Placement GetBestPlacementPosition( Vector3 currentAnchorPosition, Vector2 screenPos, float groundingPlaneHeight, float hoverOffset, float maxTranslationDistance, TranslationMode translationMode) { Placement result = new Placement(); result.UpdatedGroundingPlaneHeight = groundingPlaneHeight; // Get the angle between the camera and the object's down direction. float angle = Vector3.Angle(Camera.main.transform.forward, Vector3.down); angle = 90.0f - angle; float touchOffsetRatio = Mathf.Clamp01(angle / 90.0f); float screenTouchOffset = touchOffsetRatio * k_MaxScreenTouchOffset; screenPos.y += GestureTouchesUtility.InchesToPixels(screenTouchOffset); float hoverRatio = Mathf.Clamp01(angle / 45.0f); hoverOffset *= hoverRatio; float distance = (Camera.main.transform.position - currentAnchorPosition).magnitude; float distanceHoverRatio = Mathf.Clamp01(distance / k_HoverDistanceThreshold); hoverOffset *= distanceHoverRatio; // The best estimate of the point in the plane where the object will be placed: Vector3 groundingPoint; // Get the ray to cast into the scene from the perspective of the camera. TrackableHit hit; if (Frame.Raycast( screenPos.x, screenPos.y, TrackableHitFlags.PlaneWithinBounds, out hit)) { if (hit.Trackable is DetectedPlane) { DetectedPlane plane = hit.Trackable as DetectedPlane; if (IsPlaneTypeAllowed(translationMode, plane.PlaneType)) { // Avoid detecting the back of existing planes. if ((hit.Trackable is DetectedPlane) && Vector3.Dot(Camera.main.transform.position - hit.Pose.position, hit.Pose.rotation * Vector3.up) < 0) { Debug.Log("Hit at back of the current DetectedPlane"); return(result); } // Don't allow hovering for vertical or horizontal downward facing planes. if (plane.PlaneType == DetectedPlaneType.Vertical || plane.PlaneType == DetectedPlaneType.HorizontalDownwardFacing) { // Limit the translation to maxTranslationDistance. groundingPoint = LimitTranslation( hit.Pose.position, currentAnchorPosition, maxTranslationDistance); groundingPoint.y = groundingPlaneHeight; result.PlacementPlane = hit; result.PlacementPosition = groundingPoint; result.HoveringPosition = groundingPoint; result.UpdatedGroundingPlaneHeight = groundingPoint.y; //result.PlacementRotation = hit.Pose.rotation; return(result); } // Allow hovering for horizontal upward facing planes. if (plane.PlaneType == DetectedPlaneType.HorizontalUpwardFacing) { // Return early if the camera is pointing upwards. if (angle < 0f) { return(result); } // Limit the translation to maxTranslationDistance. groundingPoint = LimitTranslation( hit.Pose.position, currentAnchorPosition, maxTranslationDistance); groundingPoint.y = groundingPlaneHeight; //changed // Find the hovering position by casting from the camera onto the // grounding plane and offsetting the result by the hover offset. result.HoveringPosition = groundingPoint + (Vector3.up * hoverOffset); // If the AR Plane is above the grounding plane, then the hit plane's // position is used to replace the current groundingPlane. Otherwise, // the hit is ignored because hits are only detected on lower planes by // casting straight downwards in world space. if (groundingPoint.y > groundingPlaneHeight) { result.PlacementPlane = hit; result.PlacementPosition = groundingPoint; result.UpdatedGroundingPlaneHeight = hit.Pose.position.y; //result.PlacementRotation = hit.Pose.rotation; return(result); } } else { // Not supported plane type. return(result); } } else { // Plane type not allowed. return(result); } } else { // Hit is not a plane. return(result); } } // Return early if the camera is pointing upwards. if (angle < 0f) { return(result); } // If the grounding point is lower than the current gorunding plane height, or if the // raycast did not return a hit, then we extend the grounding plane to infinity, and do // a new raycast into the scene from the perspective of the camera. Ray cameraRay = Camera.main.ScreenPointToRay(screenPos); Plane groundingPlane = new Plane(Vector3.up, new Vector3(0.0f, groundingPlaneHeight, 0.0f)); // Find the hovering position by casting from the camera onto the grounding plane // and offsetting the result by the hover offset. float enter; if (groundingPlane.Raycast(cameraRay, out enter)) { groundingPoint = LimitTranslation( cameraRay.GetPoint(enter), currentAnchorPosition, maxTranslationDistance); groundingPoint.y = groundingPlaneHeight; //changed result.HoveringPosition = groundingPoint + (Vector3.up * hoverOffset); } else { // If we can't successfully cast onto the groundingPlane, just return early. return(result); } // Cast straight down onto AR planes that are lower than the current grounding plane. if (Frame.Raycast( groundingPoint + (Vector3.up * k_DownRayOffset), Vector3.down, out hit, Mathf.Infinity, TrackableHitFlags.PlaneWithinBounds)) { result.PlacementPosition = hit.Pose.position; result.PlacementPlane = hit; //result.PlacementRotation = hit.Pose.rotation; //result.UpdatedGroundingPlaneHeight = groundingPlaneHeight;//changed return(result); } return(result); }
public void SetSelectedPlane(TrackableHit hit) { Debug.Log("Setting plane to: " + hit.Trackable); detectedPlane = (DetectedPlane)hit.Trackable; AttachToAnchor(hit); }
void Update() { _UpdateApplicationLifecycle(); Touch touch; if (Input.touchCount < 1 || (touch = Input.GetTouch(0)).phase != TouchPhase.Began) { return; } if (EventSystem.current.IsPointerOverGameObject(touch.fingerId)) { return; } TrackableHit hit; TrackableHitFlags raycastFilter = TrackableHitFlags.PlaneWithinPolygon | TrackableHitFlags.FeaturePointWithSurfaceNormal; if (Frame.Raycast(touch.position.x, touch.position.y, raycastFilter, out hit)) { if ((hit.Trackable is DetectedPlane) && Vector3.Dot(FirstPersonCamera.transform.position - hit.Pose.position, hit.Pose.rotation * Vector3.up) < 0) { Debug.Log("Hit at back of the current DetectedPlane"); } else { GameObject prefab; if (hit.Trackable is FeaturePoint) { prefab = _respawnPoint; _isStarted = true; } else if (hit.Trackable is DetectedPlane) { DetectedPlane detectedPlane = hit.Trackable as DetectedPlane; if (detectedPlane.PlaneType == DetectedPlaneType.Vertical) { prefab = _respawnPoint; _isStarted = true; } else { prefab = _respawnPoint; _isStarted = true; } } else { prefab = _respawnPoint; _isStarted = true; } var RespawnPoint = Instantiate(prefab, hit.Pose.position, hit.Pose.rotation); RespawnPoint.transform.Rotate(0, k_ModelRotation, 0, Space.Self); var anchor = hit.Trackable.CreateAnchor(hit.Pose); RespawnPoint.transform.parent = anchor.transform; } } }
/// <summary> /// The Unity Update() method. /// </summary> public void Update() { _UpdateApplicationLifecycle(); //Checks the current phase CheckPhase(); //If we are in the Display Phase, we need to check touches to set the furniture if (currentPhase == Phase.Display) { // If the player has not touched the screen, we are done with this update. Touch touch; if (Input.touchCount < 1 || (touch = Input.GetTouch(0)).phase != TouchPhase.Began) { return; } // Should not handle input if the player is pointing on UI. if (EventSystem.current.IsPointerOverGameObject(touch.fingerId)) { return; } // Raycast against the location the player touched to search for planes. TrackableHit hit; TrackableHitFlags raycastFilter = TrackableHitFlags.PlaneWithinPolygon | TrackableHitFlags.FeaturePointWithSurfaceNormal; if (Frame.Raycast(touch.position.x, touch.position.y, raycastFilter, out hit)) { // Use hit pose and camera pose to check if hittest is from the // back of the plane, if it is, no need to create the anchor. if ((hit.Trackable is DetectedPlane) && Vector3.Dot(FirstPersonCamera.transform.position - hit.Pose.position, hit.Pose.rotation * Vector3.up) < 0) { Debug.Log("Hit at back of the current DetectedPlane"); } else { // Choose the Kivik model for the Trackable that got hit. GameObject prefab = null; /*if (hit.Trackable is FeaturePoint) * { * prefab = AndyPointPrefab; * }*/ if (hit.Trackable is DetectedPlane) { DetectedPlane detectedPlane = hit.Trackable as DetectedPlane; if (detectedPlane.PlaneType == DetectedPlaneType.Vertical) { prefab = Furniture; } else { prefab = Furniture; } } /*else * { * prefab = AndyHorizontalPlanePrefab; * }*/ // Instantiate Andy model at the hit pose. var andyObject = Instantiate(prefab, hit.Pose.position, hit.Pose.rotation); // Compensate for the hitPose rotation facing away from the raycast (i.e. // camera). andyObject.transform.Rotate(0, k_ModelRotation, 0, Space.Self); // Create an anchor to allow ARCore to track the hitpoint as understanding of // the physical world evolves. var anchor = hit.Trackable.CreateAnchor(hit.Pose); // Make Andy model a child of the anchor. andyObject.transform.parent = anchor.transform; //Get the displayed object sofa = andyObject; //If everything has gone ok, we change the phase if (sofa != null) { currentPhase = Phase.Rotate; //Gives the object to the rotation scripts by reference RotateLeft.GetComponent <RotateLeft>().setSofa(sofa); RotateRight.GetComponent <RotateRight>().setSofa(sofa); //Gives a callback to the animation buttons AnimateForward.GetComponent <Button>().onClick.AddListener(sofa.GetComponent <AnimationController>().setForward); AnimateBackward.GetComponent <Button>().onClick.AddListener(sofa.GetComponent <AnimationController>().setBackward); } } } } }
void SetSelectedPlane(DetectedPlane selectedPlane) { Debug.Log("Selected plane centered at " + selectedPlane.CenterPose.position); cube.SetSelectedPlane(selectedPlane); }
public void Update() { EventDetection(); Session.GetTrackables <DetectedPlane>(planes); bool trackingUI = true; for (int i = 0; i < planes.Count; i++) { if (planes[i].TrackingState == TrackingState.Tracking) { trackingUI = false; break; } } Touch touch; if (Input.touchCount < 1 || (touch = Input.GetTouch(0)).phase != TouchPhase.Began) { return; } TrackableHit hit; TrackableHitFlags raycastFilter = TrackableHitFlags.PlaneWithinPolygon | TrackableHitFlags.FeaturePointWithSurfaceNormal; RaycastHit[] h; Ray r = camera.ScreenPointToRay(touch.position); h = Physics.RaycastAll(r); for (int i = 0; i < h.Length; i++) { h[i].collider.gameObject.SendMessage("turnOnGravity", SendMessageOptions.DontRequireReceiver); } if (Frame.Raycast(touch.position.x, touch.position.y, raycastFilter, out hit)) { if ((hit.Trackable is DetectedPlane) && Vector3.Dot(camera.transform.position - hit.Pose.position, hit.Pose.rotation * Vector3.up) < 0) { Debug.Log("Hit at back of the current DetectedPlane"); } else { if ((hit.Trackable is DetectedPlane)) { DetectedPlane plane = (DetectedPlane)hit.Trackable; if (plane.PlaneType == DetectedPlaneType.Vertical && currentFrameOnScene < frameLimit) { var andyObject = Instantiate(prefab, hit.Pose.position, hit.Pose.rotation); andyObject.transform.position = new Vector3(hit.Pose.position.x + 0.06f, hit.Pose.position.y + 0.06f, hit.Pose.position.z + 0.06f); var placedObjectForward = Vector3.up; var placedObjectUp = plane.CenterPose.rotation * Vector3.up; Vector3 normal = plane.CenterPose.rotation * Vector3.up; andyObject.transform.rotation = Quaternion.LookRotation(placedObjectForward, placedObjectUp); andyObject.transform.Rotate(-90, 0, 180); andyObject.transform.Translate(Vector3.forward * 0.05f); var anchor = hit.Trackable.CreateAnchor(hit.Pose); andyObject.transform.parent = anchor.transform; currentFrameOnScene++; if (currentFrameOnScene >= frameLimit) { List <GameObject> l = DetectedPlanePrefab.GetComponent <GoogleARCore.Examples.Common.DetectedPlaneGenerator>().getPlaneList(); for (int i = 0; i < l.Count; i++) { Destroy(l[i].GetComponent <MeshRenderer>()); } } } else { Handheld.Vibrate(); } } } } }