如何淡入/淡出textmesh？ 不工作

Question

At top :

private Vector3 lastFwd;
private float curAngleX = 0;

In Start :

private void Start()
{
    lastFwd = transform.forward;
}

In Update :

void Update()
{
    var curFwd = transform.forward;
    // measure the angle rotated since last frame:
    var ang = Vector3.Angle(curFwd, lastFwd);

    if (myApproximation(ang, 179f, 1f) == true)
    {
        var t = transform.GetChild(0).GetComponent<TextMesh>();
        StartCoroutine(FadeTextToZeroAlpha(1, t));
        t.text = "Hello";
        StartCoroutine(FadeTextToFullAlpha(0, t));
    }
}

The Fade methods :

public IEnumerator FadeTextToFullAlpha(float t, TextMesh i)
{
    i.color = new Color(i.color.r, i.color.g, i.color.b, 0);
    while (i.color.a < 1.0f)
    {
        i.color = new Color(i.color.r, i.color.g, i.color.b, i.color.a + (Time.deltaTime / t));
        yield return null;
    }
}

public IEnumerator FadeTextToZeroAlpha(float t, TextMesh i)
{
    i.color = new Color(i.color.r, i.color.g, i.color.b, 1);
    while (i.color.a > 0.0f)
    {
        i.color = new Color(i.color.r, i.color.g, i.color.b, i.color.a - (Time.deltaTime / t));
        yield return null;
    }
}

What I want to do is to start fading from 1 to 0 while it's 0 to change the t variable text for example :

t.text = "Hello";

And then to fade back from 0 to 1.

But it's not making the fade. If I leave only the line from 1 to 0 it will fade the text. But when the two lines are exist it's not fading at all. The text is the same.

The complete script :

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class OnMouseOverEvent : MonoBehaviour
{
    public float speed = 5f;
    public float distanceToMove = 1f;
    public bool goForward;
    public Vector3 startPos;
    public Vector3 endPos;

    private bool isRotating = false;
    private Vector3 lastFwd;
    private float curAngleX = 0;

    private void Start()
    {
        lastFwd = transform.forward;

        startPos = transform.position;
        endPos = transform.position - Vector3.forward * distanceToMove;
    }

    void Update()
    {
        if (goForward && isRotating == false)
        {
            transform.position = Vector3.MoveTowards(transform.position, endPos, speed * Time.deltaTime);
        }
        else if (isRotating == false)
        {
            transform.position = Vector3.MoveTowards(transform.position, startPos, speed * Time.deltaTime);
        }

        var curFwd = transform.forward;
        // measure the angle rotated since last frame:
        var ang = Vector3.Angle(curFwd, lastFwd);

        if (myApproximation(ang, 179f, 1f) == true)
        {
            var t = transform.GetChild(0).GetComponent<TextMesh>();
            StartCoroutine(FadeTextToZeroAlpha(1, t));
            t.text = "Hello";
            StartCoroutine(FadeTextToFullAlpha(0, t));
        }
    }

    public IEnumerator FadeTextToFullAlpha(float t, TextMesh i)
    {
        i.color = new Color(i.color.r, i.color.g, i.color.b, 0);
        while (i.color.a < 1.0f)
        {
            i.color = new Color(i.color.r, i.color.g, i.color.b, i.color.a + (Time.deltaTime / t));
            yield return null;
        }
    }

    public IEnumerator FadeTextToZeroAlpha(float t, TextMesh i)
    {
        i.color = new Color(i.color.r, i.color.g, i.color.b, 1);
        while (i.color.a > 0.0f)
        {
            i.color = new Color(i.color.r, i.color.g, i.color.b, i.color.a - (Time.deltaTime / t));
            yield return null;
        }
    }

    private bool myApproximation(float a, float b, float tolerance)
    {
        return (Mathf.Abs(a - b) < tolerance);
    }

    private void OnMouseOver()
    {
        goForward = true;
    }

    private void OnMouseExit()
    {
        goForward = false;
    }

    private void OnMouseDown()
    {
        if (isRotating == false && transform.name == "Options")
            StartCoroutine(Rotate(5));
    }

    IEnumerator Rotate(float duration)
    {
        Quaternion startRot = transform.rotation;
        float t = 0.0f;
        while (t < duration)
        {
            isRotating = true;
            t += Time.deltaTime;

            transform.rotation = startRot * Quaternion.AngleAxis(t / duration * 360f, Vector3.up); 

            yield return null;
        }
        transform.rotation = startRot;

        isRotating = false;
    }
}

