Comment faire disparaître / faire disparaître un GameObject lentement?

Vous pouvez utiliser une Coroutine combinée avec Color.Lerp pour réduire la valeur alpha de tous les matériaux au fil du temps.

(Je suppose que vous voulez dire ici les maillages avec les moteurs de rendu, pas les éléments d'interface utilisateur, mais cela fonctionnerait également de la même manière)

// How long should fading take (in seconds)
public float fadingDuration = 1;

// For storing Renderer components
private Renderer[] renderers;

// For storing original color data
private List<Color> originalColors = new List<Color>();

// For storing FadeOut color data
// (= Original data with alpha=0)
private List<Color> fadeOutColors = new List<Color>();

private void Awake() {
    // Get all renderers, own and children
    renderers  = GetComponentInChildren<Renderer>(true);

    // Run through renderers
    foreach(var rend in renderers)
    {
        // Run through all materials
        foreach (vat mat in rend.materials)
        {
            // Get original color
            var color = mat.color;
            // Add to original list
            originalColors.Add(color);

            // Get fadeout color (alpha 0)
            var fadeoutColor = new Color(color.r, color.g, color.b, 0);

            // Add to fadeout list
            fadeoutColors.Add(fadeOutColor);
    } 
}

// Call this to start fading
public void StartFadeout()
{
    StartCoroutine(FadeOut());
}

private IEnumerator FadeOut()
{
    var timePassed = 0;

    while(timePassed < fadingDuration)
    {
        // Get factor between 0 and 1 depending on passed time
        var lerpFactor = timePassed / fadingDuration;

        // Run through all renderers
        int colorIndex = 0;
        foreach(var rend in renderers)
        {
            // Run through all materials
            foreach (vat mat in rend.materials)
            {
                // Set color interpolated between original and FadeOut color depending on lerpFactor
                mat.color = Color.Lerp(originalColors[colorIndex], fadeOutColors[colorIndex], lerpFactor);

                // Count up index
                colorIndex++;
            }
        }

        // Add time passed since last frame
        timePassed += Time.deltaTime;

        // return to render the frame and continue from here in the next frame
        yield return null;
    }

    // In the end just to be sure apply the final target values (FadeOut colors)
    // Alternatively you could also deactivate/destroy the object here

    // Run through all materials
    int colorIndex = 0;
    foreach(var rend in renderers)
    {
        // Run through all materials
        foreach (vat mat in rend.materials)
        {
            // Set color to final FadeOut value
            mat.color = fadeOutColors[colorIndex];

            // Count up index
            colorIndex++;
        }
    } 
}

Notez que pour que la transparence fonctionne sur tous vos matériaux, pour utiliser un shader supportant la transparence.

Ce n'est peut-être pas la meilleure solution en termes de performances. D'autant plus que plusieurs Renderers peuvent faire référence au même Material, donc dans l'exemple actuel, il y a peut-être des redondances.

Mais si vous n'avez de toute façon qu'un seul Renderer avec un Material, vous pouvez ajuster un peu le code et sauter toutes les boucles ;)

Comme mentionné dans les réponses précédentes, vous pouvez le faire facilement en manipulant

meshrenderer.material.color = new Color (, x);

Un détail important à ajouter est que le matériau doit être mis en place dans la file d'attente transparente (et prend en charge la transparence). Ceci est réalisé via une liste déroulante dans l'inspecteur de matériaux, pour les shaders de surface standard, mais doit être traité dans les shaders personnalisés en utilisant un mode de fusion alpha moins et une file d'attente transparente dans les shaders personnalisés

Balises {"Queue" = "Transparent" "RenderType" = "Transparent"}

Mélanger SrcAlpha OneMinusSrcAlpha

Voici mon approche utilisant les coroutines.

void Awake()
{
    StartCoroutine(FadeOutMaterial(1f));
}

IEnumerator FadeOutMaterial(float fadeSpeed)
{
    Renderer rend = objectToFade.transform.GetComponent<Renderer>();
    Color matColor = rend.material.color;
    float alphaValue = rend.material.color.a;

    while (rend.material.color.a > 0f)
    {
        alphaValue -= Time.deltaTime / fadeSpeed;
        rend.material.color = new Color(matColor.r, matColor.g, matColor.b, alphaValue);
        yield return null;
    }
    rend.material.color = new Color(matColor.r, matColor.g, matColor.b, 0f);
}