---
title: "P3D: Iluminación"
---

# Fundamentos

Las luces en un ambiente 3D determinan los colores y la intensidad de color en cada cara de las mallas dibujadas ("rendereadas") en la pantalla.

Processing utiliza el llamado [Modelo de reflexión de Phong](https://es.wikipedia.org/wiki/Modelo_de_reflexi%C3%B3n_de_Phong), en el que se suman los componentes de luz *ambiental*, *difusa*, y *especular*.

![](https://upload.wikimedia.org/wikipedia/commons/6/6b/Phong_components_version_4.png)


Ejemplos sobre la aplicación de iluminación virtual:

[Lighting Artist Realizes People Have No Idea What His Job Means And Gives Some Amazing Examples](https://www.demilked.com/lighting-artist-explains-his-job-dan-o-brien/)

# Tipos de luces

En Processing y en otros ambientes 3D, hay cuatro tipos básicos de luces a colocar en el espacio:

* `ambientLight`
* `pointLight`
* `directionalLight`
* `spotLight`

## ambientLight

Es una luz que colorea desde y hacia todas direcciones

![](/img/ambientLight.png)

Los tres parámetros que recibe son los valores de color (RGB, HSB, dependiendo del modo)

```java
ambientLight( r, g, b);
```

## pointLight

Es una luz que tiene una posición específica x,y,z, y que desde ese punto emite luz en todas direcciones

![](/img/pointLight.png)

Los seis parámetros que recibe son:

* los 3 valores de color
* sus coordenadas x,y,z

```java
pointLight( r, g, b, x, y, z);
```

## directionalLight

Es una luz que tiene una dirección específica que es emitida desde todos los puntos del espacio.

![](/img/directionalLight.png)

Los seis parámetros que recibe son:

* los 3 valores de color
* la magnitud de la dirección en cada eje x,y,z:

```java
directionalLight( r, g, b, dx, dy, dz);
```

## spotLight

Esta luz es combinación de `pointLight` y `directionalLight`: tiene una posición específica, desde la cual emite luz en una dirección específica, con cierto ángulo de apertura y un parámetro de *concentración* de luz en ese centro.

![](/img/spotLight.png)

Los doce parámetros que recibe son

* los 3 valores de color
* coordenadas x,y,z
* dirección dx, dy, dz
* ángulo de apertura del cono (en radianes)
* concentración de luz en el centro del cono (valor entre 1 y 10000)

```java
spotLight( r, g, b, x, y, z, dx, dy, dz, angulo, concentracion);
```

[[Ángulos en radianes]](/notas/angulos.html)

# Consideraciones

Algunos detalles sobre las luces que utilizaremos en Processing 3D:

* Tienen un alcance *infinito* (a menos que las configuremos con `lightFalloff`).
* No tienen una *fuente visible* - si queremos que se vea por ejemplo una lámpara, tenemos que dibujarla aparte.
* No generan sombra ni son obstruidas por superficies en las que se reflejan.

## Suma de luces

El modelo de reflexión de Phong consiste en sumar todas las luces que están incidiendo sobre una superficie y que reflejan hacia la cámara. 

Si, por ejemplo, establecemos una luz ambiental al 100% en todos los canales de color, todas las superficies están complemente iluminadas y las otras luces no tendrán efecto alguno:

```java
ambientLight( 255, 255, 255); // luz ambiental al 100% en r,g,b
```

Si establecemos la luz ambiental blanca al 50%, y una luz direccional blanca también al 50%, entonces veremos lo siguiente:

* Solo las caras perpendiculares a la dirección de la luz estarán completamente iluminadas
* Las caras a las que no les da la luz direccional estarán iluminadas al 50%
* Otras caras tendrán una base del 50% de iluminación, más un componente proporcional respecto a qué ángulo forman con la luz direccional.

```java
ambientLight(128, 128, 128); // luz ambiental blanca al 50%
directionalLight(128, 128, 128, 0, 0, -1); // luz direccional blanca al 50%, con dirección hacia abajo en Z
```

Esas dos luces son las que establece por defecto la función `lights()`.


# Otras configuraciones

## Falloff

La función [lightFalloff](https://processing.org/reference/lightFalloff_.html) configura qué tanto o no decae la luz conforme se aleja de su origen. Útil especialmente para las pointLights y spotLights.

Por defecto, los valores de esta función hacen que la luz no decaiga:

```java
lightFalloff(1, 0, 0);
```

## Materiales

Es posible cambiar el *material* de las mallas, que determina qué tanto o de qué forma reacciona con la luz. Las funciones para configurarlo son:

* [ambient](https://processing.org/reference/ambient_.html)
* [shininess](https://processing.org/reference/shininess_.html)
* [specular](https://processing.org/reference/specular_.html)
* [emissive](https://processing.org/reference/emissive_.html)
