Comment créer un bouton bascule dans Unity Inspector?

13

Je veux créer un outil similaire à l'outil Terrain d'Unity, qui a de jolis boutons à bascule dans l'inspecteur:

Basculer les boutons dans l'inspecteur Bouton basculé

Comment puis-je réaliser une conception similaire à celle-ci? Je sais comment créer des boutons normaux et d'autres composants d'interface utilisateur dans l'inspecteur, mais je ne trouve pas suffisamment d'informations pour faire basculer les boutons.

Jusqu'à présent, j'ai utilisé des bascules normales qui produisent une case à cocher:

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;
}

Régler la bascule GUIStylesur "Button" ne produit pas le résultat souhaité. Le contenu du texte ou de l'image va à gauche du bouton au lieu de l'intérieur.

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

Comportement indésirable lors du basculement

De plus, aucune des options trouvées dans GUISkin ne semble aider.

unity

— Lasse
source

8

J'ai résolu ce problème en utilisant des boutons au lieu de basculer.

Définissez d'abord deux styles de bouton avant toute fonction:

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

Ensuite, OnInspectorGui()assurez-vous qu'ils sont générés s'ils sont nuls:

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

Et puis utilisez l'idée proposée par @jzx pour basculer les styles:

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();

Cela produit ce que je voulais:

Premier bouton basculé Deuxième bouton basculé

— Lasse
source

1

Bon travail! Je cherchais depuis des jours pour trouver la réponse aux boutons à bascule dans l'éditeur Unity3D. Juste une question - pourquoi ne pas simplement utiliser

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

, au lieu d'avoir deux booléens? Cela fonctionne bien pour moi et le code semble proche de l'utilisation du bouton / bascule d'unité standard

— Ivaylo Slavov

1

@IvayloSlavov J'ai utilisé cela comme exemple pour plus de clarté

— Lasse

4

Toggle renvoie l'état actuel du bouton - soit le même état transmis en valeur, soit la nouvelle valeur telle que modifiée par l'utilisateur. Un meilleur schéma serait donc ...

// 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.
}

Vous pouvez utiliser le même modèle de permutation dépendant de l'état pour les 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
source

3

Voici une manière simple mais simple de le faire:

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

pris d' ici

— Kari
source

1

C'est un moyen assez simple de le faire.

— nsxdavid

2

Utilisez GUILayout.Toolbar . Les documents sont trompeurs, il exécute en fait les boutons ensemble:

De plus, vous pouvez utiliser les styles "buttonleft", "buttonmid", "buttonright" pour dessiner ces styles de bouton directement.

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

— BorisTheBrave
source

0

Tu peux le faire:

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
    }
}

Il est très important que vous instanciez à l' buttonStyleintérieur OnInspectorGUI()sinon vous obtiendrez une erreur. De plus, ne le faites pas buttonStyle = GUI.skin.button;car vous copieriez la skin.buttonréférence et tout changement sur buttonStyleserait de changer tous les styles de boutons.

— Hyago Oliveira
source