private void CheckAlignment(IAlignmentManager alignMgr, Pose virtualPose, Pose lockedPose)
{
WorldLockingManager mgr = WorldLockingManager.GetInstance();
alignMgr.ComputePinnedPose(new Pose(lockedPose.position, Quaternion.identity));
Pose pinnedFromLocked = alignMgr.PinnedFromLocked;
Pose frozenFromLocked = mgr.FrozenFromPinned.Multiply(pinnedFromLocked);
Pose lockedFromFrozen = frozenFromLocked.Inverse();
Pose computedLocked = lockedFromFrozen.Multiply(virtualPose);
bool areEqualPositions = computedLocked.position == lockedPose.position;
Assert.IsTrue(areEqualPositions, $"clp={computedLocked.position.ToString("F3")}"
+ $" lpp={lockedPose.position.ToString("F3")}"
+ $" vpp={virtualPose.position.ToString("F3")}"
+ $" FfP={mgr.FrozenFromPinned.position.ToString("F3")}"
+ $" PfL={pinnedFromLocked.position.ToString("F3")}"
);
bool areEqualRotatons = computedLocked.rotation == lockedPose.rotation;
Assert.IsTrue(areEqualRotatons, $"clr={computedLocked.rotation.ToString("F3")}"
+ $"lpr={lockedPose.rotation.ToString("F3")}"
+ $" FfP={mgr.FrozenFromPinned.position.ToString("F3")}"
+ $" PfL={pinnedFromLocked.position.ToString("F3")}"
);
}
private Vector3 GetLockedHeadPosition()
{
WorldLockingManager wltMgr = WorldLockingManager.GetInstance();
Pose lockedHeadPose = wltMgr.LockedFromPlayspace.Multiply(wltMgr.PlayspaceFromSpongy.Multiply(wltMgr.SpongyFromCamera));
return(lockedHeadPose.position);
}
private void HandleTapped(TappedEventArgs eventArgs)
{
// The tap event happens in Spongy space, so any arguments
// from it are in spongy space and need to be converted to frozen space,
// because the ray tests are done in frozen space.
var spongyHeadPose = eventArgs.headPose;
var manager = WorldLockingManager.GetInstance();
var frozenHeadPose = manager.FrozenFromSpongy.Multiply(spongyHeadPose);
var rayStart = frozenHeadPose.position;
var rayDir = frozenHeadPose.forward;
int ignoreRaycastLayer = Physics.IgnoreRaycastLayer;
int hitLayers = ~(ignoreRaycastLayer);
RaycastHit hitInfo;
if (Physics.Raycast(rayStart, rayDir, out hitInfo, Mathf.Infinity, hitLayers))
{
int uiLayer = LayerMask.GetMask("UI");
if (hitInfo.collider == null || ((1 << hitInfo.collider.gameObject.layer) & uiLayer) == 0)
{
HandleHit(new RayHit(rayStart, hitInfo));
}
}
}
public void WorldLockingManagerTestSimplePasses()
{
// Use the Assert class to test conditions
var wlMgr = WorldLockingManager.GetInstance();
Assert.IsNotNull(wlMgr); /// wlMgr is not a Unity object, so this should work.
UnityEngine.Assertions.Assert.IsNotNull(wlMgr); /// This should work whether or not object overrides == null.
}
public void Clear()
{
for (int i = 0; i < spacePins.Count; ++i)
{
spacePins[i].Reset();
}
WorldLockingManager.GetInstance().AlignmentManager.ClearAlignmentAnchors();
WorldLockingManager.GetInstance().AlignmentManager.SendAlignmentAnchors();
}
private static Pose GetGlobalFromLocked()
{
var wltMgr = WorldLockingManager.GetInstance();
Pose globalFromLocked = wltMgr.ApplyAdjustment
? wltMgr.FrozenFromLocked
: wltMgr.SpongyFromLocked;
return(globalFromLocked);
}
public void SaveLoadTestTearDown()
{
var alignMgr = WorldLockingManager.GetInstance().AlignmentManager;
alignMgr.ClearAlignmentAnchors();
alignMgr.SendAlignmentAnchors();
loadHelper.TearDown();
}
// Start is called before the first frame update
void Start()
{
Debug.Assert(WorldLockingManager.GetInstance() != null, "Unexpected null WorldLockingManager");
// dummy use of variables to silence unused variable warning in non-WSA build.
if (frozenPoseIsSpongy)
{
frozenPose = Pose.identity;
}
}
/// <inheritdoc/>
public async Task <bool> Download()
{
if (!IsReady)
{
return(false);
}
bool allSuccessful = true;
List <SpacePinPegAndProps> readObjects = new List <SpacePinPegAndProps>();
List <CloudAnchorId> cloudAnchorList = new List <CloudAnchorId>();
Dictionary <CloudAnchorId, SpacePinASA> spacePinByCloudId = new Dictionary <CloudAnchorId, SpacePinASA>();
foreach (var spacePin in spacePins)
{
int bindingIdx = FindBindingBySpacePinId(spacePin.SpacePinId);
if (bindingIdx >= 0)
{
string cloudAnchorId = bindings[bindingIdx].cloudAnchorId;
cloudAnchorList.Add(cloudAnchorId);
spacePinByCloudId[cloudAnchorId] = spacePin;
}
}
if (cloudAnchorList.Count > 0)
{
var found = await publisher.Read(cloudAnchorList);
if (found != null)
{
foreach (var keyVal in found)
{
var cloudAnchorId = keyVal.Key;
var spacePin = spacePinByCloudId[cloudAnchorId];
var pegAndProps = keyVal.Value;
Debug.Assert(pegAndProps.localPeg != null);
readObjects.Add(new SpacePinPegAndProps()
{
spacePin = spacePin, pegAndProps = pegAndProps
});
}
}
else
{
SimpleConsole.AddLine(ConsoleHigh, $"publisher Read returned null looking for {cloudAnchorList.Count} ids");
}
}
var wltMgr = WorldLockingManager.GetInstance();
foreach (var readObj in readObjects)
{
Pose lockedPose = wltMgr.LockedFromFrozen.Multiply(readObj.pegAndProps.localPeg.GlobalPose);
SimpleConsole.AddLine(ConsoleLow, $"Dwn: {lockedPose.ToString("F3")}");
readObj.spacePin.SetLockedPose(lockedPose);
readObj.spacePin.SetLocalPeg(readObj.pegAndProps.localPeg);
}
return(allSuccessful);
}
// Update is called once per frame
// Alternatively, we could make this a coroutine, and call it at a user specified interval.
private void Update()
{
if (active)
{
Pose spongyFromAnchor = WorldAnchorObject.transform.GetGlobalPose();
Pose frozenFromSpongy = WorldLockingManager.GetInstance().FrozenFromSpongy;
Pose frozenFromAnchor = frozenFromSpongy.Multiply(spongyFromAnchor);
TargetObject.SetGlobalPose(frozenFromAnchor);
}
}
/// <summary>
/// Format the summary info.
/// </summary>
/// <param name="manager">Source manager</param>
/// <returns>Formatted string</returns>
private string CaptureInfoText(WorldLockingManager manager)
{
string infoText = ""
+ string.Format("Anchors : {0}\n", manager.AnchorManager.NumAnchors)
+ string.Format("Edges : {0}\n", manager.AnchorManager.NumEdges)
+ string.Format("Fragments : {0}\n", manager.FragmentManager.NumFragments)
+ string.Format("Current Fragment : {0}\n", manager.FragmentManager.CurrentFragmentId);
return(infoText);
}
private void CheckFrozenPose()
{
if (frozenPoseIsSpongy)
{
Pose spongyPose = worldAnchor.transform.GetGlobalPose();
Debug.Assert(WorldLockingManager.GetInstance().Enabled, "Should wait until WorldLockingManager is active to check the frozen pose.");
frozenPose = WorldLockingManager.GetInstance().FrozenFromSpongy.Multiply(spongyPose);
frozenPoseIsSpongy = false;
}
}
// Update is called once per frame
void Update()
{
if (statusText != null)
{
var wltMgr = WorldLockingManager.GetInstance();
var settings = wltMgr.Settings;
string status = settings.Enabled ? "on" : "off";
statusText.text = $"WLT {status}";
statusText.color = settings.Enabled ? Color.green : Color.red;
}
}
/// <summary>
/// Callback for when the user has finished positioning the target.
/// </summary>
protected virtual void OnFinishManipulation()
{
if (WorldLockingManager.GetInstance().ApplyAdjustment)
{
SetFrozenPose(ExtractModelPose());
}
else
{
SetSpongyPose(ExtractModelPose());
}
}
private Vector3 GetGlobalHeadPosition()
{
WorldLockingManager wltMgr = WorldLockingManager.GetInstance();
Vector3 position = wltMgr.SpongyFromCamera.position;
if (wltMgr.ApplyAdjustment)
{
position = wltMgr.FrozenFromSpongy.Multiply(position);
}
return(position);
}
public void OnToggleManager()
{
var wltMgr = WorldLockingManager.GetInstance();
var settings = wltMgr.Settings;
settings.Enabled = !settings.Enabled;
wltMgr.Settings = settings;
for (int i = 0; i < targets.Count; ++i)
{
targets[i].SetActive(!targets[i].activeSelf);
}
}
private void FindAndCheckPin(GameObject rig, string pinName)
{
SpacePin spacePin = FindPinByName(rig, pinName);
Pose virtualPose = spacePin.ModelingPoseGlobal;
Pose lockedPose = spacePin.LockedPose;
Pose frozenPose = WorldLockingManager.GetInstance().FrozenFromLocked.Multiply(lockedPose);
Vector3 offset = frozenPose.position - virtualPose.position;
float len = Mathf.Abs(offset.magnitude - 1.0f);
Assert.Less(len, 1.0e-4f);
}
/// <summary>
/// Format the summary info.
/// </summary>
/// <param name="manager">Source manager</param>
/// <returns>Formatted string</returns>
private string CaptureInfoText(WorldLockingManager manager)
{
string infoText = ""
+ string.Format("Anchors : {0}\n", manager.AnchorManager.NumAnchors)
+ string.Format("Edges : {0}\n", manager.AnchorManager.NumEdges)
+ string.Format("Fragments : {0}\n", manager.FragmentManager.NumFragments)
+ string.Format("Current Fragment : {0}\n", manager.FragmentManager.CurrentFragmentId)
+ string.Format("Anchor Subsystem : {0}\n", manager.AnchorSettings.anchorSubsystem)
+ string.Format("Can Save/Load : {0} ({1})\n", manager.AnchorManager.SupportsPersistence, manager.FrozenWorldFileName);
return(infoText);
}
private void Update()
{
_WorldPosition = TransformToLookAt.position;
_LocalPosition = TransformToLookAt.localPosition;
_WorldLockedPosition = WorldLockingManager.GetInstance().LockedFromFrozen.Multiply(TransformToLookAt.GetGlobalPose()).position;
_LocalLockedPosition = WorldLockingManager.GetInstance().LockedFromFrozen.Multiply(TransformToLookAt.GetLocalPose()).position;
//_WorldFrozenPosition = WorldLockingManager.GetInstance().FrozenFromSpongy.Multiply(_WorldPosition);
//_LocalFrozenPosition = WorldLockingManager.GetInstance().FrozenFromSpongy.Multiply(_LocalPosition);
SetTexts();
}
private void FindAlignmentManager()
{
AlignSubtree subTree = targetSubtree;
if (subTree != null)
{
FindAlignmentManagerFromSubtree(subTree);
}
else
{
SetAlignmentManager(WorldLockingManager.GetInstance().AlignmentManager);
}
}
public IEnumerator WorldLockingManagerTestContextSwitch()
{
GameObject rig = loadHelper.LoadBasicSceneRig();
Assert.IsTrue(WorldLockingManager.GetInstance().AutoLoad);
var context = loadHelper.LoadComponentOnGameObject <WorldLockingContext>("Prefabs/CoreTestContext_AllDisabled.prefab");
Assert.IsFalse(WorldLockingManager.GetInstance().AutoLoad);
GameObject.Destroy(context.gameObject);
GameObject.Destroy(rig);
yield return(null);
}
/// <summary>
/// Disable the effects of all pins, as if they had never been set.
/// </summary>
public void ClearAll()
{
for (int i = 0; i < spacePins.Count; ++i)
{
spacePins[i].Reset();
}
// Could optionally also reset all existing WorldAnchors for a true reset.
// If wanted, uncomment this line.
WorldLockingManager.GetInstance().Reset();
// Also go back to idle mode.
activePin = -1;
}
private void CheckAlignment(IAlignmentManager alignMgr, Vector3 virtualPos, Vector3 lockedPos)
{
WorldLockingManager mgr = WorldLockingManager.GetInstance();
alignMgr.ComputePinnedPose(new Pose(lockedPos, Quaternion.identity));
Pose pinnedFromLocked = alignMgr.PinnedFromLocked;
Pose frozenFromLocked = mgr.FrozenFromPinned.Multiply(pinnedFromLocked);
Pose lockedFromFrozen = frozenFromLocked.Inverse();
Vector3 computedLocked = lockedFromFrozen.Multiply(virtualPos);
bool areEqual = computedLocked == lockedPos;
Assert.IsTrue(areEqual, $"c={computedLocked.ToString("F3")} l={lockedPos.ToString("F3")}");
}
private void DestroyWorldAnchorHelper()
{
if (worldAnchor != null)
{
Destroy(worldAnchor.gameObject);
worldAnchor = null;
}
if (AttachmentPoint != null)
{
WorldLockingManager.GetInstance().AttachmentPointManager.ReleaseAttachmentPoint(AttachmentPoint);
AttachmentPoint = null;
}
}
/// <summary>
/// Attempt to set a space pin from the QR code.
/// </summary>
/// <param name="qrCode">The source QR code.</param>
/// <returns>True if a space pin was set from the current data.</returns>
/// <remarks>
/// Returning false does not necessarily mean an error occurred. For example, if the space pin
/// has already been set from the given QR code, and the location hasn't changed, no action
/// will be taken and the return value will be false. Or if the coordinate system is unable
/// to resolve the transform to global space, again the return will be false, indicating
/// trying again later.
/// </remarks>
public bool Update(QRCode qrCode)
{
coordinateSystem.SpatialNodeId = qrCode.SpatialGraphNodeId;
sizeMeters = qrCode.PhysicalSideLength;
Pose spongyPose;
if (!coordinateSystem.ComputePose(out spongyPose))
{
return(false);
}
Pose frozenPose = WorldLockingManager.GetInstance().FrozenFromSpongy.Multiply(spongyPose);
return(UpdatePose(frozenPose));
}
/// <summary>
/// Attempt to set a space pin from the QR code.
/// </summary>
/// <param name="qrCode">The source QR code.</param>
/// <returns>True if a space pin was set from the current data.</returns>
/// <remarks>
/// Returning false does not necessarily mean an error occurred. For example, if the space pin
/// has already been set from the given QR code, and the location hasn't changed, no action
/// will be taken and the return value will be false. Or if the coordinate system is unable
/// to resolve the transform to global space, again the return will be false, indicating
/// trying again later.
/// </remarks>
public bool Update(QRCode qrCode)
{
SimpleConsole.AddLine(trace, $"Update SpacePin {(coordinateSystem == null ? "null" : coordinateSystem.SpatialNodeId.ToString())}");
coordinateSystem.SpatialNodeId = qrCode.SpatialGraphNodeId;
sizeMeters = qrCode.PhysicalSideLength;
Pose spongyPose;
if (!coordinateSystem.ComputePose(out spongyPose))
{
return(false);
}
Pose frozenPose = WorldLockingManager.GetInstance().FrozenFromSpongy.Multiply(spongyPose);
return(UpdatePose(frozenPose));
}
public IEnumerator WorldLockingManagerTestSettingsFromScript()
{
GameObject rig = loadHelper.LoadBasicSceneRig();
var settings = WorldLockingManager.GetInstance().Settings;
bool wasAutoLoad = settings.AutoLoad;
settings.AutoLoad = !settings.AutoLoad;
WorldLockingManager.GetInstance().Settings = settings;
Assert.AreNotEqual(wasAutoLoad, WorldLockingManager.GetInstance().AutoLoad);
GameObject.Destroy(rig);
yield return(null);
}
private void FindAndCheckPin(GameObject rig, string pinName)
{
SpacePin spacePin = FindPinByName(rig, pinName);
Pose virtualPose = spacePin.ModelingPoseGlobal;
Pose lockedPose = spacePin.LockedPose;
Debug.Log($"FFL:{WorldLockingManager.GetInstance().FrozenFromLocked.position.ToString("F3")}"
+ $"/ {WorldLockingManager.GetInstance().FrozenFromLocked.rotation.ToString("F3")}");
Pose frozenPose = WorldLockingManager.GetInstance().FrozenFromLocked.Multiply(lockedPose);
Vector3 offset = frozenPose.position - virtualPose.position;
float len = Mathf.Abs(offset.magnitude - 1.0f);
Assert.Less(len, 1.0e-4f, $"pin={spacePin.name} fr={frozenPose.position.ToString("F3")} vi={virtualPose.position.ToString("F3")}");
}
// Update is called once per frame
void Update()
{
if (AlwaysLock || !WorldLockingManager.GetInstance().Enabled)
{
Pose spongyPose = worldAnchor.transform.GetGlobalPose();
frozenPose = WorldLockingManager.GetInstance().FrozenFromSpongy.Multiply(spongyPose);
transform.SetGlobalPose(frozenPose);
}
else
{
CheckFrozenPose();
// Set pose to frozen space pose
transform.SetGlobalPose(frozenPose);
}
}
/// <summary>
/// Disable the effects of all pins, as if they had never been set.
/// </summary>
public void ClearAll()
{
for (int i = 0; i < spacePins.Count; ++i)
{
spacePins[i].Reset();
}
// Reset on the pins has removed them from the AlignmentManager, but it won't
// take effect until SendAlignmentAnchors() is called.
WorldLockingManager.GetInstance().AlignmentManager.SendAlignmentAnchors();
// Could optionally also reset all existing WorldAnchors for a true reset.
// If wanted, uncomment this line.
WorldLockingManager.GetInstance().Reset();
// Also go back to idle mode.
activePin = -1;
}
