/// <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;
}
}
public InputCommandModel()
{
LightPunch = ButtonStateEnum.Released;
MediumPunch = ButtonStateEnum.Released;
HardPunch = ButtonStateEnum.Released;
LightKick = ButtonStateEnum.Released;
MediumKick = ButtonStateEnum.Released;
HardKick = ButtonStateEnum.Released;
DirectionState = DirectionStateEnum.Neutral;
}
/// <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;
}
}
