Esto es basura. La idea era hacer un trazo (que graba la informacion) pero que tambien te devuelve un trazo de "menor" resolucion que el trazo completo. Ni hablar que esta re sacado de contexto.

ReductorResolucionDeListaDePuntos.cs

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

public class Cuerda : MonoBehaviour
{
    public bool autoGenerarCuerda = true;
    public Color color = Color.yellow;
    public float distanciaResolucion = 0.5f;
    public float distanciaMaxima = 8f;
    public float distanciaMinima = 0.01f;
    public float diametro = 0.1f;
    List<Vector3> puntos = new List<Vector3>();
    List<Vector3> puntosResolucion = new List<Vector3>();
    float distanciaCubierta = 0;
    float resolucionCalculo = -1;

    bool ConCuerda { get { if (puntos == null) return false; else if (puntos.Count == 0) return false; else return true; } }

    void Start()
    {
        if (autoGenerarCuerda) GenerarCuerda();
    }

    bool DistanciaRelevante(Vector3 v1, Vector3 v2)
    {
        if (distanciaMinima <= 0)
        {
            return v1 != v2;
        }
        else
        {
            v2 -= v1;
            return v2.sqrMagnitude >= distanciaMinima * distanciaMinima;
        }
    }

    void Update()
    {
        if (puntos == null) puntos = new List<Vector3>();

        if (puntos.Count > 0)
        {
            if (DistanciaRelevante(transform.position, puntos[puntos.Count - 1]))
            {
                float distanciaMovimiento = Vector3.Distance(transform.position, puntos[puntos.Count - 1]);
                distanciaCubierta += distanciaMovimiento;

                puntos.Add(transform.position);
                puntosResolucion.Clear();//Cambio relevante, esto hara que recalcule

                int cantEliminar = 0;
                for (int i = 0; i < puntos.Count - 1; i++)
                {
                    float distanciaAqui = Vector3.Distance(puntos[i], puntos[i + 1]);
                    
                    if (distanciaCubierta - distanciaAqui > distanciaMaxima)
                    {
                        distanciaCubierta -= distanciaAqui;
                        cantEliminar++;
                    }
                    else break;
                }
                if (cantEliminar>0)puntos.RemoveRange(0, cantEliminar);
            }
        }
        else
        {
            puntos.Add(transform.position);
            puntosResolucion.Clear();//Cambio relevante, esto hara que recalcule
        }
    }

    List<Vector3> PuntosResolucion(bool forzarCalculo = false)
    {
        if (puntosResolucion == null) puntosResolucion = new List<Vector3>();
        //  //Recalcular si cambia la resolucion, o si lo forzamos
        if (forzarCalculo || resolucionCalculo != distanciaResolucion) puntosResolucion.Clear();

        //  //Recalular solo si tuvo cambio relevante, o si lo forzamos, o cambio la resolucion (ver arriba)
        if (puntosResolucion.Count == 0)
        {
            if (puntos.Count <= 0) return puntosResolucion;
            if (distanciaResolucion <= 0)//Si la distancia resolucion es cero, seria resolucion maxima
            {//Es decir toda la informacion que tengamos
                puntosResolucion.AddRange(puntos);
                return puntosResolucion;
            }
            else
            {
                float metroTotal = 0;
                puntosResolucion.Add(puntos[puntos.Count-1]);
                for (int i = puntos.Count-2; i >= 0 && metroTotal < distanciaMaxima; i--)
                {
                    float distanciaLocal = Vector3.Distance(puntos[i + 1], puntos[i]);
                    float metroSobrante = metroTotal % distanciaResolucion;
                    for (int p = 0; p < (distanciaLocal - metroSobrante) / distanciaResolucion; p++)
                    {
                        bool escape = false;
                        float saltico = metroSobrante + (1 + p) * distanciaResolucion;
                        if (metroTotal + saltico > distanciaMaxima)
                        {
                            saltico = distanciaMaxima - metroTotal;
                            escape = true;
                        }
                        puntosResolucion.Add(Vector3.MoveTowards(puntos[i + 1], puntos[i], saltico));
                        if (escape) break;

                    }
                    metroTotal += distanciaLocal;
                }
            }
        }
        return puntosResolucion;
    }

    [ContextMenu("Generar Cuerda")]
    void GenerarCuerda()
    {
        puntos.Add(transform.position);
        if (distanciaResolucion <= 0)
        {
            puntos.Add(transform.position - transform.forward * distanciaMaxima);
        }
        else
        {
            for (float tempDistanciaRecorrer = distanciaMaxima; tempDistanciaRecorrer >= 0; tempDistanciaRecorrer -= distanciaResolucion)
            {
                puntos.Add(puntos[puntos.Count - 1] - transform.forward * distanciaResolucion);
                distanciaCubierta += distanciaResolucion;
            }
        }
        puntos.Reverse();
    }

    /*[ContextMenu("Generar Cuerda")]
    void GenerarCuerda()
    {
        puntos.Add(transform.position);
        for (float tempDistanciaRecorrer = distanciaMaxima; tempDistanciaRecorrer >= 0; tempDistanciaRecorrer -= distanciaResolucion)
        {
            puntos.Add(puntos[puntos.Count - 1] - transform.forward * distanciaResolucion);
            distanciaCubierta += distanciaResolucion;
        }
        puntos.Reverse();
    }*/

#if UNITY_EDITOR
    void OnDrawGizmosSelected()
    {
        if (ConCuerda)
        {
            Color invCol = Color.LerpUnclamped(color, Color.gray, 2);
            Gizmos.color = invCol;
            Gizmos.DrawCube(puntos[0], Vector3.one * diametro);
            UnityEditor.Handles.color = invCol;
            UnityEditor.Handles.Label(puntos[0] - Vector3.up * diametro, "0");
            for (int i = 1; i < puntos.Count; i++)
            {
                Gizmos.DrawCube(puntos[i], Vector3.one * diametro);
                UnityEditor.Handles.Label(puntos[i] - Vector3.up * diametro, i.ToString());
            }

            PuntosResolucion();
            Gizmos.DrawCube(puntosResolucion[0], Vector3.one * diametro);
            for (int i = 1; i < puntosResolucion.Count; i++)
            {
                Gizmos.color = Color.Lerp(color, Color.Lerp(color, Color.black, 0.25f), i / (float)puntosResolucion.Count);
                Gizmos.DrawLine(puntosResolucion[i - 1], puntosResolucion[i]);
                Gizmos.DrawCube(puntosResolucion[i], Vector3.one * diametro);
            }
        }
    }
#endif
}