# Рендеринг в Blender

Рендерьте 3D-сцены и анимации в Blender на GPU CLORE.AI.

{% hint style="success" %}
Все примеры можно запускать на GPU-серверах, арендуемых через [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Аренда на CLORE.AI

1. Посетите [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Отфильтруйте по типу GPU, объему VRAM и цене
3. Выберите **On-Demand** (фиксированная ставка) или **Spot** (цена по ставке)
4. Настройте ваш заказ:
   * Выберите Docker-образ
   * Установите порты (TCP для SSH, HTTP для веб-интерфейсов)
   * Добавьте переменные окружения при необходимости
   * Введите команду запуска
5. Выберите способ оплаты: **CLORE**, **BTC**, или **USDT/USDC**
6. Создайте заказ и дождитесь развертывания

### Доступ к вашему серверу

* Найдите данные для подключения в **Моих заказах**
* Веб-интерфейсы: используйте URL HTTP-порта
* SSH: `ssh -p <port> root@<proxy-address>`

## Зачем арендовать GPU для Blender?

* Визуализируйте сложные сцены в 10–50 раз быстрее, чем на CPU
* Несколько GPU для ещё более быстрого рендеринга
* Не нужно инвестировать в дорогое оборудование
* Платите только за время рендеринга

## Требования

| Сложность сцены | Рекомендуемый GPU | VRAM     |
| --------------- | ----------------- | -------- |
| Простая         | RTX 3070          | 8GB      |
| Средне          | RTX 3090          | 24 ГБ    |
| Сложный         | RTX 4090          | 24 ГБ    |
| Продакшен       | A100              | 40–80 ГБ |

## Быстрое развертывание

**Docker-образ:**

```
linuxserver/blender
```

Или рендер без интерфейса (headless):

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

**Порты:**

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

## Настройка headless-рендера

**Образ:**

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

**Команда:**

```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
```

## Доступ к вашему сервису

После развертывания найдите ваш `http_pub` URL в **Моих заказах**:

1. Перейдите на **Моих заказах** страницу
2. Нажмите на ваш заказ
3. Найдите `http_pub` URL (например, `abc123.clorecloud.net`)

Используйте `https://YOUR_HTTP_PUB_URL` вместо `localhost` в примерах ниже.

## Загрузите свой проект

### Через SCP

```bash

# Загрузить .blend файл
scp -P <port> myproject.blend root@<proxy>:/workspace/

# Загрузить папку проекта
scp -P <port> -r ./project/ root@<proxy>:/workspace/
```

### Через rsync (большие проекты)

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

## Команды рендеринга

### Один кадр

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

### Анимация (диапазон кадров)

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

### Конкретные кадры

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

## Опции рендеринга

### Разрешение

```bash

# Переопределить разрешение
blender -b file.blend -o //output/frame_### -x 1920 -y 1080 -a -- --cycles-device CUDA
```

### Использовать Python-скрипт

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

**render\_setup.py:**

```python
import bpy

# Установить движок рендеринга
bpy.context.scene.render.engine = 'CYCLES'

# Установить устройство
bpy.context.preferences.addons['cycles'].preferences.compute_device_type = 'CUDA'

# Включить все GPU
for device in bpy.context.preferences.addons['cycles'].preferences.devices:
    device.use = True

# Установить количество сэмплов
bpy.context.scene.cycles.samples = 128

# Установить разрешение
bpy.context.scene.render.resolution_x = 1920
bpy.context.scene.render.resolution_y = 1080

# Настройки вывода
bpy.context.scene.render.image_settings.file_format = 'PNG'
```

## Рендеринг на нескольких GPU

Для серверов с несколькими GPU:

```python
import bpy

# Включить CUDA
prefs = bpy.context.preferences.addons['cycles'].preferences
prefs.compute_device_type = 'CUDA'

# Обновить список устройств
prefs.get_devices()

# Включить все GPU
for device in prefs.devices:
    if device.type == 'CUDA':
        device.use = True
        print(f"Enabled: {device.name}")
```

## Ферма рендеринга (несколько серверов)

Арендуйте несколько серверов и разделите кадры:

**Сервер 1:**

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

**Сервер 2:**

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

**Сервер 3:**

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

Затем объедините рендеры локально.

## Рендеринг в Eevee (быстрее)

Для качества в реальном времени:

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

## Поддержка OptiX (GPU RTX)

Для трассировки лучей на RTX:

```python
import bpy
prefs = bpy.context.preferences.addons['cycles'].preferences
prefs.compute_device_type = 'OPTIX'  # Вместо CUDA
```

## Автоматизированный скрипт рендеринга

**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 "Рендеринг завершён!"
ls -la $OUTPUT_DIR
```

Использование:

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

## Мониторинг прогресса рендеринга

### Наблюдение за папкой вывода

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

### Вывод Blender

Blender выводит прогресс кадра в stdout:

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

## Скачать отрендеренные кадры

```bash

# Скачать все кадры
scp -P <port> -r root@<proxy>:/workspace/output/ ./renders/

# Скачать конкретные кадры
scp -P <port> root@<proxy>:/workspace/output/frame_001.png ./

# Синхронизация с rsync
rsync -avz --progress -e "ssh -p <port>" root@<proxy>:/workspace/output/ ./renders/
```

## Кодирование видео

После рендеринга кадров закодируйте в видео:

```bash

# Установить ffmpeg
apt-get install -y ffmpeg

# Кодировать в MP4
ffmpeg -framerate 24 -i /workspace/output/frame_%03d.png -c:v libx264 -pix_fmt yuv420p output.mp4

# Кодировать в ProRes (высокое качество)
ffmpeg -framerate 24 -i /workspace/output/frame_%03d.png -c:v prores_ks -profile:v 3 output.mov
```

## Советы по производительности

### Оптимизация для скорости

```python

# Уменьшить сэмплы для предпросмотра
bpy.context.scene.cycles.samples = 64

# Использовать адаптивную выборку
bpy.context.scene.cycles.use_adaptive_sampling = True
bpy.context.scene.cycles.adaptive_threshold = 0.01

# Ограничить число отражений (bounces)
bpy.context.scene.cycles.max_bounces = 8
```

### Оптимизация памяти

```python

# Использовать плиточный рендеринг для высоких разрешений
bpy.context.scene.render.use_persistent_data = True

# Установить размер тайла
bpy.context.scene.cycles.tile_size = 256  # Для GPU
```

## Оценки времени рендеринга

| Сцена     | GPU      | Разрешение | Сэмплы | Время/кадр |
| --------- | -------- | ---------- | ------ | ---------- |
| Простая   | RTX 3090 | 1080p      | 128    | \~30с      |
| Средне    | RTX 3090 | 1080p      | 256    | \~2 мин    |
| Сложный   | RTX 4090 | 4K         | 512    | \~10 мин   |
| Продакшен | A100     | 4K         | 1024   | \~20 мин   |

## Расчёт стоимости

**Пример: анимация из 250 кадров**

```
GPU: RTX 4090
Время на кадр: 2 минуты
Общее время рендеринга: 500 минут = 8,3 часа
Почасовая ставка: $0.04
Общая стоимость: ~ $0.33
```

## Устранение неполадок

### "CUDA устройство не найдено"

```python

# Проверить доступные устройства
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" %}
**Недостаточно памяти**
{% endhint %}

* Уменьшите разрешение текстур
* Используйте меньший размер тайлов
* Включите «persistent data»
* Используйте более простые шейдеры

### Медленный рендеринг

* Проверьте, используется ли GPU (nvidia-smi)
* Оптимизируйте геометрию сцены
* Используйте денойзинг с меньшим количеством сэмплов

## Дальнейшие шаги

* Запустите Jupyter для постобработки
* [Генерация видео с помощью ИИ](https://docs.clore.ai/guides/guides_v2-ru/generaciya-video/ai-video-generation)