private void UpdateImageAnchor(ARImageAnchor arImageAnchor)
{
Debug.LogFormat("image anchor updated[{0}] : tracked => {1}", arImageAnchor.Identifier, arImageAnchor.IsTracked);
if (arImageAnchor.ReferenceImageName == "dynamicImage")
{
if (_gameObject != null)
{
if (arImageAnchor.IsTracked)
{
if (!_gameObject.activeSelf)
{
_gameObject.SetActive(true);
}
_gameObject.transform.position = UnityARMatrixOps.GetPosition(arImageAnchor.Transform);
_gameObject.transform.rotation = UnityARMatrixOps.GetRotation(arImageAnchor.Transform);
}
else if (_gameObject.activeSelf)
{
//_imageAnchorGO.SetActive(false);
}
}
}
}
/// <summary>
/// Get the camera pose for the current frame.
/// </summary>
/// <returns>The camera pose of the current frame.</returns>
public static Pose GetCameraPose()
{
Pose framePose = new Pose();
if (Application.platform == RuntimePlatform.IPhonePlayer)
{
#if ARCORE_IOS_SUPPORT
var session = UnityARSessionNativeInterface.GetARSessionNativeInterface();
if (session != null)
{
var matrix = session.GetCameraPose();
framePose.position = UnityARMatrixOps.GetPosition(matrix);
framePose.rotation = UnityARMatrixOps.GetRotation(matrix);
}
#endif
}
else
{
framePose = Frame.Pose;
}
return(framePose);
}
void UpdateImageAnchor(ARImageAnchor arImageAnchor)
{
m_logger.Debug("image anchor updated {0}", arImageAnchor.referenceImageName);
ARKitTrackedImage trackedImage;
if (m_trackedImages.TryGetValue(arImageAnchor.identifier, out trackedImage))
{
trackedImage.gameObject.SetActive(true);
trackedImage.gameObject.transform.position = UnityARMatrixOps.GetPosition(arImageAnchor.transform);
trackedImage.gameObject.transform.rotation = UnityARMatrixOps.GetRotation(arImageAnchor.transform);
trackedImage.transform.localScale = arImageAnchor.transform.lossyScale * arImageAnchor.referenceImagePhysicalSize;
/*
* m_logger.Debug("Setting pos={0} rot={1} scale={2}",
* trackedImage.gameObject.transform.position,
* trackedImage.gameObject.transform.rotation.eulerAngles,
* trackedImage.transform.localScale);
*/
}
}
bool HitTestWithResultType(ARPoint point, ARHitTestResultType resultTypes)
{
Debug.Log("Enter HitTestWithResultType!");
List <ARHitTestResult> hitResults = UnityARSessionNativeInterface.GetARSessionNativeInterface().HitTest(point, resultTypes);
Debug.Log("HitResults " + hitResults.Count);
if (hitResults.Count > 0)
{
foreach (var hitResult in hitResults)
{
Debug.Log("Got hit!");
m_HitObject.transform.position = UnityARMatrixOps.GetPosition(hitResult.worldTransform);
m_HitObject.transform.rotation = Quaternion.LookRotation(new Vector3(
m_HitObject.transform.position.x - arCameraManager.m_camera.transform.localPosition.x,
0.0f,
m_HitObject.transform.position.z - arCameraManager.m_camera.transform.position.z));
m_HitObject.SetActive(true);
return(true);
}
}
m_HitObject.SetActive(false);
return(false);
}
/// <summary>
/// Finds a target object by name and updates its state.
/// </summary>
/// <param name="label"> A label to aid in debugging.</param>
/// <param name="anchorData">Anchor data.</param>
/// <param name="act"> The action to perform once the target is found.</param>
private void WithTarget(string label, ARImageAnchor anchorData, Action <TrackableFoundEventHandler> act)
{
var tracking = Tracking ? "tracking" : "not tracking";
ScreenDebugger.Print($"{label} {anchorData.referenceImageName} [{tracking}]");
if (Tracking)
{
var targetName = anchorData.referenceImageName;
if (targetsByName.ContainsKey(targetName))
{
var target = targetsByName[targetName];
act?.Invoke(target);
target.transform.position = UnityARMatrixOps.GetPosition(anchorData.transform);
target.transform.rotation = UnityARMatrixOps.GetRotation(anchorData.transform);
}
else
{
ScreenDebugger.Print($"Couldn't find {targetName}");
ScreenDebugger.Print($"Names we recognize: {string.Join(", ", targetsByName.Keys.ToArray())}");
}
}
}
void AddImageAnchor(ARImageAnchor arImageAnchor)
{
Debug.Log("image anchor added");
if (arImageAnchor.referenceImageName == referenceImage.imageName)
{
transform.position = UnityARMatrixOps.GetPosition(arImageAnchor.transform);
transform.rotation = UnityARMatrixOps.GetRotation(arImageAnchor.transform);
if (Marker != null)
{
_myMarker = Instantiate(Marker, Anchor.position, Anchor.rotation);
_myMarker.GetComponent <MarkerQuadScript>().setARImage(referenceImage);
StartCoroutine(HideMarker());
}
if (detected != null)
{
detected(this);
}
_lastTimeUpdate = Time.time;
}
}
public static ExARKitPlaneMeshRender UpdatePlaneWithAnchorTransform(ExARKitPlaneMeshRender plane, ARPlaneAnchor arPlaneAnchor)
{
//do coordinate conversion from ARKit to Unity
plane.transform.position = UnityARMatrixOps.GetPosition(arPlaneAnchor.transform);
plane.transform.rotation = UnityARMatrixOps.GetRotation(arPlaneAnchor.transform);
plane.UpdateMesh(arPlaneAnchor);
MeshFilter mf = plane.GetComponentInChildren <MeshFilter> ();
if (mf != null)
{
//if (apmr == null) {
//since our plane mesh is actually 10mx10m in the world, we scale it here by 0.1f
mf.gameObject.transform.localScale = new Vector3(arPlaneAnchor.extent.x * 0.1f, arPlaneAnchor.extent.y * 0.1f, arPlaneAnchor.extent.z * 0.1f);
//convert our center position to unity coords
mf.gameObject.transform.localPosition = new Vector3(arPlaneAnchor.center.x, arPlaneAnchor.center.y, -arPlaneAnchor.center.z);
//}
}
return(plane);
}
void AddImageAnchor(ARImageAnchor arImageAnchor)
{
Debug.LogFormat("image anchor added[{0}] : tracked => {1}", arImageAnchor.identifier, arImageAnchor.isTracked);
if (arImageAnchor.referenceImageName == referenceImage.imageName)
{
markerPosition = UnityARMatrixOps.GetPosition(arImageAnchor.transform);
markerRotation = UnityARMatrixOps.GetRotation(arImageAnchor.transform);
Debug.Log("Marker Position: " + markerPosition);
Debug.Log("Marker Rotation: " + markerRotation);
imageAnchorGO = Instantiate <GameObject>(prefabToGenerate, markerPosition, markerRotation);
GameObject markerText = GameObject.Find("markerLocation");
//GameObject markerFoundPrompt = new GameObject();
//markerFoundPrompt.AddComponent<TextMesh>();
//markerFoundPrompt.GetComponent<TextMesh>().text = "Marker position: " + markerPosition + ". MarkerRotation: " + markerRotation ;
//Vector3 worldPoint = Camera.main.ScreenToWorldPoint(new Vector3(0, 0, 0));
//imageAnchorGO = Instantiate<GameObject> (markerFoundPrompt, worldPoint, Quaternion.identity);
//Debug.Log(markerFoundPrompt.GetComponent<TextMesh>().text);
//Debug.Log(markerFoundPrompt.GetComponent<TextMesh>().transform.position);
//Debug.Log(markerFoundPrompt.GetComponent<TextMesh>().transform.rotation);
}
}
private bool HitTestWithResultType(ARPoint point, ARHitTestResultType resultTypes)
{
List <ARHitTestResult> hitResults = UnityARSessionNativeInterface.GetARSessionNativeInterface().HitTest(point, resultTypes);
if (hitResults.Count > 0)
{
foreach (var hitResult in hitResults)
{
Debug.Log("Got hit!");
m_HitTransform.position = UnityARMatrixOps.GetPosition(hitResult.worldTransform);
m_HitTransform.rotation = UnityARMatrixOps.GetRotation(hitResult.worldTransform);
//targetPosition = UnityARMatrixOps.GetPosition(hitResult.worldTransform);
targetRotation = UnityARMatrixOps.GetRotation(hitResult.worldTransform);
//m_HitTransform.position = targetPosition;
//m_HitTransform.rotation = targetRotation;
//FramePerfabs.transform.position = targetPosition;
// FramePerfabs.transform.rotation = targetRotation;
Debug.Log(string.Format("x:{0:0.######} y:{1:0.######} z:{2:0.######}", m_HitTransform.position.x, m_HitTransform.position.y, m_HitTransform.position.z));
return(true);
}
}
return(false);
}
// Update is called once per frame
void Update()
{
if (Input.GetMouseButtonDown(0))
{
var screenPosition = Camera.main.ScreenToViewportPoint(Input.mousePosition);
ARPoint point = new ARPoint {
x = screenPosition.x,
y = screenPosition.y
};
List <ARHitTestResult> hitResults = UnityARSessionNativeInterface.GetARSessionNativeInterface().HitTest(point,
ARHitTestResultType.ARHitTestResultTypeExistingPlaneUsingExtent);
if (hitResults.Count > 0)
{
foreach (var hitResult in hitResults)
{
Vector3 position = UnityARMatrixOps.GetPosition(hitResult.worldTransform);
CreateBall(new Vector3(position.x, position.y + createHeight, position.z));
break;
}
}
}
}
bool HitTestWithResultType(ARPoint point, ARHitTestResultType resultTypes)
{
List <ARHitTestResult> hitResults = UnityARSessionNativeInterface.GetARSessionNativeInterface().HitTest(point, resultTypes);
if (hitResults.Count > 0)
{
Debug.Log("Got a hit");
foreach (var hitResult in hitResults)
{
// m_HitTransform.position = UnityARMatrixOps.GetPosition (hitResult.worldTransform);
// m_HitTransform.rotation = UnityARMatrixOps.GetRotation (hitResult.worldTransform);
Vector3 position = UnityARMatrixOps.GetPosition(hitResult.worldTransform);
GameObject target = DisplayAnchorPoint(position, 0);
// anchor selected on server! LOCK IN
anchorChosen = true;
anchorSelect = true;
anchor = target;
return(true);
}
}
return(false);
}
void ProcessInput()
{
if (Input.touchCount > 0 && buttonPressed == false)
{
var touch = Input.GetTouch(0);
if (touch.tapCount == 2)
{
currentAnimation = AnimState.Dance;
return;
}
if (touch.phase == TouchPhase.Began)
{
var screenPosition = Camera.main.ScreenToViewportPoint(touch.position);
ARPoint point = new ARPoint
{
x = screenPosition.x,
y = screenPosition.y
};
List <ARHitTestResult> hitResults =
UnityARSessionNativeInterface.GetARSessionNativeInterface().HitTest(
point, ARHitTestResultType.ARHitTestResultTypeEstimatedHorizontalPlane);
if (hitResults.Count > 0)
{
foreach (var hitResult in hitResults)
{
Vector3 position = UnityARMatrixOps.GetPosition(hitResult.worldTransform);
PetGo(position);
break;
}
}
}
}
}
public void UpdateEnvironmentProbe(AREnvironmentProbeAnchor environmentProbeAnchor)
{
transform.position = UnityARMatrixOps.GetPosition(environmentProbeAnchor.transform);
Quaternion rot = UnityARMatrixOps.GetRotation(environmentProbeAnchor.transform);
//rot.z = -rot.z;
//rot.w = -rot.w;
transform.rotation = rot;
if (reflectionProbe != null)
{
reflectionProbe.size = environmentProbeAnchor.Extent;
}
if (debugExtentGO != null)
{
debugExtentGO.transform.localScale = environmentProbeAnchor.Extent;
}
latchedTexture = environmentProbeAnchor.Cubemap;
latchUpdate = true;
}
//testing
//finding the place to place
bool HitTestWithResultType(ARPoint point, ARHitTestResultType resultTypes)
{
List <ARHitTestResult> hitResults = UnityARSessionNativeInterface.GetARSessionNativeInterface().HitTest(point, resultTypes);
if (hitResults.Count > 0)
{
foreach (var hitResult in hitResults)
{
for (int i = 0; i < arpags.Count; i++)
{
if (hitResult.anchorIdentifier == arpags[i].planeAnchor.identifier)
{
selectedPlaneValue = i;
// planePlacementState = planeState.Set;
// print(planePlacementState);
PlaceFloorPlane(UnityARMatrixOps.GetPosition(hitResult.worldTransform));
return(true);
}
}
}
}
return(false);
}
private void AddImageAnchor(ARImageAnchor arImageAnchor)
{
Debug.LogFormat("image anchor added[{0}] : tracked => {1}", arImageAnchor.Identifier, arImageAnchor.IsTracked);
if (arImageAnchor.ReferenceImageName == "dynamicImage")
{
Vector3 position = UnityARMatrixOps.GetPosition(arImageAnchor.Transform);
Quaternion rotation = UnityARMatrixOps.GetRotation(arImageAnchor.Transform);
var arObjectState = ArBehaviour.ArObjectState;
if (arObjectState != null && TriggerObject != null && !_gameObjectCreated)
{
_gameObjectCreated = true;
lock (arObjectState)
{
transform.position = position;
transform.rotation = rotation;
var result = ArBehaviour.CreateArObject(
arObjectState,
TriggerObject.gameObject,
null,
transform,
TriggerObject.poi,
TriggerObject.poi.id,
out _gameObject
);
if (!ArBehaviourPosition.IsEmpty(result))
{
ArBehaviour.ErrorMessage = result;
return;
}
}
}
}
}
void UpdateImageAnchor(ARImageAnchor arImageAnchor)
{
Debug.Log("image anchor updated");
if (arImageAnchor.referenceImageName == referenceImage.imageName)
{
imageAnchorGO.transform.position = UnityARMatrixOps.GetPosition(arImageAnchor.transform);
imageAnchorGO.transform.rotation = UnityARMatrixOps.GetRotation(arImageAnchor.transform);
searchcount++;
if (!issetparent && searchcount > searchlimit)
{
issetparent = true;
offset = worldroot.position - imageAnchorGO.transform.position;
eulerangleYoffset = worldroot.eulerAngles.y - imageAnchorGO.transform.eulerAngles.y;
lockedDoneTitle.gameObject.SetActive(true);
Debug.Log("记录初始偏移 == " + offset.ToString() + " " + eulerangleYoffset.ToString());
}
else if (issetparent)
{
Debug.Log("位置恢复！！！！！！");
worldroot.position = imageAnchorGO.transform.position + offset;
worldroot.eulerAngles = new Vector3(0, imageAnchorGO.transform.eulerAngles.y + eulerangleYoffset, 0);
}
}
}
void Update()
{
if (m_camera != null)
{
Matrix4x4 matrix = m_session.GetCameraPose();
Vector3 arPos = UnityARMatrixOps.GetPosition(matrix);
Vector3 diff = arPos - lastArPos;
Vector3 correctedDiff = new Vector3(
sin * diff.z + cos * diff.x,
diff.y,
cos * diff.z - sin * diff.x);
m_camera.transform.localPosition += correctedDiff;
lastArPos = arPos;
Quaternion r = UnityARMatrixOps.GetRotation(matrix);
m_camera.transform.localRotation = Quaternion.Euler(
r.eulerAngles.x,
r.eulerAngles.y + initRotation.eulerAngles.y,
r.eulerAngles.z);
m_camera.projectionMatrix = m_session.GetCameraProjection();
}
}
bool HitTestWithResultType(ARPoint point, ARHitTestResultType resultTypes)
{
if (EventSystem.current.IsPointerOverGameObject(Input.GetTouch(0).fingerId))
{
return(false);
} // don't register touches on the UI
List <ARHitTestResult> hitResults = UnityARSessionNativeInterface.GetARSessionNativeInterface().HitTest(point, resultTypes);
if (hitResults.Count > 0)
{
foreach (var hitResult in hitResults) // Why not just get [0] instead of looping?
{
m_HitTransform.position = UnityARMatrixOps.GetPosition(hitResult.worldTransform) + Vector3.up * 0.02f; // move above grid slightly
m_HitTransform.rotation = UnityARMatrixOps.GetRotation(hitResult.worldTransform);
if (!planePainting)
{
PaintPlaneOn();
}
return(true);
}
}
return(false); // no hit results
}
private bool HitTestWithResultType(ARPoint point, ARHitTestResultType resultType)
{
List <ARHitTestResult> hitResults =
UnityARSessionNativeInterface.GetARSessionNativeInterface().HitTest(point, resultType);
if (hitResults.Count > 0)
{
foreach (ARHitTestResult hitResult in hitResults)
{
Debug.Log("Got hit!");
Vector3 position = UnityARMatrixOps.GetPosition(hitResult.worldTransform);
Quaternion rotation = UnityARMatrixOps.GetRotation(hitResult.worldTransform);
// Transform to placenote frame of reference
Matrix4x4 worldTransform = Matrix4x4.TRS(position, rotation, Vector3.one);
Matrix4x4?placenoteTransform = LibPlacenote.Instance.ProcessPose(worldTransform);
Vector3 hitPosition = PNUtility.MatrixOps.GetPosition(placenoteTransform.Value);
Quaternion hitRotation = PNUtility.MatrixOps.GetRotation(placenoteTransform.Value);
// Create node info object
NodeInfo nodeInfo = new NodeInfo();
nodeInfo.px = hitPosition.x;
nodeInfo.py = hitPosition.y;
nodeInfo.pz = hitPosition.z;
nodeInfo.nodeType = (int)m_NodeController._selectedNodeType;
m_NodeController.AddActiveNode(nodeInfo);
return(true);
}
}
return(false);
}
void UpdateImageAnchor(ARImageAnchor arImageAnchor)
{
Debug.LogFormat("image anchor updated[{0}] : tracked => {1}", arImageAnchor.identifier, arImageAnchor.isTracked);
if (bindObjectToImage && arImageAnchor.referenceImageName == referenceImage.imageName)
{
if (arImageAnchor.isTracked)
{
if (!imageAnchorGO.activeSelf)
{
imageAnchorGO.SetActive(true);
}
if (bindObjectToImage)
{
imageAnchorGO.transform.position = UnityARMatrixOps.GetPosition(arImageAnchor.transform);
imageAnchorGO.transform.rotation = UnityARMatrixOps.GetRotation(arImageAnchor.transform);
}
}
else if (destroyObjectOnEnd && imageAnchorGO)
{
GameObject.Destroy(imageAnchorGO);
}
}
}
bool HitTestWithResultType(ARPoint point, ARHitTestResultType resultTypes) // UI button
{
List <ARHitTestResult> hitResults = UnityARSessionNativeInterface.GetARSessionNativeInterface().HitTest(point, resultTypes);
if (hitResults.Count > 0)
{
foreach (var hitResult in hitResults)
{ // Manually adding 1 unit on Y axis because of the pivot point and center of the 3D model
Vector3 position = UnityARMatrixOps.GetPosition(hitResult.worldTransform) + new Vector3(0, 1f, 0);
Quaternion rotation = UnityARMatrixOps.GetRotation(hitResult.worldTransform);
OpenDoorInFront(position, rotation); // Passing the data to spwan the portal on detected dimentions from hit test
Instantiate(particleLauncher, position + new Vector3(0, 1f, 0), rotation); // particle animation
instructionText.text = "Enjoy your journey!!";
Vector3 currentAngle = transform.eulerAngles;
transform.LookAt(Camera.main.transform);
transform.eulerAngles = new Vector3(currentAngle.x, transform.eulerAngles.y, currentAngle.z); // Angle correction for the door that is placed
return(true);
}
}
return(false);
}
void FaceUpdated(ARFaceAnchor anchorData)
{
if (_positionBuffer == null)
{
return;
}
var mapWidth = _positionMap.width;
var mapHeight = _positionMap.height;
var vCount = anchorData.faceGeometry.vertices.Length;
_positionBuffer.SetData(anchorData.faceGeometry.vertices);
gameObject.transform.localPosition = UnityARMatrixOps.GetPosition(anchorData.transform);
gameObject.transform.localRotation = UnityARMatrixOps.GetRotation(anchorData.transform);
_vertexBaker.SetInt(_vertexCountID, vCount);
_vertexBaker.SetMatrix(_transformID, gameObject.transform.localToWorldMatrix);
_vertexBaker.SetBuffer(0, _positionBufferID, _positionBuffer);
_vertexBaker.SetTexture(0, _positionMapID, _tmpPositionMap);
_vertexBaker.Dispatch(0, mapWidth / 8, mapHeight / 8, 1);
Graphics.CopyTexture(_tmpPositionMap, _positionMap);
}
// Update is called once per frame
void Update()
{
Matrix4x4 matrix = m_session.GetCameraPose();
if (m_arMode)
{
transform.localPosition = UnityARMatrixOps.GetPosition(matrix) * 1f;
}
else
{
transform.localPosition = UnityARMatrixOps.GetPosition(matrix) * 200f; //m_movementScale;
}
transform.localRotation = UnityARMatrixOps.GetRotation(matrix);
//Camera.main.projectionMatrix = m_session.GetCameraProjection();
if (m_arMode)
{
//for AR mode
Camera.main.projectionMatrix = m_session.GetCameraProjection();
foreach (Camera cam in Camera.main.transform.GetComponentsInChildren <Camera>())
{
cam.projectionMatrix = Camera.main.projectionMatrix;
}
}
}
bool HitTestWithResultType(ARPoint point, ARHitTestResultType resultTypes)
{
List <ARHitTestResult> hitResults = UnityARSessionNativeInterface.GetARSessionNativeInterface().HitTest(point, resultTypes);
if (hitResults.Count > 0)
{
foreach (var hitResult in hitResults)
{
Logger.Info("Got hit!");
OnClickPlane(UnityARMatrixOps.GetPosition(hitResult.worldTransform), UnityARMatrixOps.GetRotation(hitResult.worldTransform));
//Logger.Info(string.Format("x:{0:0.######} y:{1:0.######} z:{2:0.######}", m_HitTransform.position.x, m_HitTransform.position.y, m_HitTransform.position.z));
return(true);
}
}
return(false);
}
void FaceAdded(ARFaceAnchor anchorData)
{
currentBlendShapes = anchorData.blendShapes;
model.transform.localPosition = UnityARMatrixOps.GetPosition(anchorData.transform);
model.transform.localPosition = new Vector3(model.transform.localPosition.x, model.transform.localPosition.y + offsetY, model.transform.localPosition.z);
}
void FaceAdded(ARFaceAnchor anchorData)
{
anchorPrefab.transform.position = UnityARMatrixOps.GetPosition(anchorData.transform);
anchorPrefab.transform.rotation = UnityARMatrixOps.GetRotation(anchorData.transform);
anchorPrefab.SetActive(true);
}
protected override void Update()
{
if (IsNewLayer)
{
_sessionStarted = false;
}
base.Update();
var layerItemList = LayerItemList;
if (MenuEnabled.HasValue && MenuEnabled.Value && layerItemList != null && layerItemList.Any())
{
var fitToScanOverlay = FitToScanOverlay;
if (fitToScanOverlay != null && fitToScanOverlay.activeSelf)
{
long nowTicks = DateTime.Now.Ticks;
var second = nowTicks / 10000000L;
if (!_fitToScanOverlayActivationSecond.HasValue)
{
_fitToScanOverlayActivationSecond = second;
//Debug.LogFormat("FTS value {0}", _fitToScanOverlayActivationSecond.Value);
}
else
{
var value = _fitToScanOverlayActivationSecond.Value;
if (value + 30 < second)
{
//Debug.LogFormat("FTS value {0}, second {1}", _fitToScanOverlayActivationSecond.Value, second);
var triggerObjects = TriggerObjects;
if (triggerObjects != null)
{
foreach (var t in triggerObjects.Values)
{
t.isActive = false;
}
}
_fitToScanOverlayActivationSecond = null;
MenuButtonClick = new MenuButtonClickActivity {
ArBehaviour = this
};
}
else
{
SetInfoText($"Timeout in {value + 30 - second} seconds.");
}
}
}
else
{
_fitToScanOverlayActivationSecond = null;
}
}
#if IS_SLAM_APP
#else
if (!_sessionStarted)
{
if (!HasTriggerImages)
{
StartArSession();
return;
}
var anchorManager = AnchorManager.GetComponent <ArKitAnchorManager>();
anchorManager.ArBehaviour = this;
anchorManager.TriggerObjects = TriggerObjects;
anchorManager.FitToScanOverlay = FitToScanOverlay;
StartArSession(anchorManager.TriggerObjects);
}
#endif
if (m_camera != null && _sessionStarted)
{
// JUST WORKS!
Matrix4x4 matrix = m_session.GetCameraPose();
m_camera.transform.localPosition = UnityARMatrixOps.GetPosition(matrix);
m_camera.transform.localRotation = UnityARMatrixOps.GetRotation(matrix);
m_camera.projectionMatrix = m_session.GetCameraProjection();
}
}
void Update()
{
if (m_camera != null && sessionStarted)
{
// Positional information of AR camera
Matrix4x4 matrix = m_session.GetCameraPose();
Vector3 newPos = UnityARMatrixOps.GetPosition(matrix);
passedTime += Time.deltaTime;
// Get accelerometer difference (experimental)
double acc = Input.acceleration.z - lastAcc.z; //Changed from Float to double on 6 Apr to try and get Acc data to show
if (acc > 0)
{
dir = Direction.backward;
}
else if (acc < 0)
{
dir = Direction.forward;
}
// Do speed calculation and update UI
if (frames % speedFrames == 0)
{
double dist = Vector3.Distance(newPos, lastPos); //Changed from Float to double on 6 Apr to try and get Acc data to show | Added 6 Apr
speed = dist / passedTime;
speedText.text = "Speed " + speed.ToString();
if (speed > 1)
{
warningText.text = "Slow down!";
if (dir == Direction.forward)
{
directionText.text = "Forwards";
}
else
{
directionText.text = "Backwards";
}
}
else
{
warningText.text = "";
directionText.text = "";
}
// Reset counters and update last recorded info
frames = 0;
passedTime = 0;
lastPos = m_camera.transform.localPosition;
lastAcc = Input.acceleration;
// Debug text
posText.text = "Pos: " + m_camera.transform.localPosition;
accText.text = "Acc: " + (string.Format("{0:0.000000000000}", (Input.acceleration - lastAcc))); //Ensure it's formatting value to 12 places after the decimal point so that it's clear whether there's any value in there.
debugAccText.text = "Acc Debug: " + (Input.acceleration); //Display Current Acceleration to debug the Acceleration bug: Added 6 Apr
debugAccTypeText.text = "Acc Type: " + (Input.acceleration.GetType()); //Added 6 Apr: Should Display type of the Input.accleration val to determine if it's an int
}
frames++;
// Move game camera to new position/rotation sensed
m_camera.transform.localPosition = UnityARMatrixOps.GetPosition(matrix);
m_camera.transform.localRotation = UnityARMatrixOps.GetRotation(matrix);
m_camera.projectionMatrix = m_session.GetCameraProjection();
}
}
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);
}
}
/// <summary>
/// Converts a <see cref="UnityARMatrix4x4"/> to a <see cref="Matrix4x4"/>.
/// </summary>
/// <param name="input">The input matrix.</param>
/// <returns><see cref="Matrix4x4"/>.</returns>
public static Matrix4x4 ToMatrix4x4(this UnityARMatrix4x4 input)
{
return(UnityARMatrixOps.GetMatrix(input));
}
