Come faccio a creare un pulsante di attivazione / disattivazione in Unity Inspector?

13

Voglio creare uno strumento simile allo strumento Terreno di Unity, che ha alcuni pulsanti di attivazione / disattivazione nell'ispettore:

Attiva / disattiva i pulsanti nella finestra di ispezione Pulsante attivato

Come posso ottenere un design simile a questo? So come creare pulsanti normali e altri componenti dell'interfaccia utente in Impostazioni, ma non riesco a trovare informazioni sufficienti per attivare / disattivare i pulsanti.

Finora ho usato le normali levette che producono una casella di controllo:

var tmp = EditorGUILayout.Toggle( SetAmountFieldContent, _setValue );

if ( tmp != _setValue )
{
  _setValue = tmp;
  if ( _setValue )
    _smoothValue = false;
}

tmp = EditorGUILayout.Toggle( SmoothValueFieldContent, _smoothValue );

if ( tmp != _smoothValue )
{
  _smoothValue = tmp;
  if ( _smoothValue )
    _setValue = false;
}

Impostando l'interruttore GUIStylesu "Pulsante" non si ottiene il risultato desiderato. Il contenuto del testo o dell'immagine va a sinistra del pulsante anziché all'interno.

var tmp = EditorGUILayout.Toggle( SetAmountFieldContent, _setValue, "Button" );

Comportamento indesiderato su attivazione / disattivazione

Inoltre, nessuna delle opzioni disponibili in GUISkin non sembra essere d'aiuto.

unity

— Lasse
fonte

8

Ho risolto questo problema utilizzando i pulsanti anziché gli interruttori.

Prima definire due stili di pulsante prima di qualsiasi funzione:

private static GUIStyle ToggleButtonStyleNormal = null;
private static GUIStyle ToggleButtonStyleToggled = null;

Quindi OnInspectorGui()assicurati che vengano generati se null:

if ( ToggleButtonStyleNormal == null )
{
  ToggleButtonStyleNormal = "Button";
  ToggleButtonStyleToggled = new GUIStyle(ToggleButtonStyleNormal);
  ToggleButtonStyleToggled.normal.background = ToggleButtonStyleToggled.active.background;
}

E poi usa l'idea proposta da @jzx per attivare e disattivare gli stili:

GUILayout.BeginHorizontal(  );

if ( GUILayout.Button( SetAmountFieldContent, _setValue ? ToggleButtonStyleToggled : ToggleButtonStyleNormal ) )
{
  _setValue = true;
  _smoothValue = false;
}

if ( GUILayout.Button( SmoothValueFieldContent, _smoothValue ? ToggleButtonStyleToggled : ToggleButtonStyleNormal ) )
{
  _smoothValue = true;
  _setValue = false;
}

GUILayout.EndHorizontal();

Questo produce ciò che volevo:

Primo pulsante attivato Secondo pulsante attivato

— Lasse
fonte

1

Ottimo lavoro! Stavo cercando giorni per trovare la risposta ai pulsanti di attivazione / disattivazione nell'editor Unity3D. Solo una domanda: perché non usi semplicemente

_smoothValue = !GUILayout.Button( SetAmountFieldContent, _smoothValue  ? ToggleButtonStyleToggled : ToggleButtonStyleNormal)

, invece di avere due booleani? Funziona bene per me e il codice sembra vicino all'uso del pulsante / interruttori di stadnard unity

— Ivaylo Slavov

1

@IvayloSlavov L'ho usato come esempio per chiarezza

— Lasse il

4

Toggle restituisce lo stato corrente del pulsante: lo stesso stato passato in valore o il nuovo valore modificato dall'utente. Quindi un modello migliore sarebbe ...

// TODO: Initialize these with GUIContent
private GUIContent _toggleButtonDepressedLabel;
private GUIContent _toggleButtonDefaultLabel;

// Current toggle state
bool _toggleButtonState;

void DisplayToggle()
{
    var image = _toggleButtonValue
                ? _toggleButtonDepressedLabel
                : _toggleButtonDefaultLabel;
    var newState = EditorGUILayout.Toggle(image, _toggleButtonState);
    if (newState != _toggleButtonState)
    {
        _toggleButtonState = newState;
        OnToggleButtonChanged();
    }
}

void OnGUI ()
{
    DisplayToggle();
}

void OnToggleButtonChanged()
{
    // Do stuff.
}

È possibile utilizzare lo stesso modello di scambio dipendente dallo stato per GUIStyles.

private GUIStyle _toggleButtonDepressedStyle;
private GUIStyle _toggleButtonDefaultStyle;
// ...
    var image = _toggleButtonValue
                ? _toggleButtonDepressedLabel
                : _toggleButtonDefaultLabel;
    var style = _toggleButtonValue
                ? _toggleButtonDepressedStyle
                : _toggleButtonDefaultStyle;
    var newState = EditorGUILayout.Toggle(image, _toggleButtonState, style);

— JZX
fonte

3

Ecco un modo semplice ma semplice per farlo:

 pressed = GUILayout.Toggle(pressed, "Toggle me !", "Button");

preso da qui

— Kari
fonte

1

Questo è un modo semplice per farlo.

— nsxdavid,

2

Utilizzare GUILayout.Toolbar . I documenti sono fuorvianti, in realtà esegue i pulsanti insieme:

Inoltre, puoi usare gli stili "buttonleft", "buttonmid", "buttonright" per disegnare direttamente questi stili di pulsante.

        var left = GUI.skin.FindStyle("buttonleft");
        GUILayout.Button("left only button", left);

— BorisTheBrave
fonte

0

Puoi farlo:

private GUIStyle buttonStyle;
private bool enableToogle;

public override void OnInspectorGUI()
{
    buttonStyle = new GUIStyle(GUI.skin.button);
    enableToogle = GUILayout.Toggle(enableToogle, "Toogle Me", buttonStyle);

    if(enableToogle)
    {
        // your stuff here
    }
}

È molto importante che tu installi buttonStyleall'interno, OnInspectorGUI()altrimenti otterrai un errore. Inoltre, non farlo buttonStyle = GUI.skin.button;perché copieresti il skin.buttonriferimento e qualsiasi modifica buttonStylecambierebbe tutti gli stili dei pulsanti.

— Hyago Oliveira
fonte