Dominando Lerp: Interpolación Lineal en Unity

En el mundo del desarrollo de videojuegos, a menudo nos encontramos con la necesidad de realizar transiciones suaves y fluidas. Ya sea mover un objeto de un punto A a un punto B, cambiar el color de un material gradualmente o ajustar el volumen del sonido, la clave para un resultado pulido y profesional radica en la transición. Aquí es donde entra en juego una herramienta matemática increíblemente poderosa y versátil: la interpolación lineal, comúnmente conocida por su abreviatura, Lerp.

Entender y dominar la función Lerp te abrirá un abanico de posibilidades para mejorar la experiencia de usuario en tus juegos, haciendo que las animaciones y cambios de estado se sientan naturales y orgánicos. En esta guía completa, desglosaremos qué es exactamente Lerp, cómo funciona en Unity a través de sus diferentes implementaciones y te mostraremos ejemplos prácticos para que puedas aplicarlo en tus propios proyectos desde hoy mismo.

¿Qué es Exactamente la Interpolación Lineal (Lerp)?

En su esencia, la interpolación lineal es un método para encontrar un valor que se encuentra en un punto intermedio entre otros dos valores. Imagina una línea recta que conecta un punto A con un punto B. Lerp te permite encontrar cualquier punto en esa línea. Para ello, utiliza una fórmula simple que depende de tres componentes:

• Valor Inicial (A): El punto de partida de nuestra interpolación.
• Valor Final (B): El punto de destino al que queremos llegar.
• Factor de Interpolación (t): Un valor, generalmente entre 0 y 1, que representa el porcentaje del camino que hemos recorrido desde A hacia B.

La fórmula matemática es la siguiente: Resultado = A + (B - A) * t.

Veámoslo con el ejemplo más sencillo posible. Queremos interpolar entre los números 3 (nuestro valor A) y 5 (nuestro valor B) en un 50%. Nuestro factor 't' sería 0.5. Aplicando la fórmula:

Resultado = 3 + (5 - 3) * 0.5 = 3 + 2 * 0.5 = 3 + 1 = 4

El resultado es 4, que es exactamente el punto medio entre 3 y 5. Si 't' fuera 0, el resultado sería 3 (el valor inicial). Si 't' fuera 1, el resultado sería 5 (el valor final). Si 't' fuera 0.25, estaríamos a un 25% del camino, obteniendo 3.5.

Lerp en Acción: Las Funciones de Unity

Unity, consciente de la utilidad de esta herramienta, nos proporciona varias funciones Lerp integradas para diferentes tipos de datos. Todas siguen la misma lógica, pero se aplican a contextos distintos.

Mathf.Lerp: Para Valores Numéricos (float)

Esta es la forma más básica de Lerp en Unity, utilizada para interpolar entre dos números de punto flotante (floats). Es ideal para cualquier propiedad que se represente con un solo número: la intensidad de una luz, el volumen de un sonido, la vida de un personaje, etc.

Su sintaxis es: Mathf.Lerp(float a, float b, float t);

Por ejemplo, si quieres calcular el 75% del camino entre 10 y 50:

float valorInicial = 10f; float valorFinal = 50f; float factor = 0.75f; float resultado = Mathf.Lerp(valorInicial, valorFinal, factor); // resultado será 40

Vector3.Lerp: Para Posiciones y Vectores

Probablemente una de las funciones Lerp más utilizadas. Sirve para interpolar entre dos vectores tridimensionales. Su uso principal es para mover o rotar objetos de manera suave en el espacio 3D. La función no hace más que aplicar un Mathf.Lerp a cada uno de los componentes del vector (X, Y y Z) de forma independiente.

Su sintaxis es: Vector3.Lerp(Vector3 a, Vector3 b, float t);

Imagina que quieres mover una plataforma desde su posición inicial (1, 2, 3) hasta una posición final (5, 6, 7). Si quieres saber dónde debería estar cuando ha recorrido el 75% del trayecto, harías lo siguiente:

Vector3 posInicial = new Vector3(1f, 2f, 3f); Vector3 posFinal = new Vector3(5f, 6f, 7f); float factor = 0.75f; Vector3 posicionIntermedia = Vector3.Lerp(posInicial, posFinal, factor); // El resultado será (4, 5, 6)

Color.Lerp: Para Mezclar Colores

