Текущий уровень LOD - LOD Group Unity

У меня проблемы с ведением в LOD Group, потому что я хочу знать, какой текущий активный уровень LOD я вижу на экране. Я только могу получить доступ к проценту с

GameObject.GetComponent<LODGroup>().GetLODs()[size].screenRelativeTransitionHeight;

Кто-то знает, как это решить? Заранее спасибо.

Источник

5 ответов

Решение

Просматривая ответы answer.unity3d.com, я пришел к этому: http://answers.unity3d.com/questions/684467/find-the-lod-step-which-is-currently-used.html

 LODGroup lodGroup = obj.GetComponent<LODGroup>();
 if (lodGroup != null)
 {
     Transform lodTransform = lodGroup.transform;
     foreach (Transform child in lodTransform)
     {
         var renderer = child.GetComponent<Renderer> ();
         if (renderer != null && renderer.isVisible)
         { 
             Debug.Log("This LODlevel is used: " + child.name); 
         }
     }
 }

Вы можете узнать, какой уровень LOD в данный момент активен, посмотрев на имена дочерних рендеров GameObjects, которые в данный момент видны (видимы на экране).

Источник

У меня была та же проблема, и, наконец, я нашел решение, которое действительно работает. (К сожалению, renderer.isVisible не обновляется достаточно часто, чтобы быть надёжным, и я не хотел добавлять дополнительные компоненты для всех подобъектов LOD.)

Я загрузил решение здесь: https://github.com/JulienHeijmans/EditorScripts/blob/master/Scripts/Utility/Editor/LODExtendedUtility.cs

Это в основном код, который я взял отсюда: https://github.com/Unity-Technologies/AutoLOD/blob/master/Scripts/Extensions/LODGroupExtensions.cs Я просто обнаружил, что не нужно, и добавил другие вспомогательные функции, которые я пришлось использовать часто.

Он был сделан для использования в качестве служебного скрипта в редакторе, но здесь есть математика для получения видимого уровня LOD.

Источник

Оптимизированный ответ от @maros:

      static public int GetCurrentLODIndex(LODGroup lodGroup)
{
    LOD[] lods = lodGroup.GetLODs();
    for (int i = 0; i < lods.Length; i++)
    {
        LOD lod = lods[i];
        if (lod.renderers.Length > 0 && lod.renderers[0].isVisible)
            return i;
    }
    return -1;
}

Но он не подойдет, если вам нужно использовать один и тот же рендер в разных LOD. Например, я использую рендерер vfx в LOD0 и LOD1, для LOD1 vfx приостановлен. Поэтому использовал следующий код, основанный на ответе @JulienH:

      using UnityEngine;

public class LODUtils
{
/// <summary>
/// Returns the currently visible LOD level of a specific LODGroup, from a specific camera.
/// </summary>
public static int GetCurrentLODIndex(LODGroup lodGroup, Camera camera)
{
    var lods = lodGroup.GetLODs();
    var relativeHeight = GetRelativeHeight(lodGroup, camera);

    int lodIndex = GetMaxLOD(lodGroup);
    for (var i = 0; i < lods.Length; i++)
    {
        var lod = lods[i];

        if (relativeHeight >= lod.screenRelativeTransitionHeight)
        {
            lodIndex = i;
            break;
        }
    }

    return lodIndex;
}

private static float GetRelativeHeight(LODGroup lodGroup, Camera camera)
{
    var distance = (lodGroup.transform.TransformPoint(lodGroup.localReferencePoint) - camera.transform.position).magnitude;
    return DistanceToRelativeHeight(camera, (distance / QualitySettings.lodBias), GetWorldSpaceSize(lodGroup));
}

private static float DistanceToRelativeHeight(Camera camera, float distance, float size)
{
    if (camera.orthographic)
        return size * 0.5F / camera.orthographicSize;

    var halfAngle = Mathf.Tan(Mathf.Deg2Rad * camera.fieldOfView * 0.5F);
    var relativeHeight = size * 0.5F / (distance * halfAngle);
    return relativeHeight;
}

private static int GetMaxLOD(LODGroup lodGroup)
{
    return lodGroup.lodCount - 1;
}

private static float GetWorldSpaceSize(LODGroup lodGroup)
{
    return GetWorldSpaceScale(lodGroup.transform) * lodGroup.size;
}

private static float GetWorldSpaceScale(Transform t)
{
    var scale = t.lossyScale;
    float largestAxis = Mathf.Abs(scale.x);
    largestAxis = Mathf.Max(largestAxis, Mathf.Abs(scale.y));
    largestAxis = Mathf.Max(largestAxis, Mathf.Abs(scale.z));
    return largestAxis;
}
}
Источник 
      private static int GetLODCurShowLevel(Camera cam, LODGroup lodGroup)
{
    var inv_SceneViewCamHeight = 1.0f / (cam.pixelHeight - 6.0f);

    var lods = lodGroup.GetLODs();
    for (int lodIDX = 0; lodIDX < lods.Length; lodIDX++)
    {
        var lod = lods[lodIDX];
        var renderers = lod.renderers;
        for (int renderIDX = 0; renderIDX < renderers.Length; renderIDX++)
        {
            var renderer = renderers[renderIDX];
            var heightInScreen = cam.WorldToScreenPoint(renderer.bounds.min).y - cam.WorldToScreenPoint(renderer.bounds.max).y;
            var ratioInScren = heightInScreen * inv_SceneViewCamHeight;
            if (ratioInScren > lod.screenRelativeTransitionHeight)
            {
                return lodIDX;
            }
        }
    }

    return -1;
}
Источник 
      public class TestingStoreLODGroupCurLODLevel : MonoBehaviour
{
    public bool[] lodVisibleArr;
    public int GetCurLOD()
    {
        if (lodVisibleArr != null)
        {
            var len = lodVisibleArr.Length;
            for (int i = 0; i < len; i++)
            {
                if (lodVisibleArr[i])
                {
                    return i;
                }
            }
        }
        return -1;
    }
}

