Question

我有一个必须消失一些GameObjects的函数，此刻我使用SetActive（false），但它不应立即消失，它应在2或3秒钟内缓慢消失。我想不透明应该慢慢变成透明或类似的东西...

public void SlotCheck(string gemColor,GameObject slotColor,GameObject 
puzzleStuk,ref int scoreGem,ref bool Visibility)
{
if (DragHandler2.itemBegingDragged.name.Contains(gemColor)
DragHandler2.itemBegingDragged.transform.parent.name == "green_small_b")
     {
         Visibility=false;
         puzzleStuk.SetActive(Visibility);
         slotColor.SetActive(false);
         DragHandler2.itemBegingDragged.SetActive(false);
         scoreGem--;
     }

 }

Answer 1

您可以获取GameObject的Renderer组件，然后在Update()中逐渐更改颜色的alpha。

例如：

Renderer renderer;

void Start() {
    renderer  = GetComponent<Renderer>();
}

void Update() {
    Color oldCol = renderer.material.color;
    Color newCol = new Color(oldCol.r, oldCol.g, oldCol.b, oldCol.a - 0.01f);
    renderer.material.color = newCol;
}

当然，您不应使用像0.01f这样的硬编码值，而应使用检查器中的值。还应将其乘以Time.deltaTime，以使衰落速度不基于FPS。

在此示例中，某些名称之类的名称可能不是100％正确，但应该让您了解Unity API documentation的哪一部分。

Answer 2

您可以结合使用Coroutine和Color.Lerp来降低所有材质随时间变化的alpha值。

（我假设您是指与Renderer进行网格划分，而不是与UI无关，但这也将以类似方式起作用）

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

请注意，要使透明度在所有材质上均有效，必须使用支持透明度的着色器。

但是，这可能不是关于性能的最佳解决方案。尤其是由于多个渲染器可能引用相同的材质，因此在当前示例中可能会有一些冗余。

但是如果您只有一个带有一种材质的渲染器，则可以稍微调整一下代码并跳过所有循环；）

Answer 3

如之前的回答所述，您可以轻松地进行操作

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

要添加的一个重要细节是，需要在透明队列中设置材料（并支持透明）。对于标准表面着色器，这是通过在材质检查器中的下拉菜单实现的，但必须在自定义着色器中使用减号alpha混合模式和自定义着色器中的透明队列来处理

Tags {"Queue"="Transparent" "RenderType"="Transparent" }

Blend SrcAlpha OneMinusSrcAlpha

Answer 4

这是我使用协程的方法。

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

如何逐渐淡出/消失GameObject？

4 个答案: