/// <summary> /// On state change swap out the active mesh based on the state /// </summary> protected void StateChange(ButtonStateEnum newState) { if (newState == ButtonStateEnum.Pressed) { lastTimePressed = Time.time; } currentDatum = Profile.ButtonStates[(int)newState]; // If we're not using smooth states, just set them now if (!Profile.SmoothStateChanges) { TargetTransform.localScale = currentDatum.Scale; TargetTransform.localPosition = currentDatum.Offset; if (Renderer != null) { if (instantiatedMaterial == null) { sharedMaterial = Renderer.sharedMaterial; instantiatedMaterial = new Material(sharedMaterial); Renderer.sharedMaterial = instantiatedMaterial; } if (!string.IsNullOrEmpty(Profile.ColorPropertyName)) { Renderer.sharedMaterial.SetColor(Profile.ColorPropertyName, currentDatum.StateColor); } if (!string.IsNullOrEmpty(Profile.ValuePropertyName)) { Renderer.sharedMaterial.SetFloat(Profile.ValuePropertyName, currentDatum.StateValue); } } } }
/// <summary> /// On state change swap out the active mesh based on the state /// </summary> public override void OnStateChange(ButtonStateEnum newState) { MeshButtonDatum stateDatum = ButtonStates[(int)newState]; // if filter or renderer are null set them if (_meshFilter == null) { _meshFilter = this.GetComponent <MeshFilter>(); } if (_renderer == null) { _renderer = this.GetComponent <MeshRenderer>(); } if (_animator == null) { _animator = this.GetComponent <Animator>(); } // Play animator state if (UseAnimator) { _animator.Play(stateDatum.Name); } // Set the color from the datum if (_renderer != null) { _renderer.material.color = stateDatum.StateColor; } base.OnStateChange(newState); }
/// <summary> /// Event to fire off when hand visibity changes /// </summary> /// <param name="visible"></param> public virtual void OnHandVisibleChange(bool visible) { m_bLastHandVisible = visible; ButtonStateEnum newState = ButtonState; switch (ButtonState) { case ButtonStateEnum.Interactive: { newState = visible ? ButtonStateEnum.Interactive : ButtonStateEnum.Observation; break; } case ButtonStateEnum.Targeted: { newState = visible ? ButtonStateEnum.Targeted : ButtonStateEnum.ObservationTargeted; break; } case ButtonStateEnum.Observation: { newState = visible ? ButtonStateEnum.Interactive : ButtonStateEnum.Observation; break; } case ButtonStateEnum.ObservationTargeted: { newState = visible ? ButtonStateEnum.Targeted : ButtonStateEnum.ObservationTargeted; break; } } OnStateChange(newState); }
/// <summary> /// Called when button is pressed down. /// </summary> protected void DoButtonPressed(bool bRelease = false) { ButtonStateEnum newState = ButtonStateEnum.Pressed; this.OnStateChange(newState); if (OnButtonPressed != null) { // PETED : edited if (bRelease == true) { OnButtonPressed(gameObject); } } if (OnButtonClicked != null) { OnButtonClicked(gameObject); } if (bRelease) { StartCoroutine(DelayedRelease(0.2f)); } }
/// <summary> /// Handle button pressed callback from button /// </summary> /// <param name="buttonObj"></param> public void ButtonStateChange(ButtonStateEnum newState) { if (newState == ButtonStateEnum.Pressed) { switch (Behavior) { default: break; case ToggleBehaviorEnum.OnTapped: State = !State; break; } } else if (newState == ButtonStateEnum.ObservationTargeted || newState == ButtonStateEnum.Targeted) { switch (Behavior) { default: break; case ToggleBehaviorEnum.OnFocus: State = !State; break; } } }
public void SetButtonState(ButtonStateEnum state) { if (state != CurrentState) { CurrentState = state; SetColor(); } }
/// <summary> /// FocusManager SendMessage("FocusEnter") receiver. /// </summary> public void FocusEnter(FocusArgs args) { if (!m_disabled && args.CurNumFocusers == 1) { ButtonStateEnum newState = Veil.Instance.HandVisible ? ButtonStateEnum.Targeted : ButtonStateEnum.ObservationTargeted; this.OnStateChange(newState); } }
public ButtonElement() { this.mType = ButtonTypeEnum.Reply; this.mState = ButtonStateEnum.Normal; this.mType = ButtonTypeEnum.Reply; this.mState = ButtonStateEnum.Normal; this.mPressedID = 248; this.mNormalID = 247; this.RefreshCache(); }
/// <summary> /// Called when button is pressed down. /// </summary> protected void DoButtonPressed() { if (OnButtonPressed != null) { OnButtonPressed(gameObject); ButtonStateEnum newState = ButtonStateEnum.Pressed; this.OnStateChange(newState); } }
/// <summary> /// FocusManager SendMessage("FocusEnter") receiver. /// </summary> public void OnFocusEnter(PointerSpecificEventData eventData) { if (!m_disabled) { ButtonStateEnum newState = _bHandVisible ? ButtonStateEnum.Targeted : ButtonStateEnum.ObservationTargeted; this.OnStateChange(newState); _bFocused = true; } }
/// <summary> /// Called when button is released. /// </summary> protected void DoButtonReleased() { if (OnButtonReleased != null) { OnButtonReleased(gameObject); ButtonStateEnum newState = ButtonStateEnum.Observation; this.OnStateChange(newState); } }
/// <summary> /// Callback virtual function for when the button state changes /// </summary> /// <param name="newState"> /// A <see cref="ButtonStateEnum"/> for the new button state. /// </param> public virtual void OnStateChange(ButtonStateEnum newState) { ButtonState = newState; // Send out the action/event for the statechange if (this.StateChange != null) { this.StateChange(newState); } }
public virtual void Released(InteractionManager.InteractionEventArgs args) { if (enabled) { DoButtonReleased(); // Unset state from pressed. ButtonStateEnum newState = ButtonStateEnum.Targeted; this.OnStateChange(newState); } }
/// <summary> /// InteractionManager SendMessage("HoldStarted") receiver. /// </summary> /// <param name="args"></param> public virtual void HoldStarted(InteractionManager.InteractionEventArgs args) { if (!m_disabled) { DoButtonPressed(); // Set state to Pressed ButtonStateEnum newState = ButtonStateEnum.Pressed; this.OnStateChange(newState); } }
/// <summary> /// InteractionManager SendMessage("HoldCanceled") receiver. /// </summary> /// <param name="args"></param> public virtual void HoldCanceled(InteractionManager.InteractionEventArgs args) { if (!m_disabled && ButtonState == ButtonStateEnum.Pressed) { DoButtonCancelled(); // Unset state from pressed. ButtonStateEnum newState = ButtonStateEnum.Targeted; this.OnStateChange(newState); } }
/// <summary> /// On state change swap out the active mesh based on the state /// </summary> public override void OnStateChange(ButtonStateEnum newState) { if (_animator == null) { _animator = this.GetComponent <Animator>(); } _animator.SetInteger("State", (int)newState); base.OnStateChange(newState); }
/// <summary> /// Handle On Hold started from IHoldSource /// </summary> /// <param name="eventData"></param> public void OnHoldCanceled(HoldEventData eventData) { if (!m_disabled && ButtonState == ButtonStateEnum.Pressed) { DoButtonCanceled(); // Unset state from pressed. ButtonStateEnum newState = ButtonStateEnum.Targeted; this.OnStateChange(newState); } }
/// <summary> /// Callback override function to change prefab enabled on button state change /// </summary> /// <param name="newState"> /// A <see cref="ButtonStateEnum"/> for the new button state. /// </param> public override void OnStateChange(ButtonStateEnum newState) { for (int i = 0; i < ButtonStates.Length; i++) { if (ButtonStates[i].Instance != null) { ButtonStates[i].Instance.SetActive(i == (int)newState); } } base.OnStateChange(newState); }
public InputCommandModel() { LightPunch = ButtonStateEnum.Released; MediumPunch = ButtonStateEnum.Released; HardPunch = ButtonStateEnum.Released; LightKick = ButtonStateEnum.Released; MediumKick = ButtonStateEnum.Released; HardKick = ButtonStateEnum.Released; DirectionState = DirectionStateEnum.Neutral; }
void Update() { //Debug.Log(/*this.name + */" button STATE is " + PosState); NowButtonState = ButtonState; LocalClear = ClearManager.GetComponent <ClearAll>().clear; //Debug.Log("LLLLL: " + LocalClear); if (LocalClear == true) { PosState = PosButtonType.CANCEL; } }
/// <summary> /// Handle input down events from IInputSource. /// </summary> /// <param name="eventData"></param> public void OnInputDown(InputEventData eventData) { if (enabled) { if (ButtonPressFilter == InteractionSourcePressInfo.None || ButtonPressFilter == eventData.PressType) { DoButtonPressed(); // Set state to Pressed ButtonStateEnum newState = ButtonStateEnum.Pressed; this.OnStateChange(newState); } } }
protected ButtonElement(SerializationInfo info, StreamingContext context) : base(info, context) { this.mType = ButtonTypeEnum.Reply; this.mState = ButtonStateEnum.Normal; info.GetInt32("ButtonElementVersion"); this.mPressedID = info.GetInt32(nameof(PressedID)); this.mNormalID = info.GetInt32(nameof(NormalID)); this.mType = (ButtonTypeEnum)info.GetInt32(nameof(Type)); this.mState = (ButtonStateEnum)info.GetInt32(nameof(State)); this.mCodeBehind = info.GetString("CodeBehind"); this.mParam = info.GetInt32(nameof(Param)); this.RefreshCache(); }
/// <summary> /// State change /// </summary> void StateChange(ButtonStateEnum newState) { if (TargetAnimator == null) { return; } if (AnimActions == null) { return; } if (!gameObject.activeSelf) { return; } for (int i = 0; i < AnimActions.Length; i++) { if (AnimActions[i].ButtonState == newState) { if (!string.IsNullOrEmpty(AnimActions[i].ParamName)) { switch (AnimActions[i].ParamType) { case AnimatorControllerParameterType.Bool: TargetAnimator.SetBool(AnimActions[i].ParamName, AnimActions[i].BoolValue); break; case AnimatorControllerParameterType.Float: TargetAnimator.SetFloat(AnimActions[i].ParamName, AnimActions[i].FloatValue); break; case AnimatorControllerParameterType.Int: TargetAnimator.SetInteger(AnimActions[i].ParamName, AnimActions[i].IntValue); break; case AnimatorControllerParameterType.Trigger: TargetAnimator.SetTrigger(AnimActions[i].ParamName); break; default: throw new ArgumentOutOfRangeException(); } } break; } } }
public override void OnStateChange(ButtonStateEnum newState) { Element element = gameObject.GetComponent <Element>(); switch (newState) { case ButtonStateEnum.ObservationTargeted: case ButtonStateEnum.Targeted: // If we're not the active element, light up if (Element.ActiveElement != this) { element.Highlight(); } break; case ButtonStateEnum.Pressed: // User has clicked us // If we're the active element button, reset ourselves if (Element.ActiveElement == element) { // If we're the current element, reset ourselves Element.ActiveElement = null; } else { Element.ActiveElement = element; //element.Open(); App app = null; GameObject appObject = GameObject.Find("AppObject"); if (appObject != null) { app = appObject.GetComponent <App>(); if (app != null) { app.TryToAddElement(element); } } } break; default: element.Dim(); break; } base.OnStateChange(newState); }
/// <summary> /// FocusManager SendMessage("FocusExit") receiver. /// </summary> public void FocusExit(FocusArgs args) { if (!m_disabled && args.CurNumFocusers == 0) { if (ButtonState == ButtonStateEnum.Pressed) { DoButtonCancelled(); } ButtonStateEnum newState = Veil.Instance.HandVisible ? ButtonStateEnum.Interactive : ButtonStateEnum.Observation; if (RequireGaze || ButtonState != ButtonStateEnum.Pressed) { this.OnStateChange(newState); } } }
/// <summary> /// On state change /// </summary> public override void OnStateChange(ButtonStateEnum newState) { if (_animator == null) { _animator = this.GetComponent <Animator>(); } if (AnimActions == null) { //TODO error? base.OnStateChange(newState); return; } for (int i = 0; i < AnimActions.Length; i++) { if (AnimActions[i].ButtonState == newState) { switch (AnimActions[i].ParamType) { case AnimatorControllerParameterType.Bool: _animator.SetBool(AnimActions[i].ParamName, AnimActions[i].BoolValue); break; case AnimatorControllerParameterType.Float: _animator.SetFloat(AnimActions[i].ParamName, AnimActions[i].FloatValue); break; case AnimatorControllerParameterType.Int: _animator.SetInteger(AnimActions[i].ParamName, AnimActions[i].IntValue); break; case AnimatorControllerParameterType.Trigger: _animator.SetTrigger(AnimActions[i].ParamName); break; default: break; } break; } } base.OnStateChange(newState); }
/// <summary> /// OnStateChange override for changing button state on the key button. /// </summary> public override void OnStateChange(ButtonStateEnum newState) { switch (newState) { case ButtonStateEnum.Observation: if (_bgRenderer != null) { _bgRenderer.material.color = IdleBgColor; } KeyText.color = IdleTxColor; break; case ButtonStateEnum.Targeted: if (_bgRenderer != null) { _bgRenderer.material.color = IdleBgColor; } KeyText.color = IdleTxColor; break; case ButtonStateEnum.Interactive: if (_bgRenderer != null) { _bgRenderer.material.color = HoverBgColor; } KeyText.color = IdleTxColor; break; case ButtonStateEnum.Pressed: if (_bgRenderer != null) { _bgRenderer.material.color = PressBgColor; } KeyText.color = PressTxColor; if (KeySound != null && AudioManager.Instance != null) { AudioManager.Instance.PlayClip(KeySound); } break; } }
/// <summary> /// FocusManager SendMessage("FocusExit") receiver. /// </summary> public void OnFocusExit(PointerSpecificEventData eventData) { if (!m_disabled) // && FocusManager.Instance.IsFocused(this)) { if (ButtonState == ButtonStateEnum.Pressed) { DoButtonCanceled(); } ButtonStateEnum newState = _bHandVisible ? ButtonStateEnum.Interactive : ButtonStateEnum.Observation; if (RequireGaze || ButtonState != ButtonStateEnum.Pressed) { this.OnStateChange(newState); } _bFocused = false; } }
private void stateChange(ButtonStateEnum obj) { if (normal_toCopy == null || alternative_toCopy == null) { return; } if (obj == ButtonStateEnum.ObservationTargeted || obj == ButtonStateEnum.Targeted) { alternative_toCopy.SetActive(true); miniaturGameObjectScript.toShowInstance = Instantiate(alternative_toCopy); alternative_toCopy.SetActive(false); } else if ((obj == ButtonStateEnum.Observation || obj == ButtonStateEnum.Interactive) && button.isActiveAndEnabled) // active and enabled, because, when disabeling the go, button fires "observation event" { normal_toCopy.SetActive(true); miniaturGameObjectScript.toShowInstance = Instantiate(normal_toCopy); normal_toCopy.SetActive(false); } }
void StateChange(ButtonStateEnum newState) { switch (newState) { case ButtonStateEnum.Observation: PlayClip(ButtonObservation); break; case ButtonStateEnum.ObservationTargeted: PlayClip(ButtonObservationTargeted); break; case ButtonStateEnum.Targeted: PlayClip(ButtonTargeted); break; default: break; } }