/// <summary>
/// Gets the state of the given button key mapping for the press type on the controller index.
/// </summary>
/// <param name="index">The index of the controller.</param>
/// <param name="keyMapping">The key mapping key to check.</param>
/// <param name="pressType">The type of button press to check.</param>
/// <returns>Returns true if the button state matches the given data.</returns>
protected virtual bool GetControllerButtonState(uint index, string keyMapping, ButtonPressTypes pressType)
{
KeyCode buttonCode = VRTK_SharedMethods.GetDictionaryValue(keyMappings, keyMapping, KeyCode.None);
if (pressType == ButtonPressTypes.Touch)
{
return(IsButtonPressed(index, ButtonPressTypes.Press, buttonCode));
}
else if (pressType == ButtonPressTypes.TouchDown)
{
return(IsButtonPressed(index, ButtonPressTypes.PressDown, buttonCode));
}
else if (pressType == ButtonPressTypes.TouchUp)
{
return(IsButtonPressed(index, ButtonPressTypes.PressUp, buttonCode));
}
else if (pressType == ButtonPressTypes.Press)
{
return(!IsButtonPressIgnored() && IsButtonPressed(index, ButtonPressTypes.Press, buttonCode));
}
else if (pressType == ButtonPressTypes.PressDown)
{
return(!IsButtonPressIgnored() && IsButtonPressed(index, ButtonPressTypes.PressDown, buttonCode));
}
else if (pressType == ButtonPressTypes.PressUp)
{
return(!IsButtonPressIgnored() && IsButtonPressed(index, ButtonPressTypes.PressUp, buttonCode));
}
return(false);
}
protected virtual void CancelSetOpacityCoroutine(GameObject model)
{
Coroutine currentOpacityRoutine = VRTK_SharedMethods.GetDictionaryValue(setOpacityCoroutines, model);
if (currentOpacityRoutine != null)
{
StopCoroutine(currentOpacityRoutine);
}
}
protected virtual void InternalCancelHapticPulse(VRTK_ControllerReference controllerReference)
{
Coroutine currentHapticLoopRoutine = VRTK_SharedMethods.GetDictionaryValue(hapticLoopCoroutines, controllerReference);
if (currentHapticLoopRoutine != null)
{
StopCoroutine(currentHapticLoopRoutine);
hapticLoopCoroutines.Remove(controllerReference);
}
}
public static VRTK_ControllerReference GetControllerReference(SDK_BaseController.ControllerHand controllerHand)
{
GameObject scriptAlias = GetValidObjectFromHand(controllerHand);
uint controllerIndex = VRTK_SDK_Bridge.GetControllerIndex(scriptAlias);
VRTK_ControllerReference foundReference = VRTK_SharedMethods.GetDictionaryValue(controllerReferences, controllerIndex);
if (foundReference != null)
{
return(foundReference);
}
return(new VRTK_ControllerReference(scriptAlias));
}
protected virtual void EngageButtonReleased(object sender, ControllerInteractionEventArgs e)
{
// If the button is released, clear all the lists.
for (int i = 0; i < trackedObjects.Count; i++)
{
Transform trackedObj = trackedObjects[i];
VRTK_SharedMethods.GetDictionaryValue(movementList, trackedObj, new List <float>()).Clear();
}
initialGaze = Vector3.zero;
movementEngaged = false;
engagedController = null;
}
public static VRTK_ControllerReference GetControllerReference(uint controllerIndex)
{
if (controllerIndex < uint.MaxValue)
{
VRTK_ControllerReference foundReference = VRTK_SharedMethods.GetDictionaryValue(controllerReferences, controllerIndex);
if (foundReference != null)
{
return(foundReference);
}
return(new VRTK_ControllerReference(controllerIndex));
}
return(null);
}
protected virtual Transform GetElementTransform(string path)
{
if (path == null)
{
return(null);
}
if (actualModelContainer == null && VRTK_SharedMethods.GetDictionaryValue(cachedElements, path) == null)
{
VRTK_Logger.Error(VRTK_Logger.GetCommonMessage(VRTK_Logger.CommonMessageKeys.SDK_OBJECT_NOT_FOUND, "Controller Model", "Controller SDK"));
return(null);
}
return(VRTK_SharedMethods.GetDictionaryValue(cachedElements, path, actualModelContainer.transform.Find(path), true));
}
/// <summary>
/// The GetControllerButtonState method is used to determine if the given controller button for the given press type on the given controller reference is currently taking place.
/// </summary>
/// <param name="buttonType">The type of button to check for the state of.</param>
/// <param name="pressType">The button state to check for.</param>
/// <param name="controllerReference">The reference to the controller to check the button state on.</param>
/// <returns>Returns true if the given button is in the state of the given press type on the given controller reference.</returns>
public override bool GetControllerButtonState(ButtonTypes buttonType, ButtonPressTypes pressType, VRTK_ControllerReference controllerReference)
{
if (!VRTK_ControllerReference.IsValid(controllerReference))
{
return(false);
}
bool isRightController = (controllerReference.hand == ControllerHand.Right);
KeyCode?touchButton = VRTK_SharedMethods.GetDictionaryValue((isRightController ? rightControllerTouchKeyCodes : leftControllerTouchKeyCodes), buttonType);
KeyCode?pressButton = VRTK_SharedMethods.GetDictionaryValue((isRightController ? rightControllerPressKeyCodes : leftControllerPressKeyCodes), buttonType);
switch (buttonType)
{
case ButtonTypes.Trigger:
switch (pressType)
{
case ButtonPressTypes.Touch:
case ButtonPressTypes.TouchDown:
case ButtonPressTypes.TouchUp:
return(IsButtonPressed(pressType, touchButton, pressButton));
case ButtonPressTypes.Press:
case ButtonPressTypes.PressDown:
case ButtonPressTypes.PressUp:
return(IsMouseAliasPress(isRightController, buttonType, pressType) || IsAxisButtonPress(controllerReference, buttonType, pressType));
}
break;
case ButtonTypes.Grip:
return(IsMouseAliasPress(isRightController, buttonType, pressType) || IsAxisButtonPress(controllerReference, buttonType, pressType));
case ButtonTypes.Touchpad:
return(IsButtonPressed(pressType, touchButton, pressButton));
case ButtonTypes.ButtonOne:
return(IsButtonPressed(pressType, touchButton, pressButton));
case ButtonTypes.ButtonTwo:
return(IsButtonPressed(pressType, touchButton, pressButton));
case ButtonTypes.StartMenu:
return(IsButtonPressed(pressType, touchButton, pressButton));
}
return(false);
}
protected virtual float CalculateListAverage()
{
float listAverage = 0;
for (int i = 0; i < trackedObjects.Count; i++)
{
Transform trackedObj = trackedObjects[i];
// Get the amount of Y movement that's occured since the last update.
float previousYPosition = VRTK_SharedMethods.GetDictionaryValue(previousYPositions, trackedObj);
float deltaYPostion = Mathf.Abs(previousYPosition - trackedObj.transform.localPosition.y);
// Convenience code.
List <float> trackedObjList = VRTK_SharedMethods.GetDictionaryValue(movementList, trackedObj, new List <float>(), true);
// Cap off the speed.
if (deltaYPostion > sensitivity)
{
VRTK_SharedMethods.AddListValue(trackedObjList, sensitivity);
}
else
{
VRTK_SharedMethods.AddListValue(trackedObjList, deltaYPostion);
}
// Keep our tracking list at m_averagePeriod number of elements.
if (trackedObjList.Count > averagePeriod)
{
trackedObjList.RemoveAt(0);
}
// Average out the current tracker's list.
float sum = 0;
for (int j = 0; j < trackedObjList.Count; j++)
{
float diffrences = trackedObjList[j];
sum += diffrences;
}
float avg = sum / averagePeriod;
// Add the average to the the list average.
listAverage += avg;
}
return(listAverage);
}
public static string GetCommonMessage(CommonMessageKeys messageKey, params object[] parameters)
{
CreateIfNotExists();
string returnMessage = "";
string outputMessage = VRTK_SharedMethods.GetDictionaryValue(commonMessages, messageKey);
if (outputMessage != null)
{
int outputMessageParts = VRTK_SharedMethods.GetDictionaryValue(commonMessageParts, messageKey);
if (parameters.Length != outputMessageParts)
{
Array.Resize(ref parameters, outputMessageParts);
}
returnMessage = string.Format(outputMessage, parameters);
}
return(returnMessage);
}
protected virtual bool IsAxisOnHandButtonPress(Dictionary <ButtonTypes, bool> axisHandState, ButtonTypes buttonType, ButtonPressTypes pressType, Vector2 axisValue)
{
bool previousAxisState = VRTK_SharedMethods.GetDictionaryValue(axisHandState, buttonType);
if (pressType == ButtonPressTypes.PressDown && !previousAxisState)
{
bool currentAxisState = GetAxisPressState(previousAxisState, axisValue.x);
VRTK_SharedMethods.AddDictionaryValue(axisHandState, buttonType, currentAxisState, true);
return(currentAxisState);
}
if (pressType == ButtonPressTypes.PressUp && previousAxisState)
{
bool currentAxisState = GetAxisPressState(previousAxisState, axisValue.x);
VRTK_SharedMethods.AddDictionaryValue(axisHandState, buttonType, currentAxisState, true);
return(!currentAxisState);
}
return(false);
}
public static VRTK_ControllerReference GetControllerReference(GameObject controllerObject)
{
//Try and get the index from either the actual or alias
uint controllerIndex = VRTK_SDK_Bridge.GetControllerIndex(controllerObject);
//If not found then try and get index from the model object
if (controllerIndex >= uint.MaxValue)
{
controllerIndex = VRTK_SDK_Bridge.GetControllerIndex(GetValidObjectFromHand(VRTK_SDK_Bridge.GetControllerModelHand(controllerObject)));
}
VRTK_ControllerReference foundReference = VRTK_SharedMethods.GetDictionaryValue(controllerReferences, controllerIndex);
if (foundReference != null)
{
return(foundReference);
}
return(new VRTK_ControllerReference(controllerIndex));
}
protected virtual void CancelRoutines(GameObject currentAffectingObject = null)
{
if (currentAffectingObject != null)
{
Coroutine currentAffectingRoutine = VRTK_SharedMethods.GetDictionaryValue(affectingRoutines, currentAffectingObject);
if (currentAffectingRoutine != null)
{
StopCoroutine(currentAffectingRoutine);
}
}
else
{
foreach (KeyValuePair <GameObject, Coroutine> affectingRouting in affectingRoutines)
{
if (currentAffectingObject == affectingRouting.Key && affectingRouting.Value != null)
{
StopCoroutine(affectingRouting.Value);
}
}
}
}
protected virtual void ManageTouchCollision(VRTK_InteractTouch touchToIgnore, bool ignore)
{
Collider[] interactTouchColliders = touchToIgnore.ControllerColliders();
VRTK_ControllerTrackedCollider trackedColliderValue = VRTK_SharedMethods.GetDictionaryValue(VRTK_ObjectCache.registeredTrackedColliderToInteractTouches, touchToIgnore);
if (trackedColliderValue != null)
{
Collider[] trackedColliders = trackedColliderValue.TrackedColliders();
interactTouchColliders = interactTouchColliders.Concat(trackedColliders).ToArray();
}
for (int touchCollidersIndex = 0; touchCollidersIndex < interactTouchColliders.Length; touchCollidersIndex++)
{
for (int localCollidersIndex = 0; localCollidersIndex < localColliders.Length; localCollidersIndex++)
{
if (localColliders[localCollidersIndex] != null && interactTouchColliders[touchCollidersIndex] != null && !ShouldExclude(localColliders[localCollidersIndex].transform))
{
Physics.IgnoreCollision(localColliders[localCollidersIndex], interactTouchColliders[touchCollidersIndex], ignore);
}
}
}
}
/// <summary>
/// The GetPointerLength method retrieves the maximum UI Pointer length for the given pointer ID.
/// </summary>
/// <param name="pointerId">The pointer ID for the UI Pointer to recieve the length for.</param>
/// <returns>The maximum length the UI Pointer will cast to.</returns>
public static float GetPointerLength(int pointerId)
{
return(VRTK_SharedMethods.GetDictionaryValue(pointerLengths, pointerId, float.MaxValue));
}
/// <summary>
/// whether or not the hair touch modifier is currently pressed
/// if so, pressing a key on the keyboard will only emit touch and hair touch events,
/// but not a real press.
/// </summary>
/// <returns>whether or not the HairTouchModifier is active</returns>
protected virtual bool IsHairTouchModifierPressed()
{
return(Input.GetKey(VRTK_SharedMethods.GetDictionaryValue(keyMappings, "HairTouchModifier", KeyCode.None)));
}