public class TestingCheckVisibleChanged : MonoBehaviour
{
    public int belongLOD;
    public TestingStoreLODGroupCurLODLevel storeLOD;
    private void OnBecameInvisible()
    {
        if (storeLOD)
        {
            storeLOD.lodVisibleArr[belongLOD] = false;
        }
    }

    private void OnBecameVisible()
    {
        if (storeLOD)
        {
            storeLOD.lodVisibleArr[belongLOD] = true;
        }
    }
}

    private void SetupCheckLODInfo(GameObject go)
    {
        var lodGroup = go.GetComponent<LODGroup>();
        if (lodGroup == null)
        {
            return;
        }

        var storeLODComp = go.GetComponent<TestingStoreLODGroupCurLODLevel>();
        if (storeLODComp != null)
        {
            return;
        }

        storeLODComp = go.AddComponent<TestingStoreLODGroupCurLODLevel>();
        var lods = lodGroup.GetLODs();
        for (int lodIDX = 0; lodIDX < lods.Length; lodIDX++)
        {
            var lod = lods[lodIDX];
            var renderers = lod.renderers;
            for (int rendererIDX = 0; rendererIDX < renderers.Length; rendererIDX++)
            {
                var renderer = renderers[rendererIDX];
                var checkVisibleComp = renderer.gameObject.GetComponent<TestingCheckVisibleChanged>();
                if (checkVisibleComp == null)
                {
                    checkVisibleComp = renderer.gameObject.AddComponent<TestingCheckVisibleChanged>();
                }
                checkVisibleComp.belongLOD = lodIDX;
                checkVisibleComp.storeLOD = storeLODComp;
            }
        }

        storeLODComp.lodVisibleArr = new bool[lods.Length]; 
    }

    private void UnSetupCheckLODInfo(GameObject go)
    {
        var lodGroup = go.GetComponent<LODGroup>();
        if (lodGroup == null)
        {
            return;
        }
        var storeLODComp = go.GetComponent<TestingStoreLODGroupCurLODLevel>();
        if (storeLODComp != null)
        {
            GameObject.Destroy(storeLODComp);
        }

        var lods = lodGroup.GetLODs();
        for (int lodIDX = 0; lodIDX < lods.Length; lodIDX++)
        {
            var lod = lods[lodIDX];
            var renderers = lod.renderers;
            for (int rendererIDX = 0; rendererIDX < renderers.Length; rendererIDX++)
            {
                var renderer = renderers[rendererIDX];
                var checkVisibleComp = renderer.gameObject.GetComponent<TestingCheckVisibleChanged>();
                if (checkVisibleComp != null)
                {
                    GameObject.Destroy(checkVisibleComp);
                }
            }
        }
    }
Источник
Другие вопросы по тегам