# Renderizado con Blender

Renderiza escenas 3D y animaciones usando Blender en GPUs de CLORE.AI.

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Alquilar en CLORE.AI

1. Visita [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Filtrar por tipo de GPU, VRAM y precio
3. Elegir **Bajo demanda** (tarifa fija) o **Spot** (precio de puja)
4. Configura tu pedido:
   * Selecciona imagen Docker
   * Establece puertos (TCP para SSH, HTTP para interfaces web)
   * Agrega variables de entorno si es necesario
   * Introduce el comando de inicio
5. Selecciona pago: **CLORE**, **BTC**, o **USDT/USDC**
6. Crea el pedido y espera el despliegue

### Accede a tu servidor

* Encuentra los detalles de conexión en **Mis Pedidos**
* Interfaces web: Usa la URL del puerto HTTP
* SSH: `ssh -p <port> root@<proxy-address>`

## ¿Por qué alquilar GPUs para Blender?

* Renderiza escenas complejas 10-50x más rápido que la CPU
* Múltiples GPUs para renderizado aún más rápido
* No es necesario invertir en hardware caro
* Paga solo por el tiempo de renderizado

## Requisitos

| Complejidad de la escena | GPU recomendada | VRAM    |
| ------------------------ | --------------- | ------- |
| Simple                   | RTX 3070        | 8GB     |
| Medio                    | RTX 3090        | 24GB    |
| Complejo                 | RTX 4090        | 24GB    |
| Producción               | A100            | 40-80GB |

## Despliegue rápido

**Imagen Docker:**

```
linuxserver/blender
```

O renderizado sin interfaz (headless):

```
nytimes/blender:3.6-gpu-ubuntu22.04
```

**Puertos:**

```
22/tcp
3000/http
```

## Configuración de renderizado sin interfaz

**Imagen:**

```
nvidia/cuda:12.1.0-devel-ubuntu22.04
```

**Comando:**

```bash
apt-get update && \
apt-get install -y wget libxi6 libxxf86vm1 libxfixes3 libxrender1 libgl1 && \
wget https://download.blender.org/release/Blender4.0/blender-4.0.2-linux-x64.tar.xz && \
tar -xf blender-4.0.2-linux-x64.tar.xz && \
mv blender-4.0.2-linux-x64 /opt/blender
```

## Accediendo a tu servicio

Después del despliegue, encuentra tu `http_pub` URL en **Mis Pedidos**:

1. Ir a **Mis Pedidos** página
2. Haz clic en tu pedido
3. Encuentra la `http_pub` URL (por ejemplo, `abc123.clorecloud.net`)

Usa `https://TU_HTTP_PUB_URL` en lugar de `localhost` en los ejemplos abajo.

## Sube tu proyecto

### Vía SCP

```bash

# Subir archivo .blend
scp -P <port> myproject.blend root@<proxy>:/workspace/

# Subir carpeta del proyecto
scp -P <port> -r ./project/ root@<proxy>:/workspace/
```

### Vía rsync (proyectos grandes)

```bash
rsync -avz --progress -e "ssh -p <port>" ./project/ root@<proxy>:/workspace/project/
```

## Comandos de renderizado

### Fotograma único

```bash
/opt/blender/blender -b /workspace/myproject.blend -o /workspace/output/frame_### -f 1 -- --cycles-device CUDA
```

### Animación (rango de fotogramas)

```bash
/opt/blender/blender -b /workspace/myproject.blend -o /workspace/output/frame_### -s 1 -e 250 -a -- --cycles-device CUDA
```

### Fotogramas específicos

```bash
/opt/blender/blender -b /workspace/myproject.blend -o /workspace/output/frame_### -f 1,50,100,150,200 -- --cycles-device CUDA
```

## Opciones de renderizado

### Resolución

```bash

# Sobrescribir resolución
blender -b file.blend -o //output/frame_### -x 1920 -y 1080 -a -- --cycles-device CUDA
```

### Usar script de Python

```bash
blender -b file.blend --python render_setup.py -a
```

**render\_setup.py:**

```python
import bpy

# Establecer motor de renderizado
bpy.context.scene.render.engine = 'CYCLES'

# Establecer dispositivo
bpy.context.preferences.addons['cycles'].preferences.compute_device_type = 'CUDA'

# Habilitar todas las GPUs
for device in bpy.context.preferences.addons['cycles'].preferences.devices:
    device.use = True

# Establecer muestras
bpy.context.scene.cycles.samples = 128

# Establecer resolución
bpy.context.scene.render.resolution_x = 1920
bpy.context.scene.render.resolution_y = 1080

# Configuración de salida
bpy.context.scene.render.image_settings.file_format = 'PNG'
```

## Renderizado multi-GPU

Para servidores con múltiples GPUs:

```python
import bpy

# Habilitar CUDA
prefs = bpy.context.preferences.addons['cycles'].preferences
prefs.compute_device_type = 'CUDA'

# Actualizar dispositivos
prefs.get_devices()

# Habilitar todas las GPUs
for device in prefs.devices:
    if device.type == 'CUDA':
        device.use = True
        print(f"Enabled: {device.name}")
```

## Estilo granja de render (múltiples servidores)

Alquila múltiples servidores y divide los fotogramas:

**Servidor 1:**

```bash
blender -b project.blend -o //output/frame_### -s 1 -e 100 -a
```

**Servidor 2:**

```bash
blender -b project.blend -o //output/frame_### -s 101 -e 200 -a
```

**Servidor 3:**

```bash
blender -b project.blend -o //output/frame_### -s 201 -e 300 -a
```

Luego combina los renders localmente.

## Renderizado con Eevee (más rápido)

Para calidad en tiempo real:

```bash
blender -b file.blend -E BLENDER_EEVEE -o //output/frame_### -a
```

## Soporte OptiX (GPUs RTX)

Para trazado de rayos en RTX:

```python
import bpy
prefs = bpy.context.preferences.addons['cycles'].preferences
prefs.compute_device_type = 'OPTIX'  # En lugar de CUDA
```

## Script de renderizado automatizado

**render.sh:**

```bash
#!/bin/bash
BLEND_FILE=$1
START_FRAME=$2
END_FRAME=$3
OUTPUT_DIR=/workspace/output

mkdir -p $OUTPUT_DIR

/opt/blender/blender -b $BLEND_FILE \
    -o ${OUTPUT_DIR}/frame_### \
    -s $START_FRAME \
    -e $END_FRAME \
    -a \
    -- --cycles-device CUDA

echo "¡Renderizado completo!"
ls -la $OUTPUT_DIR
```

Uso:

```bash
chmod +x render.sh
./render.sh /workspace/myproject.blend 1 250
```

## Monitoreo del progreso de renderizado

### Vigila la carpeta de salida

```bash
watch -n 5 'ls -la /workspace/output/ | tail -20'
```

### Salida de Blender

Blender imprime el progreso de los fotogramas en stdout:

```
Fra:1 Mem:1234.56M (Pico 1500.00M) | Time:00:01.23 | Remaining:04:32.10 | Mem:567.89M, Peak:890.12M | Scene, View Layer | Sample 64/128
```

## Descargar fotogramas renderizados

```bash

# Descargar todos los fotogramas
scp -P <port> -r root@<proxy>:/workspace/output/ ./renders/

# Descargar fotogramas específicos
scp -P <port> root@<proxy>:/workspace/output/frame_001.png ./

# Sincronizar con rsync
rsync -avz --progress -e "ssh -p <port>" root@<proxy>:/workspace/output/ ./renders/
```

## Codificación de video

Después de renderizar los fotogramas, codifica a video:

```bash

# Instalar ffmpeg
apt-get install -y ffmpeg

# Codificar a MP4
ffmpeg -framerate 24 -i /workspace/output/frame_%03d.png -c:v libx264 -pix_fmt yuv420p output.mp4

# Codificar a ProRes (alta calidad)
ffmpeg -framerate 24 -i /workspace/output/frame_%03d.png -c:v prores_ks -profile:v 3 output.mov
```

## Consejos de rendimiento

### Optimizar para velocidad

```python

# Reducir muestras para vista previa
bpy.context.scene.cycles.samples = 64

# Usar muestreo adaptativo
bpy.context.scene.cycles.use_adaptive_sampling = True
bpy.context.scene.cycles.adaptive_threshold = 0.01

# Limitar rebotes
bpy.context.scene.cycles.max_bounces = 8
```

### Optimización de memoria

```python

# Usar renderizado por tiles para alta resolución
bpy.context.scene.render.use_persistent_data = True

# Establecer tamaño de tile
bpy.context.scene.cycles.tile_size = 256  # Para GPU
```

## Estimaciones de tiempo de renderizado

| Escena     | GPU      | Resolución | Muestras | Tiempo/Frame |
| ---------- | -------- | ---------- | -------- | ------------ |
| Simple     | RTX 3090 | 1080p      | 128      | \~30s        |
| Medio      | RTX 3090 | 1080p      | 256      | \~2min       |
| Complejo   | RTX 4090 | 4K         | 512      | \~10min      |
| Producción | A100     | 4K         | 1024     | \~20min      |

## Cálculo de costo

**Ejemplo: animación de 250 fotogramas**

```
GPU: RTX 4090
Tiempo por fotograma: 2 minutos
Tiempo total de renderizado: 500 minutos = 8.3 horas
Tarifa por hora: $0.04
Costo total: ~$0.33
```

## Solución de problemas

### "Dispositivo CUDA no encontrado"

```python

# Verificar dispositivos disponibles
import bpy
prefs = bpy.context.preferences.addons['cycles'].preferences
prefs.compute_device_type = 'CUDA'
prefs.get_devices()
for d in prefs.devices:
    print(d.name, d.type)
```

{% hint style="danger" %}
**Fuera de memoria**
{% endhint %}

* Reducir la resolución de las texturas
* Usar tamaño de tile más pequeño
* Habilitar "persistent data"
* Usar shaders más simples

### Renderizado lento

* Verificar que la GPU esté siendo usada (nvidia-smi)
* Optimizar la geometría de la escena
* Usar denoising con menos muestras

## Próximos pasos

* Ejecutar Jupyter para postprocesado
* [Generación de video AI](https://docs.clore.ai/guides/guides_v2-es/generacion-de-video/ai-video-generation)