public IEnumerator PivotTransform_MoveWithPivot()
{
// Object A is a child of B
// Object A is re-parented to C, with the same world position.
// Process using ChangeRelativePosition should have equal effect as Transform.SetParent(newParent, worldPositionStats: true);
Vector3 objectA_Positon = new Vector3(2324.32f, 928.23f, 284.134f);
Vector3 objectB_Positon = new Vector3(243.2f, 332f, 5f);
Vector3 objectC_Positon = new Vector3(-420.9f, -6f, 82f);
// Setup test objects
GameObject objectA_gameObject = new GameObject("objectA");
objectA_gameObject.transform.position = objectA_Positon;
yield return(new WaitForSeconds(0.1f));
PivotTransform.MoveWithPivot(objectA_gameObject.transform, objectB_Positon, objectC_Positon);
yield return(new WaitForSeconds(0.1f));
Vector3 diff_objA = objectA_gameObject.transform.position - objectA_Positon;
float diff_objA_magnitude = diff_objA.magnitude;
Debug.Log($"ObjectA Difference: {diff_objA} magnitude: {diff_objA_magnitude}");
Vector3 diff_OrigMovement = objectB_Positon - objectC_Positon;
float diff_OrigMovement_magnitude = diff_OrigMovement.magnitude;
Debug.Log($"B, C Difference: {diff_OrigMovement} magnitude: {diff_OrigMovement_magnitude}");
Assert.True(Mathf.Abs(diff_objA_magnitude - diff_OrigMovement_magnitude) < float.Epsilon);
}
public static TransformData AlignObject(IMarker marker, TransformData origin, Pose destination)
{
// Get a world pose from the marker relative to the spawned model.
Pose currentPose = GetWorldPose(origin, marker.RelativePosition, Quaternion.Euler(marker.RelativeRotationEuler));
// Rotate around the anchor point, to match the pose.
var postRot = PivotTransform.RotateAroundPivot(origin, currentPose, destination.rotation);
// Update world pose
currentPose = GetWorldPose(postRot, marker.RelativePosition, Quaternion.Euler(marker.RelativeRotationEuler));
// Translate around a pivot
return(PivotTransform.MoveWithPivot(postRot, currentPose.position, destination.position));
}
void Update()
{
m_AnchorSelection.Update();
if (m_CurrentCursor)
{
// Update exposed value
m_Value.position = m_CurrentCursor.transform.position;
m_Value.rotation = m_CurrentCursor.transform.rotation;
if (m_Dragging && !PivotTransform.Similar(Vector3.zero, m_Value.position))
{
OnValueUpdate?.Invoke(m_Value);
m_Dragging = false;
}
}
}
private void InvokeOnDispatchMarkers(Payload <IViewerAction> viewerAction)
{
HasChanged = false;
lock (m_SyncRoot)
{
if (viewerAction.ActionType.RequiresContext(MarkerEditContext.current, viewerAction.Data))
{
viewerAction.ActionType.ApplyPayload(viewerAction.Data, ref m_MarkerEdit, () =>
{
bool sendUpdate = false;
var editedMarker = m_MarkerEdit.ToMarker();
// Check if any of the fields are different from controller.
if (!PivotTransform.Similar(m_CachedMarker.RelativePosition, editedMarker.RelativePosition) ||
!PivotTransform.Similar(m_CachedMarker.RelativeRotationEuler, editedMarker.RelativeRotationEuler) ||
!PivotTransform.Similar(m_CachedMarker.ObjectScale, editedMarker.ObjectScale) ||
m_CachedMarker.Name != editedMarker.Name)
{
sendUpdate = true;
}
// Update drag handle position
if (sendUpdate)
{
m_MarkerController.Visualize(editedMarker);
m_UpdateDragHandle.Run(
() => m_DraggableMarkerPlacement.UpdatePose(editedMarker.GetWorldPose(m_MarkerController.AlignedObject.Get())),
0.1f);
m_CachedMarker = editedMarker;
m_MarkerEditContextTarget.UpdateWith(ref m_MarkerEdit);
}
HasChanged = true;
});
}
if (viewerAction.ActionType.RequiresContext(MarkerListContext.current, viewerAction.Data))
{
viewerAction.ActionType.ApplyPayload(viewerAction.Data, ref m_MarkerList, () =>
{
m_MarkerListContextTarget.UpdateWith(ref m_MarkerList);
HasChanged = true;
});
}
}
}
private void Nudge(Vector3 amount)
{
if (rotationMode)
{
var origin = new TransformData(model);
Pose pivot = Marker.GetWorldPose(origin, marker.RelativePosition, Quaternion.Euler(marker.RelativeRotationEuler));
var result = PivotTransform.RotateAroundPivot(
origin,
pivot,
pivot.rotation * Quaternion.Euler(amount)
);
model.position = result.position;
model.rotation = result.rotation;
model.localScale = result.scale;
}
else
{
model.position += amount;
}
}
void OnDragMarkerUpdate(Pose newMarkerPose)
{
if (m_MarkerController.AlignedObject == null)
{
return;
}
var local = Marker.InverseTransformPose(m_MarkerController.AlignedObject.Transform, newMarkerPose);
var rotation = local.rotation.eulerAngles;
var effectiveRotation = new Vector3(rotation.x, m_MarkerEdit.YAxis, rotation.z);
// Only update the Y rotation if the marker is on a wall
// We can determine if on a wall if the X is near zero
int xmod = Mathf.RoundToInt((rotation.x * 4) / 360) % 4;
if (xmod == 0)
{
effectiveRotation.y = rotation.y;
}
// Discard if similar to existing data.
if (PivotTransform.Similar(local.position, new Vector3(m_MarkerEdit.X, m_MarkerEdit.Y, m_MarkerEdit.Z)) &&
PivotTransform.Similar(effectiveRotation, new Vector3(m_MarkerEdit.XAxis, m_MarkerEdit.YAxis, m_MarkerEdit.ZAxis)))
{
return;
}
m_MarkerEdit.X = local.position.x;
m_MarkerEdit.Y = local.position.y;
m_MarkerEdit.Z = local.position.z;
m_MarkerEdit.XAxis = effectiveRotation.x;
m_MarkerEdit.YAxis = effectiveRotation.y;
m_MarkerEdit.ZAxis = effectiveRotation.z;
m_MarkerEditContextTarget.UpdateWith(ref m_MarkerEdit);
m_MarkerController.Visualize(m_MarkerEdit.ToMarker());
m_PlaceNewMarker = false;
}
public void Update()
{
piv_struct = piv_struct.SFB_Setup(AlwaysChangePivot);
}
