private void OnTrigger(XRController controller, float value)
{
if (!isOnInteractableEvent && !isOnSelectedEvent && value > 0.002f)
{
return;
}
float maximumValue = animateGrabFrame;
float normValue = Mathf.Clamp(value, 0f, maximumValue);
switch (grabType)
{
case GrabbingType.None:
case GrabbingType.SimpleFingerTip:
anim.SetBool("TriggerTouch", false);
anim.SetFloat("TriggerHandGrab", 0f);
anim.SetFloat("TriggerFingerGrab", 0f);
break;
case GrabbingType.FingerGrab:
anim.SetBool("TriggerTouch", false);
anim.SetFloat("TriggerHandGrab", 0f);
anim.SetFloat("TriggerFingerGrab", normValue);
break;
case GrabbingType.HandGrab:
anim.SetBool("TriggerTouch", false);
anim.SetFloat("TriggerFingerGrab", 0f);
anim.SetFloat("TriggerHandGrab", normValue);
break;
}
}
void Awake()
{
scene = GameObject.Find("Scene");
rightHandController = GameObject.Find("RightHand Controller");
if (rightHandController != null) // guard
{
rightXRController = rightHandController.GetComponent <XRController>();
rightRayRenderer = rightHandController.GetComponent <LineRenderer>();
if (rightRayRenderer == null)
{
rightRayRenderer = rightHandController.AddComponent <LineRenderer>() as LineRenderer;
}
rightRayRenderer.startWidth = 0.01f;
rightRayRenderer.positionCount = 2; // two points (one line segment)
rightRayRenderer.enabled = true;
cursorDistance = 0.2f;
// geometry for intersection visualization
cursorBall = GameObject.Find("CursorSphere");
collisionDetector = cursorBall.GetComponent <CollisionDetector>();
cursorBall.GetComponent <MeshRenderer>().material.color = Color.yellow;
cursorBall.transform.position = rightHandController.transform.position + rightHandController.transform.forward * cursorDistance;
cursorBall.SetActive(false);
}
//Debug.Log("DefaultRay Start: " + rightHandController);
}
private void SetPoint(XRController controller, XRRayInteractor interactor)
{
if (controller.controllerNode == hand)
{
MeasureDistance(interactor);
}
}
private void Clear(XRController controller, XRRayInteractor interactor)
{
//You could limit the clear to a certain controller by
//comparing the current node.
Display(false);
m_measuring = false;
}
static void CreateXRUIPointer()
{
GameObject selectedGo = Selection.activeGameObject;
if (selectedGo == null)
{
selectedGo = new GameObject("Controller", typeof(XRController), typeof(XRUIPointer));
}
XRController controller = selectedGo.GetComponent <XRController>();
if (controller == null)
{
GameObject controllerGo = new GameObject("Controller", typeof(XRController), typeof(XRUIPointer));
controller = selectedGo.GetComponent <XRController>();
Undo.SetTransformParent(controllerGo.transform, selectedGo.transform, "Parent Controller to Selected GameObject");
selectedGo = controllerGo;
}
XRUIPointer pointer = selectedGo.GetComponent <XRUIPointer>();
if (pointer == null)
{
selectedGo.AddComponent <XRUIPointer>();
}
Selection.activeGameObject = selectedGo;
}
private void PrintPrimaryButtonUp(XRController controller)
{
ButtonUp.Invoke();
buttonPressed = false;
pressedTime = 0f;
Debug.Log("Primary button up");
}
private void OnGrabHold(XRController controller)
{
switch (grab)
{
case GrabState.None:
grab = GrabState.One;
var hover = controller.GetComponent <OnHoverEventHandler>();
if (hover.Current != null)
{
grabbedObject = hover.Current;
}
else
{
if (MultiGrab)
{
grabbedObject = LayerManager.Instance.LayerHelper;
foreach (Layer layer in LayerManager.Instance.layers)
{
layer.transform.parent = LayerManager.Instance.LayerHelper.transform;
}
}
else
{
grabbedObject = LayerManager.Instance.ActiveLayer.gameObject;
}
before = new TransformObject(grabbedObject.transform);
}
originalParent = grabbedObject.transform.parent;
movable = grabbedObject.GetComponent <IMovable>();
resizable = grabbedObject.GetComponent <IResizable>();
if (movable != null)
{
grabbedObject.transform.parent = controller.transform;
}
break;
case GrabState.One:
grab = GrabState.Both;
var pos = grabbedObject.transform.position;
grabbedObject.transform.parent = originalParent;
grabbedObject.transform.position = pos;
refDist = Vector3.Distance(leftController.transform.position, rightController.transform.position);
refPos = grabbedObject.transform.position;
refCenter = center;
refScale = grabbedObject.transform.localScale;
refRot = grabbedObject.transform.rotation;
refControllers = (rightController.transform.position - leftController.transform.position).normalized;
refUp = (leftController.transform.up + rightController.transform.up).normalized;
ToolController.Instance.ToggleSelectedTool(false);
break;
default:
break;
}
}
public override void HandleState(XRController controller)
{
Vector2 value = Vector2.zero;
if (Input.GetKey(keyUp))
{
value.y += mockValue;
}
if (Input.GetKey(keyDown))
{
value.y -= mockValue;
}
if (Input.GetKey(keyLeft))
{
value.x -= mockValue;
}
if (Input.GetKey(keyRight))
{
value.x += mockValue;
}
if (previousValue != value)
{
mockedAxis2D.InvokeEvent(controller, value);
}
previousValue = value;
}
protected override void Awake()
{
base.Awake();
foreach (XRController controller in GetComponentsInChildren <XRController>())
{
if (controller.side == HorizontalSide.left)
{
leftController = controller;
}
else if (controller.side == HorizontalSide.right)
{
rightController = controller;
}
controllers.Add(controller.side, controller);
controller.Set(this);
}
if (rightController)
{
activeController = rightController;
}
else
{
activeController = leftController;
}
}
// Start is called before the first frame update
void Start()
{
leftHandController = GameObject.Find("LeftHand Controller");
scene = GameObject.Find("Scene");
selectables = GameObject.Find("Selectables");
cameraOffset = GameObject.Find("Camera Offset");
XRRig = GameObject.Find("XR Rig");
bending = false;
mainCamera = GameObject.Find("Main Camera");
if (leftHandController != null) // guard
{
leftXRController = leftHandController.GetComponent <XRController>();
leftRayRenderer = leftHandController.GetComponent <LineRenderer>();
if (leftRayRenderer == null)
{
leftRayRenderer = leftHandController.AddComponent <LineRenderer>() as LineRenderer;
}
//leftRayRenderer.name = "left Ray Renderer";
leftRayRenderer.startWidth = 0.01f;
leftRayRenderer.positionCount = 2; // two points (one line segment)
leftRayRenderer.enabled = true;
// geometry for intersection visualization
leftRayIntersectionSphere = GameObject.CreatePrimitive(PrimitiveType.Sphere);
//leftRayIntersectionSphere.transform.parent = this.gameObject.transform;
leftRayIntersectionSphere.name = "left Ray Intersection Sphere";
leftRayIntersectionSphere.transform.localScale = new Vector3(0.05f, 0.05f, 0.05f);
leftRayIntersectionSphere.GetComponent <MeshRenderer>().material.color = Color.yellow;
leftRayIntersectionSphere.GetComponent <SphereCollider>().enabled = false; // disable for picking ?!
leftRayIntersectionSphere.SetActive(false);
}
}
// Update is called once per frame
void Update()
{
foreach (var item in m_ReticleCache)
{
XRController controller = item.Key.GetComponent <XRController>();
if (controller.inputDevice.TryGetFeatureValue(new InputFeatureUsage <Vector2>("Primary2DAxis"), out Vector2 value))
{
if (value.magnitude > (controller as XRTeleportationController).TriggerTeleportThreshold)
{
Vector3 camForward = Camera.main.transform.forward;
camForward.y = 0;
camForward = Quaternion.LookRotation(new Vector3(value.x, 0, value.y)) * camForward;
item.Value.transform.GetChild(0).rotation = Quaternion.LookRotation(camForward);
}
else
{
TeleportRequest tr = new TeleportRequest();
tr.matchOrientation = MatchOrientation.Camera;
tr.requestTime = Time.time;
if (GenerateTeleportRequest(item.Key, new RaycastHit(), ref tr))
{
m_TeleportationProvider.QueueTeleportRequest(tr);
}
onSelectEnter.Invoke(item.Key);
}
}
}
}
// Start is called before the first frame update
void Start()
{
startPosition = transform.position;
startRotation = transform.rotation;
mainCamera = GameObject.Find("Main Camera");
rightHandController = GameObject.Find("RightHand Controller");
if (rightHandController != null) // guard
{
rightXRController = rightHandController.GetComponent <XRController>();
}
techniques.Add(GetComponent <DefaultRay>());
techniques.Add(GetComponent <DepthRay>());
techniques.Add(GetComponent <GoGoScript>());
techniques.Add(GetComponent <Argelaguet>());
foreach (var t in techniques)
{
t.enabled = false;
}
activeTechnique = techniques[currentTechniqueIdx];
activeTechnique.enabled = true;
Debug.Log("Active Technique: " + activeTechnique);
}
private void TryStopGrab(XRController controller, XRRayInteractor interactor)
{
if (m_target != null && IsOwner(controller))
{
m_target.StopGrab();
}
}
// Update is called once per frame
void FixedUpdate()
{
//verifier quel bouton est actif
boutonPrimaireActifDroit = CheckIfPrimaryActive(rightHand);
boutonPrimaireActifGauche = CheckIfPrimaryActive(leftHand);
//si on a activé la main droite ET qu'on est au sol OU en train de voler
if (boutonPrimaireActifDroit && (CheckIfGrounded() || variablesGlobales.voler == true))
{
//la main droite devient la main qui tire
draggingHand = rightHand;
//desactive le script de mouvement continu
moveScript.enabled = false;
//active fonction drag
drag();
}
//si la manette de gauche est activée ET qu'on est au sol OU en train de voler
else if (boutonPrimaireActifGauche && (CheckIfGrounded() || variablesGlobales.voler == true))
{
//la main droite devient la main qui tire
draggingHand = leftHand;
//desactive le script de mouvement continu
moveScript.enabled = false;
//active fonction drag
drag();
}
//si aucune main n'est activée, on laisse le script de mouvement continu
else
{
moveScript.enabled = true;
}
}
private void HideRadialMenu(XRController controller, XRRayInteractor interactor)
{
if (controller.controllerNode == hand)
{
RadialMenu.Show(false);
}
}
private void SecondaryHold(XRController controller, XRRayInteractor interactor)
{
if (controller.controllerNode == hand)
{
m_buttons |= MouseButton.Right;
}
}
private void Awake()
{
// Set the instance so that any script can call this from script
current = this;
// End
return;
}
protected override void OnSelectExit(XRBaseInteractor interactor)
{
base.OnSelectExit(interactor);
selectingInteractor = null;
selectingController = null;
}
private void PrimaryHold(XRController controller, XRRayInteractor interactor)
{
if (controller.controllerNode == hand)
{
m_buttons |= MouseButton.Left;
}
}
void Awake()
{
scene = GameObject.Find("Scene");
rightHandController = GameObject.Find("RightHand Controller");
if (rightHandController != null) // guard
{
rightXRController = rightHandController.GetComponent <XRController>();
//rightRayRenderer = gameObject.AddComponent<LineRenderer>();
rightRayRenderer = rightHandController.GetComponent <LineRenderer>();
if (rightRayRenderer == null)
{
rightRayRenderer = rightHandController.AddComponent <LineRenderer>() as LineRenderer;
}
//rightRayRenderer.name = "Right Ray Renderer";
rightRayRenderer.startWidth = 0.01f;
rightRayRenderer.positionCount = 2; // two points (one line segment)
rightRayRenderer.enabled = true;
// geometry for intersection visualization
rightRayIntersectionSphere = GameObject.CreatePrimitive(PrimitiveType.Sphere);
//rightRayIntersectionSphere.transform.parent = this.gameObject.transform;
rightRayIntersectionSphere.name = "Right Ray Intersection Sphere";
rightRayIntersectionSphere.transform.localScale = new Vector3(0.05f, 0.05f, 0.05f);
rightRayIntersectionSphere.GetComponent <MeshRenderer>().material.color = Color.yellow;
rightRayIntersectionSphere.GetComponent <SphereCollider>().enabled = false; // disable for picking ?!
rightRayIntersectionSphere.SetActive(false); // hide
}
}
public bool GetPointerDown(int button)
{
XRController activeController = ActiveController(button);
if (activeController != null)
{
bool value;
if (activeController.inputDevice.TryGetFeatureValue(GetUsageForPointer(button), out value) && value && !IsPressed(button))
{
return(true);
}
return(false);
}
for (int i = 0; i < m_controllers.Length; ++i)
{
bool value;
if (m_controllers[i].inputDevice.TryGetFeatureValue(GetUsageForPointer(button), out value) && value && !IsPressed(button))
{
ActiveController(button, m_controllers[i]);
return(true);
}
}
return(false);
}
public MockHMDInput(XRController right, XRController left)
{
m_rightController = right;
m_leftController = left;
m_rightHand = right.GetComponent <XRRayInteractor>();
m_leftHand = left.GetComponent <XRRayInteractor>();
}
private void PrintGripR(XRController controller, float value)
{
if (value > Mathf.Epsilon)
{
print("GripR: " + value);
}
}
private void PrintTriggerL(XRController controller, float value)
{
if (value > Mathf.Epsilon)
{
print("TriggerL: " + value);
}
}
private void TryMoveGrab(XRController controller, XRRayInteractor interactor)
{
if (m_target != null && m_target.IsValid && IsOwner(controller) && m_style == GrabStyle.Laser)
{
TryMoveTo(interactor);
}
}
/// <summary>
/// Gets the XR InputDevice and sets the correct model to display.
/// This is where a controller is detected and initialized.
/// </summary>
/// <returns>True if successful</returns>
private bool InitializeController(bool isRight, InputDeviceCharacteristics characteristics,
out InputDevice inputDevice,
GameObject handPrefab,
XRController modelParent, out Animator handAnimator, out UiInputHints inputHints,
out XrBrush brush)
{
var devices = new List <InputDevice>();
InputDevices.GetDevicesWithCharacteristics(characteristics, devices);
foreach (var item in devices)
{
Debug.Log($"Detected {item.name}: {item.characteristics}");
}
handAnimator = null;
if (devices.Count > 0)
{
inputDevice = devices[0];
var deviceName = inputDevice.name;
var prefab = useHands ? handPrefab : controllerPrefabs.Find(p => deviceName.StartsWith(p.name));
if (!prefab)
{
//TODO: find correct names for Rift CV1 and Quest
Debug.LogWarning(
$"Could not find controller model with name {deviceName}, using default controllers.");
prefab = controllerPrefabs[isRight ? 1 : 0];
}
var go = Instantiate(prefab, modelParent.modelTransform);
if (useHands)
{
handAnimator = go.GetComponent <Animator>();
}
inputHints = go.GetComponentInChildren <UiInputHints>();
inputHints.Initialize();
if (inputHints)
{
RepaintInputHints(!isRight, isRight);
}
brush = go.GetComponentInChildren <XrBrush>();
if (brush)
{
brush.Initialize(isRight);
}
return(true);
}
inputDevice = default;
inputHints = null;
brush = null;
// Debug.LogWarning("No hand controller found with characteristic: " + c);
return(false);
}
protected override void OnSelectExitFeedbackFunction(XRController controller)
{
switch (feedbackType)
{
case VisualFeedbackType.MeshRenderer:
if (runOnTouch && xrFeedback.IsTouching)
{
meshRenderer.material.color = xrUIColors.touchColor;
}
else if (runOnNear && xrFeedback.IsNear)
{
meshRenderer.material.color = xrUIColors.nearColor;
}
else
{
meshRenderer.material.color = xrUIColors.normalColor;
}
break;
case VisualFeedbackType.SpriteRenderer:
if (runOnTouch && xrFeedback.IsTouching)
{
spriteRenderer.color = xrUIColors.touchColor;
}
else if (runOnNear && xrFeedback.IsNear)
{
spriteRenderer.color = xrUIColors.nearColor;
}
else
{
spriteRenderer.color = xrUIColors.normalColor;
}
break;
case VisualFeedbackType.Outline:
if (runOnTouch && xrFeedback.IsTouching)
{
outline.OutlineColor = xrUIColors.touchColor;
}
else if (runOnNear && xrFeedback.IsNear)
{
outline.OutlineColor = xrUIColors.nearColor;
}
else
{
outline.OutlineColor = xrUIColors.normalColor;
}
break;
default:
break;
}
}
public Vector2 GetValue(XRController controller)
{
if (controller.inputDevice.TryGetFeatureValue(inputFeature, out Vector2 value))
{
return(value);
}
return(Vector2.zero);
}
public float GetValue(XRController controller)
{
if (controller.inputDevice.TryGetFeatureValue(inputFeature, out float value))
{
return(value);
}
return(0.0f);
}
// Start is called before the first frame update
private void Start()
{
// Initalize values
controller = GetComponent <XRController>();
//HandPosition = gameObject.transform.position;
//prevPos = gameObject.transform.position;
velocity = Vector3.zero;
}