The main goal is while the object is rotating to fade out/in the text and while fading to change the text.

Answer 1

All these calls

StartCoroutine(FadeTextToZeroAlpha(1, t));
t.text = "Hello";
StartCoroutine(FadeTextToFullAlpha(0, t));

happen at the same time so you have concurrent routines.

Additionally this might be called in multiple consequent frames -> you should also do it only once!

You should pack this into one single routine like

private bool isUpdatingDisplay;

// Get this reference only ONCE
// better would even be if you can already reference it via the Inspector
[SerializeField] privtae TextMesh textMesh;

private void Awake()
{
    if(!textMesh) textMesh = transform.GetChild(0).GetComponent<TextMesh>();
}

void Update()
{

    ....

    // only start fading if it isn't doing it already
    if(!isUpdatingDisplay)
    {
        StartCoroutine(UpdateDisplayPhrase("Hello"), t);
    }

    ....
}

private IEnumerator UpdateDisplayPhrase(string text, TextMesh t)
{
     // this should actually be impossible to happen
     // but just in case ignore this call if a routine is already running
     if(isUpdatingDisplay) yield brake;

     // block multiple calls
     isUpdatingDisplay = true;

     // you can simply yield IEnumerators so they are executed and at the same time
     // wait until finished
     yield return FadeTextToZeroAlpha(1, t);

     t.text = "Hello";

     // NOTE: you pass in 0 
     // -> DIVIDING BY 0 ?!
     yield return FadeTextToFullAlpha(0, t);

     // when done reset the blocking flag
     isUpdatingDisplay = false;
}

public IEnumerator FadeTextToFullAlpha(float t, TextMesh i)
{
    i.color = new Color(i.color.r, i.color.g, i.color.b, 0);
    while (i.color.a < 1.0f)
    {
        // DIVIDING BY 0 ?!
        i.color = new Color(i.color.r, i.color.g, i.color.b, i.color.a + (Time.deltaTime / t));
        yield return null;
    }
}

public IEnumerator FadeTextToZeroAlpha(float t, TextMesh i)
{
    i.color = new Color(i.color.r, i.color.g, i.color.b, 1);
    while (i.color.a > 0.0f)
    {
        i.color = new Color(i.color.r, i.color.g, i.color.b, i.color.a - (Time.deltaTime / t));
        yield return null;
    }
}

---

NOTE

you are calling

FadeTextToFullAlpha(0, t);

but in FadeTextToFullAlpha(float t, TextMesh i) using

Time.deltaTime / t

you should strongly avoid dividing by 0 ;)

---

You could refactor this a bit using only one method and making it more efficient like (also get used to use proper variable names!). I would then use Color.Lerp which allows additional easing-in and -out

public IEnumerator FadeTextTo(float targetAlpha, float maxDuration, TextMesh textMesh)
{
    // more efficient to get both colors beforehand
    var fromColor = textMesh.color;
    var toColor = new Color(fromColor.r, fromColor.g, fromColor.b, targetAlpha);

    // this is optional ofcourse but I like to do this in order to
    // always have the same fading speed even if it is already slightly faded into one direction
    var actualDuration = maxDuration * Mathf.Abs(fromColor.a - toColor.a);

    var passedTime = 0f;
    while (passedTime < actualDuration)
    {
        var lerpFactor = passedTime / actualDuration;
        // now the huge advantage is that you can add ease-in and -out if you like e.g.
        //lerpFactor = Mathf.SmoothStep(0, 1, lerpFactor);

        i.color = Color.Lerp(fromColor, toColor, lerpFactor);

        // avoid overshooting
        passedTime += Mathf.Min(Time.deltaTime, actualDuration - passedTime);
        yield return null;
    }

    // just to be sure in the end always set it once
    i.color = toColor;
}

Now there is also no trouble with 0 division anymore