De forma similar a Vector3.Lerp, esta función interpola entre dos colores. Un color en Unity se representa por cuatro componentes: Rojo, Verde, Azul y Alfa (transparencia). Color.Lerp aplica la interpolación a cada uno de estos cuatro canales, permitiéndote crear transiciones de color perfectas.

Su sintaxis es: Color.Lerp(Color a, Color b, float t);

¿Quieres crear un color que sea exactamente la mezcla entre rojo puro y azul puro? Esto te dará un púrpura.

Color colorInicial = Color.red; // (1, 0, 0, 1) Color colorFinal = Color.blue; // (0, 0, 1, 1) float factor = 0.5f; Color colorMezcla = Color.Lerp(colorInicial, colorFinal, factor); // El resultado será un púrpura (0.5, 0, 0.5, 1)

Esto es extremadamente útil para efectos de feedback visual, como hacer que un personaje parpadee en rojo al recibir daño o que el cielo cambie de color durante el atardecer.

Un Uso Avanzado: Suavizado de Valores (Smoothing)

Una de las aplicaciones más interesantes y a veces confusas de Lerp es el suavizado de valores a lo largo del tiempo. Esto se logra llamando a Lerp repetidamente dentro del método Update(), usando el valor actual como punto de partida.

Considera este código para que la intensidad de una luz alcance un valor de 8:

public Light miLuz; void Update() { miLuz.intensity = Mathf.Lerp(miLuz.intensity, 8f, 0.5f); }

Aquí ocurre algo curioso. Si la intensidad empieza en 0, en el primer frame se moverá a 4 (50% del camino a 8). En el siguiente frame, el punto de partida ya no es 0, sino 4. El nuevo cálculo será Mathf.Lerp(4, 8, 0.5), que da 6. En el siguiente, será Mathf.Lerp(6, 8, 0.5), que da 7. Y así sucesivamente. El valor se acerca cada vez más a 8, pero el incremento es cada vez más pequeño. Esto crea un efecto de desaceleración (ease-out) muy agradable.

Sin embargo, este código tiene un problema: su velocidad depende del frame-rate. Un jugador con un PC potente y 120 FPS verá la transición mucho más rápido que alguien con 30 FPS. Para solucionar esto, debemos independizar el cálculo del tiempo. Aquí es donde entra Time.deltaTime, que representa el tiempo transcurrido desde el último frame.

public Light miLuz; void Update() { float factorSuavizado = 3f; // Ajusta este valor para cambiar la velocidad miLuz.intensity = Mathf.Lerp(miLuz.intensity, 8f, factorSuavizado * Time.deltaTime); }

Al multiplicar nuestro factor de interpolación por Time.deltaTime, nos aseguramos de que el cambio sea consistente por segundo, no por frame. Esta es una técnica fundamental que debes aplicar siempre que realices un suavizado continuo en Update().

Lerp vs. SmoothDamp: ¿Cuál Debería Usar?

Unity ofrece otra función para suavizado llamada SmoothDamp. Aunque ambas pueden lograr resultados similares, están diseñadas para propósitos diferentes. Lerp es más simple, mientras que SmoothDamp ofrece más control.

Tabla Comparativa

En resumen: usa Lerp para efectos visuales y transiciones sencillas. Usa SmoothDamp cuando necesites un control más riguroso sobre el movimiento, como en el seguimiento de un personaje con la cámara.

Preguntas Frecuentes (FAQ) sobre Lerp

¿Qué pasa si el valor 't' es mayor que 1 o menor que 0?

La función Lerp estándar extrapolará. Es decir, si pides el 150% del camino (t = 1.5) entre 0 y 10, te devolverá 15. Si necesitas que el valor 't' se mantenga siempre entre 0 y 1, puedes usar la función Mathf.LerpUnclamped para la extrapolación o asegurarte de que tu valor 't' esté siempre en ese rango, por ejemplo, usando Mathf.Clamp01(t).

En el suavizado con Update, ¿el valor llega alguna vez al objetivo?

Matemáticamente, no. Siempre se acerca un porcentaje de la distancia restante, por lo que la distancia nunca llega a ser cero. En la práctica, debido a la precisión limitada de los números de punto flotante, eventualmente el valor será tan cercano al objetivo que se considerará igual.

¿Es Lerp una operación costosa para el rendimiento?

No, en absoluto. La interpolación lineal es una de las operaciones matemáticas más rápidas y eficientes que puedes realizar. Es perfectamente seguro y recomendable usarla en cada frame dentro del método Update() sin preocuparte por el impacto en el rendimiento.