Optimized LookAt Code in Unity

Questions & Answers
1

I have about 2400 objects that are Active in the scene with Textmeshpro Geometry and have code running in the update method, this update method is throughout very expensive in terms of FPS and i want this code to be optimized can anyone please help me with this code.

 void Update ()
{
    GetPlayerAndCamera();
    int layerMask = 1 << 12;

    // This would cast rays only against colliders in layer 8.
    // But instead we want to collide against everything except layer 8. The ~ operator does this, it inverts a bitmask.

    RaycastHit hit;
    // Does the ray intersect any objects excluding the player layer
    if (Physics.Raycast(Camera.main.transform.position, Vector3.down, out hit, Mathf.Infinity, layerMask))
    {

      //  Debug.Log(hit.distance);
        if (hit.distance > 250 )
        {
            foreach (var item in closeTransforms)
            {
                if (item != null)
                {
                    Vector3 lerpval = Vector3.Lerp(item.transform.localScale, Vector3.zero, 1 * Time.deltaTime);
                    item.transform.localScale = lerpval;
                    item.gameObject.SetActive(false);
                }
            }
            foreach (var item in nearTransforms)
            {
                if (item != null)
                {
                    Vector3 lerpval = Vector3.Lerp(item.transform.localScale, Vector3.zero, 1 * Time.deltaTime);
                    item.transform.localScale = lerpval;
                    item.gameObject.SetActive(false);
                }
            }
            foreach (var item in farTransforms)
            {
                if (item != null)
                {
                    item.gameObject.SetActive(true);
                    item.transform.LookAt(item.transform.position + player.transform.rotation * Vector3.forward * 1,
                    player.transform.rotation * Vector3.up + offset);
                    var dist = Vector3.Distance(Camera.main.transform.position, item.transform.position);

                    if (dist > 250 && dist < 1000)
                    {
                        Vector3 lerpval = Vector3.Lerp(item.transform.localScale, scalefor10, 1 * Time.deltaTime);
                        item.transform.localScale = lerpval;

                    }
                    else if (dist > 1000 && dist < 1500)
                    {
                        Vector3 lerpval = Vector3.Lerp(item.transform.localScale, scalefor10, 1 * Time.deltaTime);
                        item.transform.localScale = lerpval;

                    }
                    else if (dist > 1500 && dist < 2000)
                    {
                        Vector3 lerpval = Vector3.Lerp(item.transform.localScale, scalefor10, 1 * Time.deltaTime);
                        item.transform.localScale = lerpval;

                    }
                    else if (dist > 2000)
                    {
                        Vector3 lerpval = Vector3.Lerp(item.transform.localScale, scalefor10, 1 * Time.deltaTime);
                        item.transform.localScale = lerpval;

                    }
                }
            }
        }

        else
        {
            foreach (var item in closeTransforms)
            {
                if (item != null)
                {

                        item.gameObject.SetActive(true);

                    var dist = Vector3.Distance(Camera.main.transform.position, item.transform.position);

                        item.transform.LookAt(item.transform.position + player.transform.rotation * Vector3.forward * 1,
                        player.transform.rotation * Vector3.up + offset);
                    if (dist > 0 /*&& dist < 2000*/)
                    {
                        Vector3 lerpval = Vector3.Lerp(item.transform.localScale, scalefor2, 1 * Time.deltaTime);
                        item.transform.localScale = lerpval;
                    

                    }
                    //else
                    //{
                    //    item.gameObject.SetActive(false);
                       
                    //}

                }
            }
            foreach (var item in farTransforms)
            {
                if (item != null)
                {
                    item.gameObject.SetActive(true);

                    var dist = Vector3.Distance(Camera.main.transform.position, item.transform.position);

                        item.transform.LookAt(item.transform.position + player.transform.rotation * Vector3.forward * 1,
                        player.transform.rotation * Vector3.up + offset);
                    if (dist > 0)
                    {
                        Vector3 lerpval = Vector3.Lerp(item.transform.localScale, Vector3.zero, 1 * Time.deltaTime);
                        item.transform.localScale = lerpval;

                    }

                }
            }
            foreach (var item in nearTransforms)
            {
                if (item != null)
                {

                        item.gameObject.SetActive(true);

                    var dist = Vector3.Distance(Camera.main.transform.position, item.transform.position);
                        item.transform.LookAt(item.transform.position + player.transform.rotation * Vector3.forward * 1,
                        player.transform.rotation * Vector3.up + offset);

                    if (dist > 0/* && dist < 2000*/)
                    {
                        Vector3 lerpval = Vector3.Lerp(item.transform.localScale,scalefor2 , 1 * Time.deltaTime);
                        item.transform.localScale = lerpval;
                        

                    }
                    //else
                    //{

                    //    item.gameObject.SetActive(false);
                       
                    //}
                }
            }
        }
    }
    //transform.LookAt(transform.position + player.transform.rotation * Vector3.forward * 1,
    //      player.transform.rotation * Vector3.up + offset); ////USE THIS IN UPDATE ONLY
}
2

