public void ChangeTrackedTargetTypeHandJoint()
{
solverHandler = gameObject.GetComponent <SolverHandler>();
if (solverHandler != null)
{
solverHandler.TrackedTargetType = TrackedObjectType.HandJoint;
}
}
protected virtual void OnEnable()
{
if (solverHandler == null)
{
solverHandler = GetComponent <SolverHandler>();
}
applicationSignatureText.text = MixedRealityToolkit.DiagnosticsSystem.ApplicationSignature;
}
public override void OnInspectorGUI()
{
serializedObject.Update();
if (target != null)
{
InspectorUIUtility.RenderHelpURL(target.GetType());
}
bool trackedObjectChanged = false;
EditorGUI.BeginChangeCheck();
InspectorUIUtility.DrawEnumSerializedProperty(trackedTargetProperty, TrackedTypeLabel, solverHandler.TrackedTargetType);
if (!SolverHandler.IsValidTrackedObjectType(solverHandler.TrackedTargetType))
{
InspectorUIUtility.DrawWarning(" Current Tracked Target Type value of \""
+ Enum.GetName(typeof(TrackedObjectType), solverHandler.TrackedTargetType)
+ "\" is obsolete. Select MotionController or HandJoint values instead");
}
if (trackedTargetProperty.enumValueIndex == (int)TrackedObjectType.HandJoint ||
trackedTargetProperty.enumValueIndex == (int)TrackedObjectType.MotionController)
{
EditorGUILayout.PropertyField(trackedHandnessProperty);
if (trackedHandnessProperty.enumValueIndex > (int)Handedness.Both)
{
InspectorUIUtility.DrawWarning("Only Handedness values of None, Left, Right, and Both are valid");
}
}
if (trackedTargetProperty.enumValueIndex == (int)TrackedObjectType.HandJoint)
{
EditorGUILayout.PropertyField(trackedHandJointProperty);
}
else if (trackedTargetProperty.enumValueIndex == (int)TrackedObjectType.CustomOverride)
{
EditorGUILayout.PropertyField(transformOverrideProperty);
}
EditorGUILayout.PropertyField(additionalOffsetProperty);
EditorGUILayout.PropertyField(additionalRotationProperty);
trackedObjectChanged = EditorGUI.EndChangeCheck();
EditorGUILayout.PropertyField(updateSolversProperty);
serializedObject.ApplyModifiedProperties();
if (EditorApplication.isPlaying && trackedObjectChanged)
{
solverHandler.RefreshTrackedObject();
}
}
public IEnumerator TestTapToPlaceColliderTests()
{
TestUtilities.PlayspaceToOriginLookingForward();
// Create a scene with 2 cubes
GameObject colliderObj1 = GameObject.CreatePrimitive(PrimitiveType.Cube);
colliderObj1.transform.localScale = new Vector3(0.3f, 0.3f, 0.05f);
colliderObj1.transform.position = new Vector3(0.3f, 0, 1.5f);
GameObject colliderObj2 = GameObject.CreatePrimitive(PrimitiveType.Cube);
colliderObj2.transform.localScale = new Vector3(0.3f, 0.3f, 0.05f);
colliderObj2.transform.position = new Vector3(-0.3f, 0, 1.5f);
// Create a cube with Tap to Place attached
var tapToPlaceObj = InstantiateTestSolver <TapToPlace>();
tapToPlaceObj.target.transform.position = Vector3.forward * 2;
TapToPlace tapToPlace = tapToPlaceObj.solver as TapToPlace;
// Switching the TrackedTargetType to Controller Ray
SolverHandler tapToPlaceSolverHandler = tapToPlaceObj.handler;
tapToPlaceSolverHandler.TrackedTargetType = TrackedObjectType.ControllerRay;
Vector3 handStartPosition = new Vector3(0, -0.15f, 0.5f);
var leftHand = new TestHand(Handedness.Left);
yield return(leftHand.Show(handStartPosition));
// Start the placement via code instead of click from the hand
tapToPlace.StartPlacement();
yield return(null);
Assert.True(tapToPlace.IsBeingPlaced);
// Move hand, object should follow
yield return(leftHand.Move(new Vector3(-0.15f, 0, 0), 30));
Assert.True(tapToPlaceObj.target.transform.position.z < colliderObj1.transform.position.z);
yield return(leftHand.Move(new Vector3(0.15f, 0, 0), 30));
Assert.True(tapToPlaceObj.target.transform.position.z > colliderObj1.transform.position.z);
yield return(leftHand.Move(new Vector3(0.15f, 0, 0), 30));
Assert.True(tapToPlaceObj.target.transform.position.z < colliderObj1.transform.position.z);
// Stop the placement via code instead of click from the hand
tapToPlace.StopPlacement();
Assert.False(tapToPlace.IsBeingPlaced);
}
private async Task <IEquation> Generate(Homogeneous hg)
{
var ran = new Random();
var generator = new RandomFunctionGenerator(new HomogeneousTreeStrategy());
var equationHandler = new SolverHandler();
hg.Equation = "(" + generator.Generate("y/x", (1 + 2 * ran.Next(1, 2))) + ")" + "/" + "(" + generator.Generate("y/x", (1 + 2 * ran.Next(1, 2))) + ")" + "=" + "dydx";
hg = (Homogeneous)await equationHandler.SolveAndScramble(hg);
return(hg);
}
public IEnumerator TestTapToPlaceOnClickControllerRay()
{
TestUtilities.PlayspaceToOriginLookingForward();
// Create a cube with Tap to Place attached
var tapToPlaceObj = InstantiateTestSolver <TapToPlace>();
tapToPlaceObj.target.transform.position = Vector3.forward;
TapToPlace tapToPlace = tapToPlaceObj.solver as TapToPlace;
// Switch the TrackedTargetType to Controller Ray
SolverHandler tapToPlaceSolverHandler = tapToPlaceObj.handler;
tapToPlaceSolverHandler.TrackedTargetType = TrackedObjectType.ControllerRay;
// Set hand position
Vector3 handStartPosition = new Vector3(0, -0.1f, 0.6f);
var leftHand = new TestHand(Handedness.Left);
yield return(leftHand.Show(handStartPosition));
Vector3 initialObjPosition = tapToPlaceObj.target.transform.position;
yield return(leftHand.Click());
// Make sure the object is being placed after selection
Assert.True(tapToPlace.IsBeingPlaced);
// Move hand, object should follow
yield return(leftHand.Move(Vector3.forward));
yield return(leftHand.Move(Vector3.up));
// Make sure the object starting position is different from the current position
Assert.True(initialObjPosition != tapToPlaceObj.target.transform.position);
// Tap to place has a 0.5 sec timer between clicks to make sure a double click does not get registered
// We need to wait at least 0.5 secs until another click is called or tap to place will ignore the action
yield return(new WaitForSeconds(0.5f));
// Click to stop the placement
yield return(leftHand.Click());
// Make sure the object is not being placed
Assert.False(tapToPlace.IsBeingPlaced);
// Get new position of the object after it is placed
Vector3 newPosition = tapToPlaceObj.target.transform.position;
// Move hand, the object should NOT move
yield return(leftHand.Move(Vector3.back, 30));
Assert.True(newPosition == tapToPlaceObj.target.transform.position);
}
private async Task <IEquation> Generate(SeparableVariables sv)
{
var ran = new Random();
var generator = new RandomFunctionGenerator(new SeparableTreeStrategy());
var equationHandler = new SolverHandler();
sv.Equation = "(" + generator.Generate("x", ran.Next(4, 10)) + ")" + "*" + "(" + generator.Generate("y", ran.Next(4, 10)) + ")" + "=" + "dydx";
sv = (SeparableVariables)await equationHandler.SolveAndScramble(sv);
return(sv);
}
protected override void OnEnable()
{
base.OnEnable();
trackedObjectProperty = serializedObject.FindProperty("trackedObjectToReference");
transformTargetProperty = serializedObject.FindProperty("transformTarget");
additionalOffsetProperty = serializedObject.FindProperty("additionalOffset");
additionalRotationProperty = serializedObject.FindProperty("additionalRotation");
updateSolversProperty = serializedObject.FindProperty("updateSolvers");
solverHandler = target as SolverHandler;
}
protected void OnEnable()
{
trackedTargetProperty = serializedObject.FindProperty("trackedTargetType");
trackedHandnessProperty = serializedObject.FindProperty("trackedHandness");
trackedHandJointProperty = serializedObject.FindProperty("trackedHandJoint");
transformOverrideProperty = serializedObject.FindProperty("transformOverride");
additionalOffsetProperty = serializedObject.FindProperty("additionalOffset");
additionalRotationProperty = serializedObject.FindProperty("additionalRotation");
updateSolversProperty = serializedObject.FindProperty("updateSolvers");
solverHandler = target as SolverHandler;
}
private void DestroySolver()
{
if (currentSolver != null)
{
DestroyImmediate(currentSolver);
currentSolver = null;
}
if (handler != null)
{
DestroyImmediate(handler);
handler = null;
}
}
public void Unhide(SharpyBaseScript light)
{
gameObject.SetActive(true);
CurrentLight = light;
if (light != null)
{
ChannelBase = light.startChannel;
SolverHandler solver = GetComponentInChildren <SolverHandler>();
solver.TransformTarget = light.transform;
}
UpdateAllSliders();
}
void Start()
{
mapAreaIndicator = GameObject.Find("MapArea");
if (mapAreaIndicator == null)
{
return;
}
if (scaleLabel == null)
{
return;
}
if (sizeLabel == null)
{
return;
}
if (tiltLabel == null)
{
return;
}
if (scaleTextMesh == null)
{
scaleTextMesh = scaleLabel.GetComponent <TextMeshPro>();
}
if (sizeTextMesh == null)
{
sizeTextMesh = sizeLabel.GetComponent <TextMeshPro>();
}
if (tiltTextMesh == null)
{
tiltTextMesh = tiltLabel.GetComponent <TextMeshPro>();
}
mapAreaIndicator.SetActive(false);
SolverHandler handler = mapParent.GetComponent <SolverHandler>();
HandConstraint handConstraint = mapParent.GetComponent <HandConstraint>();
BoundsControl boundingBox = mapBoundingBox.GetComponent <BoundsControl>();
ObjectManipulator manipulator = mapBoundingBox.GetComponent <ObjectManipulator>();
if (handler != null)
{
handler.enabled = false;
}
if (handConstraint != null)
{
handConstraint.enabled = false;
}
mapBoundingBox.SetActive(false);
}
public void DestroySolver()
{
// Surface magnetism not set up
if (!enabled)
{
return;
}
if (currentSolver != null)
{
DestroyImmediate(currentSolver);
currentSolver = null;
}
if (handler != null)
{
DestroyImmediate(handler);
handler = null;
}
chesspieces.SetActive(true);
enabled = false;
}
private SetupData InstantiateTestSolver <T>() where T : Solver
{
var cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
cube.transform.localScale = new Vector3(0.1f, 0.2f, 0.1f);
Solver solver = AddSolverComponent <T>(cube);
SolverHandler handler = cube.GetComponent <SolverHandler>();
Assert.IsNotNull(handler, "GetComponent<SolverHandler>() returned null");
var setupData = new SetupData()
{
handler = handler,
solver = solver,
target = cube
};
setupDataList.Add(setupData);
return(setupData);
}
protected override void Awake()
{
base.Awake();
_handler = GetComponent <SolverHandler>();
Debug.Assert(_handler != null);
if (_controllerTracker == null)
{
Debug.LogWarning("AttachToControllerSolver missing controller tracker, will create own instance");
_controllerTracker = gameObject.AddComponent <ControllerTransformTracker>();
}
switch (_handedness)
{
case Handedness.None:
case Handedness.Other:
break;
case Handedness.Left:
_controllerTracker.LeftTrackingUpdated += UpdateTrackedTransform;
_controllerTracker.LeftTrackingLost += LostTracking;
break;
case Handedness.Right:
_controllerTracker.RightTrackingUpdated += UpdateTrackedTransform;
_controllerTracker.RightTrackingLost += LostTracking;
break;
case Handedness.Both:
case Handedness.Any:
_controllerTracker.TrackingUpdated += UpdateTrackedTransform;
_controllerTracker.AllTrackingLost += LostTracking;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
// Use this for initialization
void Start()
{
solHan = GetComponent <SolverHandler>();
}
private void Start()
{
spawnedObject = Instantiate(spawnThisPrefab, hideThisObject.transform.position, hideThisObject.transform.rotation);
spawnedObject.SetActive(false);
solverHandler = spawnedObject.GetComponent <SolverHandler>();
}
public void CancelDingPolymerInfoDisplayer()
{
SolverHandler solverHandler = polymerInfoDisplayer.GetComponent <SolverHandler>();
solverHandler.UpdateSolvers = true;
}
private void AddSolver <T>() where T : Solver
{
currentSolver = gameObject.AddComponent <T>();
handler = GetComponent <SolverHandler>();
RefreshSolverHandler();
}
private void Awake()
{
boundingBoxRig = GetComponent <BoundingBoxRig>();
handDraggable = GetComponent <HandDraggable>();
solverHandler = GetComponent <SolverHandler>();
}
