public void RegisterPickupable(Collider c, BKI_Hand hand, BKI_Finger finger, BKI_FreezeTypes freezeType)
{
if (c.gameObject == null)
{
return;
}
switch (hand)
{
case BKI_Hand.right:
if (freezeType == BKI_FreezeTypes.toProximal && registeredPickupableRight[(int)finger] != null)
{
return;
}
if (c.GetComponent <IBetterPickupable>() != null && registeredPickupableRight[(int)finger] == null)
{
registeredPickupableRight[(int)finger] = c.GetComponent <IBetterPickupable>().GetPickupable();
}
break;
case BKI_Hand.left:
if (freezeType == BKI_FreezeTypes.toProximal && registeredPickupableLeft[(int)finger] != null)
{
return;
}
if (c.GetComponent <IBetterPickupable>() != null && registeredPickupableLeft[(int)finger] == null)
{
registeredPickupableLeft[(int)finger] = c.GetComponent <IBetterPickupable>().GetPickupable();
}
break;
}
}
public bool EntryAlreadyExists(BKI_Hand hand, BKI_SingleGestureClass ges)
{
SweepDictionaries();
bool returnVal = false;
if (!returnVal)
{
returnVal = ((hand == BKI_Hand.right) ? rhDictionary : lhDictionary).ContainsKey(ges.gestureIdentifier);
}
if (!returnVal)
{
if (hand == BKI_Hand.right)
{
foreach (var g in rhGesturesList)
{
if (g.gesture == ges)
{
return(true);
}
}
}
else
{
foreach (var g in lhGesturesList)
{
if (g.gesture == ges)
{
return(true);
}
}
}
}
return(returnVal);
}
// Returns the rotational value read directly from the rotations before being applied to the mesh.
public float GetFingerValueRaw(BKI_Hand hand, BKI_Finger finger)
{
BKI_HandValues handVals = null;
switch (hand)
{
case BKI_Hand.right:
handVals = rightHandValues;
break;
case BKI_Hand.left:
handVals = leftHandValues;
break;
}
switch (finger)
{
case BKI_Finger.thumb: return(handVals.GetFingerValueRaw(finger));
case BKI_Finger.index: return(handVals.GetFingerValueRaw(finger));
case BKI_Finger.middle: return(handVals.GetFingerValueRaw(finger));
case BKI_Finger.ring: return(handVals.GetFingerValueRaw(finger));
case BKI_Finger.pinky: return(handVals.GetFingerValueRaw(finger));
default: return(0);
}
}
// Returns true or false depending on whether the read value exceeds the demanded deadzone.
// Acts as a mirror of Unity.Input.GetButton() for the BetterKnuckleGestures library.
public bool IsFingerDown(BKI_Hand hand, BKI_Finger finger)
{
BKI_HandValues handVals = null;
switch (hand)
{
case BKI_Hand.right:
handVals = rightHandValues;
break;
case BKI_Hand.left:
handVals = leftHandValues;
break;
}
switch (finger)
{
case BKI_Finger.thumb: return(handVals.GetFingerValue(finger) >= DEFAULT_PRESSED_DEADZONE);
case BKI_Finger.index: return(handVals.GetFingerValue(finger) >= DEFAULT_PRESSED_DEADZONE);
case BKI_Finger.middle: return(handVals.GetFingerValue(finger) >= DEFAULT_PRESSED_DEADZONE);
case BKI_Finger.ring: return(handVals.GetFingerValue(finger) >= DEFAULT_PRESSED_DEADZONE);
case BKI_Finger.pinky: return(handVals.GetFingerValue(finger) >= DEFAULT_PRESSED_DEADZONE);
default: return(false);
}
}
private void FreezeFinger(BKI_Hand hand, BKI_Finger finger, BKI_FreezeTypes freezeType, Collider c)
{
switch (hand)
{
case BKI_Hand.right:
if (BKI_FingerCurler.BKI_Curler_Instance.GetFingerValueRaw(BKI_Hand.right, finger) <= 0.05f)
{
break;
}
fingerFrozenRightHand[(int)finger] = true;
fingerFrozenValueRightHand[(int)finger] = Mathf.Clamp(BKI_FingerCurler.BKI_Curler_Instance.GetFingerValueRaw(BKI_Hand.right, finger) - 0.1f, 0.1f, 1f);
rightHandSkeleton.FreezeFingerInArray(finger, freezeType, c);
break;
case BKI_Hand.left:
if (BKI_FingerCurler.BKI_Curler_Instance.GetFingerValueRaw(BKI_Hand.left, finger) <= 0.05f)
{
break;
}
fingerFrozenLeftHand[(int)finger] = true;
fingerFrozenValueLeftHand[(int)finger] = Mathf.Clamp(BKI_FingerCurler.BKI_Curler_Instance.GetFingerValueRaw(BKI_Hand.left, finger) - 0.1f, 0.1f, 1f);
leftHandSkeleton.FreezeFingerInArray(finger, freezeType, c);
break;
}
RegisterPickupable(c, hand, finger, freezeType);
}
private void DrawButtonsSingle(BKI_Hand hand)
{
string handString = (hand == BKI_Hand.right) ? "right" : "left";
string handStringShorthand = (hand == BKI_Hand.right) ? "rh" : "lh";
lhGesture = SerializeGesture(BKI_Hand.left, leftHandValues);
rhGesture = SerializeGesture(BKI_Hand.right, rightHandValues);
float buttonWidth = WINDOW_MAX_SIZE_X * 0.25f - (DEFAULT_AREA_PADDING * 2.5f);
int xPos = DEFAULT_AREA_PADDING;
BKI_UIType t = (hand == BKI_Hand.right) ? BKI_UIType.right : BKI_UIType.left;
GUILayout.BeginArea(buttonStackRect);
{
GUILayout.BeginArea(new Rect(xPos, 0, WINDOW_MAX_SIZE_X * 0.45f - DEFAULT_AREA_PADDING, TITLE_FIELD_SIZE * 3));
{
EditorGUILayout.BeginHorizontal();
DrawSubmitButtonSingle(hand, buttonWidth);
EditorGUILayout.EndHorizontal();
}
GUILayout.EndArea();
GUILayout.Space(DEFAULT_AREA_PADDING);
}
GUILayout.EndArea();
}
// Saves individual hand
public void SaveToList(BKI_Hand hand, BKI_SingleGestureClass ges, bool isOverwrite = false)
{
BKI_SingleGestureStruct struc = new BKI_SingleGestureStruct(ges);
if (!EntryAlreadyExists(hand, ges) || isOverwrite)
{
if (isOverwrite)
{
foreach (var item in ((hand == BKI_Hand.right) ? rhGesturesList : lhGesturesList))
{
if (item.gesture.gestureIdentifier == ges.gestureIdentifier)
{
((hand == BKI_Hand.right) ? rhGesturesList : lhGesturesList).Remove(item);
break;
}
}
if (((hand == BKI_Hand.right) ? rhDictionary : lhDictionary).ContainsKey(ges.gestureIdentifier))
{
((hand == BKI_Hand.right) ? rhDictionary : lhDictionary).Remove(ges.gestureIdentifier);
}
}
((hand == BKI_Hand.right) ? rhGesturesList : lhGesturesList).Add(struc);
((hand == BKI_Hand.right) ? rhDictionary : lhDictionary).Add(ges.gestureIdentifier, ges);
AssetDatabase.Refresh();
EditorUtility.SetDirty(this);
AssetDatabase.SaveAssets();
}
}
public void SetValues(BKI_Hand h, string id, bool reqClench, BKI_FingerState[] states)
{
hand = h;
gestureIdentifier = id;
requiresClench = reqClench;
fingerStates = states;
AssignValues(states);
}
private FingerValues GetFingerValues(BKI_Hand hand)
{
float thumbVal = BKI_FingerCurler.BKI_Curler_Instance.GetFingerValueMesh(hand, BKI_Finger.thumb);
float indexVal = BKI_FingerCurler.BKI_Curler_Instance.GetFingerValueMesh(hand, BKI_Finger.index);
float middleVal = BKI_FingerCurler.BKI_Curler_Instance.GetFingerValueMesh(hand, BKI_Finger.middle);
float ringVal = BKI_FingerCurler.BKI_Curler_Instance.GetFingerValueMesh(hand, BKI_Finger.ring);
float pinkyVal = BKI_FingerCurler.BKI_Curler_Instance.GetFingerValueMesh(hand, BKI_Finger.pinky);
bool isClenching = BKI_FingerCurler.BKI_Curler_Instance.IsHandClenching(hand);
return(new FingerValues(thumbVal, indexVal, middleVal, ringVal, pinkyVal, isClenching));
}
private void RefreezeFinger(BKI_Hand hand, BKI_Finger finger, BKI_FreezeTypes freezeType, Collider c)
{
if (IsValueOverFrozenValue(hand, finger))
{
UnfreezeFinger(hand, finger, freezeType, c);
}
else
{
FreezeFinger(hand, finger, freezeType, c);
}
}
public BKI_PickupableObject GetRegisteredPickupable(BKI_Hand hand, BKI_Finger finger)
{
if (hand == BKI_Hand.right)
{
return((IsHandGripping(BKI_Hand.right)) ? registeredPickupableRight[(int)finger] : null);
}
else
{
return((IsHandGripping(BKI_Hand.left)) ? registeredPickupableLeft[(int)finger] : null);
}
}
// Initialises the object to get parented to the designated finger on the designated hand.
// Sets the callbacks for when the object enters, stays or exits collision.
public void Initialise(Action onColEnterCallback, Action onColStayCallback, Action onColExitCallback, BKI_Hand h)
{
collidedObjects = new List <Collider>();
onColEnter = onColEnterCallback;
onColStay = onColStayCallback;
onColExit = onColExitCallback;
hand = h;
// Makes sure the collider is set to isTrigger.
GetComponent <Collider>().isTrigger = true;
}
/// <summary>
/// Function that converts the mirror class to the class that will be used at runtime.
/// Cannot return null. If the input class is null, it returns a freshly generated BKI_GestureClass.
/// </summary>
private BKI_SingleGestureClass SerializeGesture(BKI_Hand h, BKI_GestureMirrorClass mirror)
{
BKI_SingleGestureClass returnVal = ScriptableObject.CreateInstance <BKI_SingleGestureClass>();
if (mirror == null)
{
return(returnVal);
}
returnVal.SetValues(h, mirror.gestureIdentifier, mirror.requiresClench, mirror.fingerStates);
return(returnVal);
}
// Sets the speed which the hand adjusts to finger values.
public void SetHandUpdateBlend(BKI_Hand hand, bool isLowBlendPercentage)
{
switch (hand)
{
case BKI_Hand.right:
rightHandSkeleton.SetHandUpdateBlend(isLowBlendPercentage);
break;
case BKI_Hand.left:
leftHandSkeleton.SetHandUpdateBlend(isLowBlendPercentage);
break;
}
}
private void UnfreezeHand(BKI_Hand hand)
{
switch (hand)
{
case BKI_Hand.right:
rightHandSkeleton.UnfreezeHand();
isRightHandFrozen = false;
break;
case BKI_Hand.left:
leftHandSkeleton.UnfreezeHand();
isLeftHandFrozen = false;
break;
}
}
public bool IsValueOverFrozenValue(BKI_Hand h, BKI_Finger f)
{
switch (h)
{
case BKI_Hand.right:
return(fingerFrozenValueRightHand[(int)f] > BKI_FingerCurler.BKI_Curler_Instance.GetFingerValueRaw(BKI_Hand.right, f) ||
BKI_FingerCurler.BKI_Curler_Instance.GetFingerValueRaw(BKI_Hand.right, f) < 0.1f);
case BKI_Hand.left:
return(fingerFrozenValueLeftHand[(int)f] > BKI_FingerCurler.BKI_Curler_Instance.GetFingerValueRaw(BKI_Hand.left, f) ||
BKI_FingerCurler.BKI_Curler_Instance.GetFingerValueRaw(BKI_Hand.left, f) < 0.1f);
default:
return(false);
}
}
public void UnregisterPickupable(Collider c, BKI_Hand hand, BKI_Finger finger, BKI_FreezeTypes freezeType)
{
if (c.GetComponent <IBetterPickupable>() == null)
{
return;
}
switch (hand)
{
case BKI_Hand.right:
registeredPickupableRight[(int)finger] = null;
break;
case BKI_Hand.left:
registeredPickupableLeft[(int)finger] = null;
break;
}
}
// Returns current value.
public bool IsHandGripping(BKI_Hand hand)
{
BKI_HandValues vals = (hand == BKI_Hand.left) ? leftHandValues : rightHandValues;
BKI_SteamVR_Behaviour_Skeleton skel = (hand == BKI_Hand.left) ? leftHandSkeleton : rightHandSkeleton;
bool canDoLoop = skel.IsFingerFrozen(BKI_Finger.thumb) && (skel.IsFingerFrozen(BKI_Finger.index) || skel.IsFingerFrozen(BKI_Finger.middle) || skel.IsFingerFrozen(BKI_Finger.ring) || skel.IsFingerFrozen(BKI_Finger.pinky));
if (canDoLoop)
{
for (int i = 1; i < 5; i++)
{
if (!(skel.IsFingerFrozen((BKI_Finger)i) && !(vals.GetFingerValue((BKI_Finger)i) < 0.1f)))
{
continue;
}
if (
(colliderManager.GetRegisteredPickupable(hand, BKI_Finger.thumb) != null &&
(colliderManager.GetRegisteredPickupable(hand, (BKI_Finger)i)) != null) &&
colliderManager.GetRegisteredPickupable(hand, BKI_Finger.thumb).GetPickupable() == colliderManager.GetRegisteredPickupable(hand, (BKI_Finger)i).GetPickupable())
{
if (hand == BKI_Hand.right)
{
rhGrippedObject = colliderManager.GetRegisteredPickupable(hand, BKI_Finger.thumb);
}
else
{
lhGrippedObject = colliderManager.GetRegisteredPickupable(hand, BKI_Finger.thumb);
}
return(true);
}
}
}
else
{
if (hand == BKI_Hand.right)
{
rhGrippedObject = null;
}
else
{
lhGrippedObject = null;
}
return(false);
}
return(false);
}
// Happens when the "Save Gesture" button is pressed. Starts the saving process. Returns the object referenced in the resources folder.
private BKI_SingleGestureClass SubmitSingleHandGesture(BKI_Hand hand, BKI_SingleGestureClass ges, bool fromResources)
{
BKI_SingleGestureClass returnObj = null;
if (gestureStorage == null)
{
Debug.LogError("Gesture storage could not be found. Exiting save function.");
return(null);
}
if (!gestureStorage.EntryAlreadyExists(hand, ges) || fromResources)
{
returnObj = SaveObjectToResources(ges, hand);
gestureStorage.SaveToList(hand, returnObj, fromResources);
}
return(returnObj);
}
private void UnfreezeFinger(BKI_Hand hand, BKI_Finger finger, BKI_FreezeTypes freezeType, Collider c)
{
switch (hand)
{
case BKI_Hand.right:
fingerFrozenRightHand[(int)finger] = false;
fingerFrozenValueRightHand[(int)finger] = 0;
rightHandSkeleton.UnfreezeFingerInArray(finger, freezeType, c);
break;
case BKI_Hand.left:
fingerFrozenLeftHand[(int)finger] = false;
fingerFrozenValueLeftHand[(int)finger] = 0;
leftHandSkeleton.UnfreezeFingerInArray(finger, freezeType, c);
break;
}
UnregisterPickupable(c, hand, finger, freezeType);
}
// Only returns true on the frame grip is entered.
public bool IsHandGrippingDown(BKI_Hand hand)
{
bool currentHandState = IsHandGripping(hand);
bool prevGripping = (hand == BKI_Hand.left) ? leftPreviousIsGripping : rightPreviousIsGripping;
bool returnVal = currentHandState && !prevGripping;
if (hand == BKI_Hand.left)
{
leftPreviousIsGripping = currentHandState;
}
else
{
rightPreviousIsGripping = currentHandState;
}
return(returnVal);
}
// Draws the appropriate title depending on the hand requested.
private void DrawHandTitle(BKI_Hand hand)
{
string handString = (hand == BKI_Hand.right) ? "Right" : "Left";
GUILayout.Space(12);
EditorGUILayout.BeginHorizontal();
{
GUILayout.Label(handString + " hand \n gesture", subtitleStyle);
if (GUILayout.Button("Reset values \n " + handString + " hand", GUILayout.Height(32), GUILayout.Width(96)))
{
if (hand == BKI_Hand.right)
{
ResetRh();
}
else
{
ResetLh();
}
}
GUILayout.Space(32);
}
EditorGUILayout.EndHorizontal();
}
private bool IsHandGripping(BKI_Hand hand)
{
if (hand == BKI_Hand.left)
{
for (int i = 1; i < 5; i++)
{
if (registeredPickupableLeft[i] == registeredPickupableLeft[0])
{
return(true);
}
}
}
else
{
for (int i = 1; i < 5; i++)
{
if (registeredPickupableRight[i] == registeredPickupableRight[0])
{
return(true);
}
}
}
return(false);
}
public BKI_PickupableObject GetGrippedObject(BKI_Hand hand)
{
return((hand == BKI_Hand.right) ? rhGrippedObject : lhGrippedObject);
}
public bool IsHandClenching(BKI_Hand hand)
{
return((hand == BKI_Hand.right) ? rightHandValues.GetIsClenching() : leftHandValues.GetIsClenching());
}
// Draws the check boxes and their labels as seen in the tool UI.
private void DrawBooleans(BKI_Hand hand)
{
BKI_GestureMirrorClass values = (hand == BKI_Hand.right) ? rightHandValues : leftHandValues;
Rect containerRect = (hand == BKI_Hand.right) ? handGUIContainer : handGUIContainer;
Rect r = new Rect(DEFAULT_AREA_PADDING + 5, TITLE_FIELD_SIZE + 2, containerRect.width - DEFAULT_AREA_PADDING * 1.5f, containerRect.height - DEFAULT_AREA_PADDING * 1.5f - TITLE_FIELD_SIZE);
GUILayout.BeginArea(r);
{
// Parenthesis to clarify GUI layout at code side.
EditorGUILayout.BeginHorizontal();
{
EditorGUILayout.BeginVertical();
{
GUILayout.Label("Thumb: ");
GUILayout.Space(3);
GUILayout.Label("Index: ");
GUILayout.Space(3);
GUILayout.Label("Middle: ");
GUILayout.Space(3);
GUILayout.Label("Ring: ");
GUILayout.Space(3);
GUILayout.Label("Pinky: ");
}
EditorGUILayout.EndVertical();
GUILayout.Space(-60);
EditorGUILayout.BeginVertical();
{
values.fingerStates[0] = (BKI_FingerState)GUILayout.Toolbar((int)values.fingerStates[0], toolbarText, GUILayout.Width(160));
values.fingerStates[1] = (BKI_FingerState)GUILayout.Toolbar((int)values.fingerStates[1], toolbarText, GUILayout.Width(160));
values.fingerStates[2] = (BKI_FingerState)GUILayout.Toolbar((int)values.fingerStates[2], toolbarText, GUILayout.Width(160));
values.fingerStates[3] = (BKI_FingerState)GUILayout.Toolbar((int)values.fingerStates[3], toolbarText, GUILayout.Width(160));
values.fingerStates[4] = (BKI_FingerState)GUILayout.Toolbar((int)values.fingerStates[4], toolbarText, GUILayout.Width(160));
}
EditorGUILayout.EndVertical();
//EditorGUILayout.BeginVertical();
//{
// bool thumb = values.GetFingerPressed(BKI_Finger.thumb);
// thumb = EditorGUILayout.Toggle(values.GetFingerPressed(BKI_Finger.thumb));
// values.SetFingerPressed(BKI_Finger.thumb, thumb);
// bool index = values.GetFingerPressed(BKI_Finger.index);
// index = EditorGUILayout.Toggle(values.GetFingerPressed(BKI_Finger.index));
// values.SetFingerPressed(BKI_Finger.index, index);
// bool middle = values.GetFingerPressed(BKI_Finger.middle);
// middle = EditorGUILayout.Toggle(values.GetFingerPressed(BKI_Finger.middle));
// values.SetFingerPressed(BKI_Finger.middle, middle);
// bool ring = values.GetFingerPressed(BKI_Finger.ring);
// ring = EditorGUILayout.Toggle(values.GetFingerPressed(BKI_Finger.ring));
// values.SetFingerPressed(BKI_Finger.ring, ring);
// bool pinky = values.GetFingerPressed(BKI_Finger.pinky);
// pinky = EditorGUILayout.Toggle(values.GetFingerPressed(BKI_Finger.pinky));
// values.SetFingerPressed(BKI_Finger.pinky, pinky);
//}
//EditorGUILayout.EndVertical();
//EditorGUILayout.BeginVertical();
//{
// GUILayout.Label("Ignore thumb: ");
// GUILayout.Label("Ignore index: ");
// GUILayout.Label("Ignore middle: ");
// GUILayout.Label("Ignore ring: ");
// GUILayout.Label("Ignore pinky: ");
//}
//EditorGUILayout.EndVertical();
//EditorGUILayout.BeginVertical();
//{
// bool thumb = values.GetFingerIgnored(BKI_Finger.thumb);
// thumb = EditorGUILayout.Toggle(values.GetFingerIgnored(BKI_Finger.thumb));
// values.SetFingerIgnored(BKI_Finger.thumb, thumb);
// bool index = values.GetFingerIgnored(BKI_Finger.index);
// index = EditorGUILayout.Toggle(values.GetFingerIgnored(BKI_Finger.index));
// values.SetFingerIgnored(BKI_Finger.index, index);
// bool middle = values.GetFingerIgnored(BKI_Finger.middle);
// middle = EditorGUILayout.Toggle(values.GetFingerIgnored(BKI_Finger.middle));
// values.SetFingerIgnored(BKI_Finger.middle, middle);
// bool ring = values.GetFingerIgnored(BKI_Finger.ring);
// ring = EditorGUILayout.Toggle(values.GetFingerIgnored(BKI_Finger.ring));
// values.SetFingerIgnored(BKI_Finger.ring, ring);
// bool pinky = values.GetFingerIgnored(BKI_Finger.pinky);
// pinky = EditorGUILayout.Toggle(values.GetFingerIgnored(BKI_Finger.pinky));
// values.SetFingerIgnored(BKI_Finger.pinky, pinky);
//}
//EditorGUILayout.EndVertical();
}
EditorGUILayout.EndHorizontal();
}
GUILayout.EndArea();
if (hand == BKI_Hand.right)
{
if (rightHandValues != values && values.gestureIdentifier != pickerWindowGNameRh)
{
ResetPickerWindow(false, true, false);
rightHandValues = values;
}
}
else if (leftHandValues != values && values.gestureIdentifier != pickerWindowGNameLh)
{
ResetPickerWindow(true, false, false);
leftHandValues = values;
}
}
private void RefreezeHand(BKI_Hand hand)
{
FreezeHand(hand);
}
private BKI_SingleGestureClass SaveObjectToResources(BKI_SingleGestureClass o, BKI_Hand hand)
{
string path = "";
switch (hand)
{
case BKI_Hand.left:
{
path = RESOURCES_LEFTHAND_PATH + "/lhGes_" + o.gestureIdentifier + ".asset";
}
break;
case BKI_Hand.right:
{
path = RESOURCES_RIGHTHAND_PATH + "/rhGes_" + o.gestureIdentifier + ".asset";
}
break;
}
AssetDatabase.CreateAsset(o, path);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
return(AssetDatabase.LoadAssetAtPath <BKI_SingleGestureClass>(path));
}
public int GetFingerPriorityValue(BKI_Hand hand)
{
return((hand == BKI_Hand.right) ? priorityValueRh : priorityValueLh);
}
// Draws the base hand and the individual fingers dependent on selected values.
private void DrawHandImages(BKI_Hand hand, BKI_GestureMirrorClass values, Rect pos, float scale = 1)
{
float flipValueWidth, flipValuePos;
float valueHeight = 1 / scale;
Rect newPos = pos;
if (hand == BKI_Hand.right)
{
flipValueWidth = 1;
flipValuePos = 0;
newPos.x += 15;
}
else
{
flipValueWidth = -1;
flipValuePos = 1;
}
flipValueWidth /= scale;
if (values.GetFingerState(BKI_Finger.thumb) == BKI_FingerState.FingerIgnored)
{
GUI.DrawTextureWithTexCoords(newPos, thumbHandCrossText2D, new Rect(flipValuePos, 0, flipValueWidth, valueHeight));
}
else if (!(values.GetFingerState(BKI_Finger.thumb) == BKI_FingerState.fingerIn))
{
GUI.DrawTextureWithTexCoords(newPos, thumbHandText2D, new Rect(flipValuePos, 0, flipValueWidth, valueHeight));
}
if (values.GetFingerState(BKI_Finger.index) == BKI_FingerState.FingerIgnored)
{
GUI.DrawTextureWithTexCoords(newPos, indexHandCrossText2D, new Rect(flipValuePos, 0, flipValueWidth, valueHeight));
}
else if (!(values.GetFingerState(BKI_Finger.index) == BKI_FingerState.fingerIn))
{
GUI.DrawTextureWithTexCoords(newPos, indexHandText2D, new Rect(flipValuePos, 0, flipValueWidth, valueHeight));
}
if (values.GetFingerState(BKI_Finger.middle) == BKI_FingerState.FingerIgnored)
{
GUI.DrawTextureWithTexCoords(newPos, middleHandCrossText2D, new Rect(flipValuePos, 0, flipValueWidth, valueHeight));
}
else if (!(values.GetFingerState(BKI_Finger.middle) == BKI_FingerState.fingerIn))
{
GUI.DrawTextureWithTexCoords(newPos, middleHandText2D, new Rect(flipValuePos, 0, flipValueWidth, valueHeight));
}
if (values.GetFingerState(BKI_Finger.ring) == BKI_FingerState.FingerIgnored)
{
GUI.DrawTextureWithTexCoords(newPos, ringHandCrossText2D, new Rect(flipValuePos, 0, flipValueWidth, valueHeight));
}
else if (!(values.GetFingerState(BKI_Finger.ring) == BKI_FingerState.fingerIn))
{
GUI.DrawTextureWithTexCoords(newPos, ringHandText2D, new Rect(flipValuePos, 0, flipValueWidth, valueHeight));
}
if (values.GetFingerState(BKI_Finger.pinky) == BKI_FingerState.FingerIgnored)
{
GUI.DrawTextureWithTexCoords(newPos, pinkyHandCrossText2D, new Rect(flipValuePos, 0, flipValueWidth, valueHeight));
}
else if (!(values.GetFingerState(BKI_Finger.pinky) == BKI_FingerState.fingerIn))
{
GUI.DrawTextureWithTexCoords(newPos, pinkyHandText2D, new Rect(flipValuePos, 0, flipValueWidth, valueHeight));
}
GUI.DrawTextureWithTexCoords(newPos, baseHandText2D, new Rect(flipValuePos, 0, flipValueWidth, valueHeight));
}