Create a single instance of LookAtCameraSystem and tag every object you want to rotate with LookAtCameraComponent. If you need transforms to rotate toward different points, write a new pair of these two systems. Intention of your code is obfuscated a bit by this long tree of if/else statements, but the general rule is to use TransformAccessArray with IJobParallelForTransform when you need to modify transforms at this scale efficiently.

LookAtCameraSystem.cs

using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Jobs;
using Unity.Mathematics;
using Unity.Entities;
using Unity.Jobs;
using BurstCompile = Unity.Burst.BurstCompileAttribute;
  
[ExecuteAlways]
public class LookAtCameraSystem : MonoBehaviour
{
  
    [SerializeField] Method _method = Method.LookAt;
    static LookAtCameraSystem _instance = null;
    TransformAccessArray _transformsAccess = default(TransformAccessArray);
    public JobHandle Dependency = default(JobHandle);
  
    void Awake ()
    {
        if( _instance==null ) _instance = this;
        else Debug.LogError($"There is more that one instance of {nameof(LookAtCameraSystem)}, this will result in reduced performance and undefined behaviour.",gameObject);
    }
  
    void OnEnable ()
    {
        RenderPipelineManager.beginCameraRendering += OnBeginCameraRendering;
        _transformsAccess = new TransformAccessArray( LookAtCameraComponent.transforms.ToArray() );
    }
  
    void OnDisable ()
    {
        RenderPipelineManager.beginCameraRendering -= OnBeginCameraRendering;
        Dependency.Complete();
        if( _transformsAccess.isCreated ) _transformsAccess.Dispose();
    }
  
    void OnBeginCameraRendering ( ScriptableRenderContext context , Camera camera )
    {
        Dependency.Complete();
  
        _transformsAccess.Dispose();
        _transformsAccess = new TransformAccessArray( LookAtCameraComponent.transforms.ToArray() );
  
        Transform cameraTransform = camera.transform;
        if( _method==Method.LookAt )
        {
            var job = new LookAtPointJob{
                point = cameraTransform.position ,
                up = cameraTransform.up
            };
            Dependency = job.Schedule( _transformsAccess );
        }
        else if( _method==Method.Align )
        {
            var rot = Quaternion.LookRotation( forward:-camera.transform.forward , upwards:-camera.transform.up );
            var job = new SetRotationJob{
                rotation = rot
            };
            Dependency = job.Schedule( _transformsAccess );
        }
    }
  
    public enum Method { LookAt = 0 , Align = 1 }
  
}
  
[BurstCompile]
public struct LookAtPointJob : IJobParallelForTransform
{
    public float3 point, up;
    void IJobParallelForTransform.Execute ( int index , TransformAccess transform )
        => transform.rotation = quaternion.LookRotation( point-(float3)transform.position , up );
}
  
[BurstCompile]
public struct SetRotationJob : IJobParallelForTransform
{
    public Quaternion rotation;
    void IJobParallelForTransform.Execute ( int index , TransformAccess transform )
        => transform.rotation = rotation;
}

LookAtCameraComponent.cs

using System.Collections.Generic;
using UnityEngine;
  
[ExecuteAlways]
public class LookAtCameraComponent : MonoBehaviour
{
    public static List<Transform> transforms = new List<Transform>();
    void OnEnable () => transforms.Add(transform);
    void OnDisable () => transforms.Remove(transform);
}