Carga de trama de unidad

Tabla de contenido

teoría

parte del código

Demostración de efectos

---

teoría

La carga cuadro por cuadro (también conocida como carga progresiva) en Unity es una técnica de optimización que mejora el rendimiento del juego y la experiencia del usuario al dividir los recursos en pequeños fragmentos y cargarlos cuadro por cuadro. Estas son algunas de las ventajas de la carga enmarcada:

1. Mejora la velocidad de carga del juego: la carga de activos en pequeñas porciones puede reducir los tiempos de carga porque solo se carga la parte de los activos necesarios para el cuadro actual. Esto es especialmente útil para juegos más grandes o escenas que requieren muchos recursos, ya que reduce los tiempos de carga iniciales y hace que los jugadores ingresen al juego más rápido.

2. Huella de memoria reducida: la carga de recursos en marcos puede reducir la huella de memoria requerida para cada marco. Cuando solo se cargan los recursos requeridos por el marco actual, es posible evitar cargar todos los recursos en la memoria al mismo tiempo, lo que reduce el consumo de memoria. Esto es muy importante para dispositivos con memoria limitada o para juegos grandes.

3. Mejore la fluidez del juego: al cargar por cuadro, puede evitar el tartamudeo obvio cuando la velocidad de cuadro cae. En comparación con la carga de todos los recursos a la vez, la carga cuadro por cuadro puede cargar recursos sin problemas en segundo plano y realizar la carga adecuada de acuerdo con la velocidad de la velocidad de cuadro. Esto asegura que el juego seguirá funcionando sin problemas mientras se cargan los recursos.

4. Aumente la conexión perfecta del mundo del juego: la carga cuadro por cuadro puede realizar la conexión perfecta de diferentes escenas o niveles. Cuando se carga una escena o un nivel, el juego puede cargar sin problemas la siguiente escena o nivel, lo que permite a los jugadores sentir la continuidad del mundo del juego.

5. Mejorar la adaptabilidad del juego: al cargar en cuadros, el juego puede adaptarse automáticamente a la estrategia de carga de acuerdo con las condiciones de rendimiento y recursos del dispositivo. Esto significa que el juego puede brindar una buena experiencia de usuario en una variedad de dispositivos, ya sea una PC de gama alta o un dispositivo móvil de gama baja.

En general, la carga cuadro por cuadro de Unity puede mejorar la velocidad de carga del juego, reducir el uso de la memoria, mejorar la fluidez, lograr una conexión perfecta y mejorar la adaptabilidad del juego. Esta es una poderosa técnica de optimización que mejora el rendimiento del juego y la experiencia del usuario.

parte del código

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

public class CilpFPS : MonoBehaviour
{
    //协程id
    private int id;
    //协程字典
    Dictionary<int, Coroutine> dic=new Dictionary<int, Coroutine>();

    public void AddFPS<T>(List<T> list,int num,Action<T> action)
    {
        int name = id++;
        Coroutine coroutine =StartCoroutine(GetFromInfoList(name,list,num,action));
        dic.Add(name, coroutine);
    }
    /// <summary>
    /// 添加分帧
    /// </summary>
    /// <param name="max">分帧加载的总数量<</param>
    /// <param name="num">一帧调用的帧的数量</param>
    /// <param name="action">具体做什么</param>
    public void AddFPS(int max,int num,Action<int> action)
    {
        int name = id++;
        Coroutine coroutine =StartCoroutine(GetFromInfoList(name,max,num,action));
        dic.Add(name, coroutine);
    }

    /// <summary>
    /// 开始分帧加载
    /// </summary>
    /// <param name="name">协程名称</param>
    /// <param name="max">分帧加载的总数量</param>
    /// <param name="num">一帧调用的帧的数量</param>
    /// <param name="action">具体做什么</param>
    /// <returns></returns>
    IEnumerator GetFromInfoList<T>(int name, List<T> list, int num, Action<T> action)
    {
        int InfoListIndex = 0;
        foreach (T item in list)
        {
            InfoListIndex++;
            action(item);
            if (InfoListIndex % num == 0)
            {
                yield return null; // 在下一帧执行
            }
        }
        StopFPS(name);
    }
    /// <summary>
    /// 开始分帧加载
    /// </summary>
    /// <param name="name">协程名称</param>
    /// <param name="max">分帧加载的总数量</param>
    /// <param name="num">一帧调用的帧的数量</param>
    /// <param name="action">具体做什么</param>
    /// <returns></returns>
    IEnumerator GetFromInfoList(int name, int max, int num, Action<int> action)
    {
        for (int i = 0; i < max; i++)
        {
            action(i);
            if(i% num == 0)
            {
                //每一帧提取5条数据
                Debug.Log("运行时间："+Time.time + "，创建次数：" + (i+1));
                yield return null;  // 在下一帧执行
            }
        }
        StopFPS(name);
    }

    /// <summary>
    /// 移除协程
    /// </summary>
    /// <param name="name"></param>
    private void StopFPS(int name)
    {
        if(dic.ContainsKey(name))
        {
            StopCoroutine(dic[name]);
            dic.Remove(name);
        }
    }
}

código de llamada

using UnityEngine;

public class CreateFps : MonoBehaviour
{
    public GameObject game;
    public CilpFPS cilpFPS;
    void Start()
    {
        cilpFPS.AddFPS(20,1, (i) =>
        {
            GameObject game1=Instantiate(game,transform);
            game1.transform.position=new Vector3(i,0,i);
        });
    }
}

 

 Demostración de efectos