Вы готовы? Тогда давайте погрузимся! 🙂 Если вы хотите получить код напрямую, он доступен в Github Gist. Через Python API .

Вам может быть интересно, почему Python API для 3D-программы интересен. Я имею в виду: зачем встраивать в творческий инструмент с вещами для программистов?

По правде говоря, во многих случаях он может быть полезен для  автоматизировать задачу : хотите ли вы быстро рандомизировать алгоритм заполнения сцены, подсчитать объекты и получить индивидуальную статистику для вашей сцены или даже создать целый мир с нуля, который можно точно воспроизвести с помощью семечек… имея возможность интегрировать процедурную генерацию или специальные инструменты  непосредственно в контексте компьютерной графики — это просто потрясающая возможность!

Кроме того, тот факт, что это Python , язык, известный как простой в освоении  и для которого существует всего бесконечное количество руководств  в сети позволяет новичкам легко погрузиться в работу (не опасаясь старых API-интерфейсов на основе C/C++, которые, на мой взгляд, требовали более высоких навыков программирования…).

Между прочим: этот Python API — не просто блестящая игрушка для подражателей: на самом деле это часть самого программного обеспечения Blender  и он используется внутри программы как основной инструмент, хотя пользовательский ввод и результаты заключены в удобный пользовательский интерфейс 😉

API сам по себе, bpy (от «Blender Python»), можно просмотреть в специальной документации Blender; он разделен на несколько подмодулей, из которых 3 наиболее важных / часто используемых:

• bpy.context: содержит геттеры и считыватели значений, доступных только для чтения, которые описывают ваш текущий рабочий контекст или даже область (например, панель в вашем окне), к которой в данный момент осуществляется доступ
• bpy.data: предоставляет вам доступ к ресурсам в вашей сцене (объектам, материалам, сеткам…), чтобы вы могли загружать, добавлять или удалять их
• bpy.ops: это настоящее мясо API — это то, что позволяет вам выполнять действия и вызывать операторы на ваших объектах или ваших взглядах; это в основном то, как вы можете имитировать действия пользователя с помощью сценариев (например, выбор объекта, вход в режим редактирования, применение подразделений, переход к «плоскому» затенению, максимизация окна…)

Сегодня мы сосредоточимся на создании объектов благодаря этому API, поэтому мы проведем процедурную генерацию . Я уже обсуждал преимущества этого подхода в других статьях; Грубо говоря, процедурная генерация заключается в определении набора правил и машины , которая использует эти правила для автоматического создания допустимых экземпляров . Большим преимуществом является то, что как только вы закончите создание движка, вы сможете создать столько экземпляров, сколько захотите! Более того, эта генерация может быть довольно быстрой, динамичной в зависимости от заданных условий и бесконечной (например, для бесконечных игр, таких как раннеры). Но, конечно, обычно это немного сложнее, чем ручное проектирование, потому что вам нужно научить свое программное обеспечение правильным и неправильным шаблонам (то есть «правилам»).

Процедурная генерация — очень обширная и сложная тема. Существует множество инструментов для генерации движков — и, честно говоря, большая их часть полагается на случайность . Идея состоит в том, чтобы начать со случайных значений, а затем каким-то образом « контролировать сумасшествие », чтобы это было правильно.

Создание и анимация случайной солнечной системы!

Чтобы увидеть, насколько мощным может быть API Python для Blender и как его использовать, давайте поработаем над базовым примером: создаем группу планет вокруг солнца (все они представляют собой простые сферы) со случайным размером, скоростью и цветом, а планеты вращаются вокруг Солнца по круговым орбитам.

Теперь давайте проясним: это будет , а не , физическая симуляция. Мы выберем все наши значения случайным образом, и не будет никакой логической связи между расстоянием до Солнца, радиусом и цветом поверхности планет. Цель здесь — просто поиграть с Python API Blender, посмотреть, как сделать процедурную генерацию и повеселиться со светящимися сферами 😉

Шаг 1: Подготовка нашего Blender

Прежде всего: давайте посмотрим, как настроить наш Blender для Python и изучите различные инструменты, которые есть в нашем распоряжении.

Примечание: в этом руководстве используются скриншоты из Blender 2. 93. Кроме того, я буду использовать Python API из Blender 2.8+, поэтому убедитесь, что ваша версия соответствует 🙂

Если вы хотите работать с Python в Blender, очень полезно запустить Blender с подключенной консолью . Это позволит вам увидеть некоторые журналы, если ваш скрипт Python содержит ошибки, что очень важно для правильной отладки!

По сути, идея состоит в том, чтобы запускать Blender с вашего терминала, а не с ярлыка приложения. Точный путь к исполняемому файлу Blender зависит от вашей ОС; Я использую Mac, поэтому все, что мне нужно сделать, это открыть терминал и запустить что-то вроде этого:

/Applications/Blender.app/Contents/MacOS/Blender &

С этого момента все, что выдают мне мои сценарии Python, будет отображаться в этой консоли 🙂

Теперь, чтобы подготовиться к кодированию, просто перейдите в Вкладка «Scripting» в верхней части окна Blender:

Это даст набор новых панелей в вашем рабочем пространстве, а именно:

1. 3D-вид : как обычно вы начинаете экран в Blender — вы видите свою текущую сцену в 3D, в режиме «сплошной» тени, и вы можете выбирать различные объекты, как обычно
2. интерактивная консоль Python : эта специально созданная консоль Python невероятно полезна для просмотра API Blender и изучения всех полей и методов, которые предоставляют нам объекты Python Blender; В дополнение к основным встроенным модулям Python, эта консоль также поставляется со встроенными модулями Blender и несколькими удобными переменными для легкого доступа к общим подмодулям API Blender
3. Информационная панель : сначала это может показаться странным, но это панель просто отлаживает все, что вы делаете, что еще раз отлично подходит для открытия возможностей API! Если вы попытаетесь выбрать объект, или переместить источник света, или любое другое действие, которое вы привыкли выполнять в Blender, вы увидите, что оно зарегистрировано на этой панели, и вы сможете понять, к какой части API вам следует получить доступ. воспроизвести это действие через сценарий
4. Текстовый редактор : как вы уже догадались – это основное блюдо для нас сегодня; здесь мы будем создавать, редактировать, сохранять и запускать наш скрипт Python. Это простой редактор Python с подсветкой синтаксиса, номерами строк и даже несколькими утилитами, такими как «Найти и заменить», если открыть боковую панель (с помощью или на Mac). Обратите внимание, однако, что этот редактор ограничен с точки зрения возможностей, поэтому, если вы планируете делать что-то большое, вероятно, лучше использовать хорошую внешнюю IDE, а затем загрузить свой скрипт в Blender, когда он будет готов
5.   Outliner : это еще один распространенный вид, который вы, вероятно, уже знаете, который просто показывает иерархию объектов в вашей текущей сцене и обеспечивает быстрый доступ
6.   панель свойств : аналогично, эта панель такая же, как макеты — здесь вы можете просматривать и редактировать свойства вашей сцены, параметры рендеринга, настройки вашего мира и конкретные данные для вашего текущего выбранного объекта

Чтобы убедиться, что все работает, просто нажмите кнопку «+ Новый» текстового редактора, напишите базовую строку print(‘hello world’) в скрипте Python и щелкните значок «Выполнить» справа (или используйте сочетание клавиш ; убедитесь, что указатель мыши наведен на текстовый редактор панель, чтобы это работало).

Если все настроено правильно, на подключенном терминале должно появиться сообщение «hello world»!

Шаг 2: Создание базовой сетки с помощью API

Хорошо! Пришло время стать реальными и создать некоторые объекты в нашей сцене с помощью Python 🙂

Для начала удалите все исходные объекты: куб, камеру и свет. Мы не будем их использовать.

Теперь давайте отредактируем наш скрипт Python, чтобы создать новый объект сферы. Это делается с помощью подпакета bpy.ops, а точнее метода mesh.primitive_uv_sphere_add():

 импорт бит/год
bpy.ops.mesh.primitive_uv_sphere_add(
    радиус=3,
    местоположение = (0, 0, 0),
    шкала = (1, 1, 1)
) 

Параметры говорят сами за себя: мы создаем сферу с радиусом 3 в исходной точке с нормализованным масштабом. (Не стесняйтесь просматривать документы для получения более подробной информации о доступных параметрах)

Еще раз запустите свой код, щелкнув значок «Выполнить» или с помощью шорткода . И тадаа! Мы только что создали простую UV-сферу в нашей 3D-сцене исключительно с помощью скрипта! 😉

Шаг 3: Создание экземпляров наших планет

Теперь мы можем создать одну сферу — так что давайте посмотрим, как легко создать несколько!

Нам нужно:

• создать N_PLANETS объектов, каждый из которых представляет собой простую UV-сферу в конечном итоге место нашего солнца), что зависит от индекса планеты (чтобы их орбиты были хорошо разбросаны)

Создать N_PLANETS экземпляров очень просто: мы просто заключим наш вызов primitive_uv_sphere_add() в цикл for и запустим его несколько раз. Чтобы сценарий оставался читабельным, мы на самом деле извлечем этот процесс создания экземпляра в вспомогательную функцию create_sphere() и передадим его со случайным радиусом и расстоянием.

Чтобы получить случайное значение для нашего радиуса и нашего расстояния, мы можем положиться на встроенный модуль случайных чисел Python.

Также мы должны  назвать наши объекты  правильно: это интересно, чтобы сохранить ясность нашей иерархии, и это будет важно, когда позже мы будем автоматически очищать сцену при инициализации скрипта. Я просто буду называть каждый объект «Планета-00», «Планета-01» и так далее для сфер N_PLANETS.

Вот обновленный скрипт:

 from random import random
импортировать бит/год
def create_sphere (радиус, расстояние_до_солнца, имя_объекта):
    # создать UV-сферу с заданным
    # радиус на заданном расстоянии от
    # мировая точка происхождения
    obj = bpy.ops.mesh.primitive_uv_sphere_add(
        радиус=радиус,
        местоположение=(расстояние_до_солнца, 0, 0),
        шкала = (1, 1, 1)
    )
    # переименовать объект
    bpy.context.object.name = имя_объекта
    # вернуть ссылку на объект
    вернуть bpy.context.object
N_ПЛАНЕТЫ = 6
для n в диапазоне (N_PLANETS):
    # получить случайный радиус (число с плавающей запятой в [1, 5])
    г = 1 + случайный () * 4
    # получить случайное расстояние до исходной точки:
    # - начальное смещение 30, чтобы выйти из сферы солнца
    # - сдвиг в зависимости от индекса планеты
    # - небольшой "шум" со случайным поплавком
    d = 30 + n * 12 + (случайное() * 4 - 2)
    # создать экземпляр планеты с этими параметрами
    # и имя пользовательского объекта
    create_sphere(r, d, "Планета-{:02d}". format(n)) 

Если вы запустите это снова, вы должны получить небольшой набор хорошо выровненных планет различных размеров, которые все названы в правильном формате:

Шаг 4: Добавление солнца и колец радиуса

В аналогичным образом мы можем повторно использовать наш метод create_sphere() и создать еще один, называемый create_torus(), чтобы добавить сферу для солнца и некоторые объекты тора, чтобы показать орбиты планет:

 from random import random
импортировать бит/год
def create_sphere (радиус, расстояние_до_солнца, имя_объекта):
    # ...
def create_torus (радиус, obj_name):
    # (аналогично методу create_sphere)
    obj = bpy.ops.mesh.primitive_torus_add(
        местоположение = (0, 0, 0),
        major_radius=радиус,
        минор_радиус=0.1,
        основные_сегменты = 60
    )
    bpy.context.object.name = имя_объекта
    вернуть bpy.context.object
N_ПЛАНЕТЫ = 6
для n в диапазоне (N_PLANETS):
    # ...
    # добавляем отображение кольца радиуса
    create_torus(d, "Радиус-{:02d}". format(n))
# добавляем солнечную сферу
солнце = создать_сферу (12, 0, "Солнце") 

Солнце, конечно, больше, чем планеты, и кольца просто размещаются одновременно со сферами планет, используя расстояние до начала координат для параметра радиуса тора:

Шаг 5: Установка материалов и затенение для наши объекты

Это здорово, но эти объекты какие-то угрюмые, все серые и блочные. Пришло время поработать над двумя важными концепциями 3D: затенением и материалами наших объектов!

Вообще говоря, затенение  относится к тому, как объект реагирует на свет и отрисовывается в 3D-виде или при визуализации. Однако здесь я сосредоточусь на «гладком» и «плоском» затенении, которое определяет, как граненый объект выглядит. По сути, это второй слой, который дополнительно влияет на визуализацию объекта, но не меняет его фактическую геометрию: он просто выглядит более гладким.

Настроить объекты на использование «сглаженного» затенения очень быстро: у нас есть специальный метод Shade_smooth() в подмодуле bpy. ops:

 из случайного импорта случайный
импортировать бит/год
def create_sphere (радиус, расстояние_до_солнца, имя_объекта):
    # ...
    # применяем плавное затенение
    bpy.ops.object.shade_smooth()
    # вернуть ссылку на объект
    вернуть bpy.context.object
def create_torus (радиус, obj_name):
    # ...
    # применяем плавное затенение
    bpy.ops.object.shade_smooth()
    # вернуть ссылку на объект
    вернуть bpy.context.object
# ... 

Настоящий вопрос заключается в следующем: как мы можем придать нашим планетам цветов , и как мы можем сделать наше солнце свечение ?

Ответ: благодаря материалам и шейдерам! 🙂

Что такое материалы и шейдеры?

Оба этих термина можно использовать, чтобы говорить о «палитре свойств, определяющих способ визуализации объекта».

Грубо говоря, шейдеров  это то, что придает 3D-объектам их цвет, их блеск, их глянец, их шероховатость… Подумайте об этом: в реальном мире, что заставляет вас говорить, что «хм, это дерево» — это просто целое набор подсказок: предмет имеет оттенок коричневого, немного отражает свет, но не резкими световыми пятнами, как металл, не преломляет лучи, как стекло, и не отражает ваше изображение, как зеркало… Благодаря постоянно совершенствующейся технологии компьютерной графики все эти свойства теперь можно смоделировать и воспроизвести в наших 3D-сценах!

Примечание: когда вы действительно стремитесь к реалистичному рендерингу, вам, вероятно, придется погрузиться в физический рендеринг или PBR. И именно для этого используется движок Blender Cycles для создания удивительно реалистичных изображений, которые просто «кажутся» реальными, в основном благодаря набору сложных и хорошо настроенных шейдеров.

В Blender шейдеры обычно редактируются с помощью редактора графов на основе узлов (доступного на вкладке «Затенение»), который позволяет вам соединять и комбинировать столько встроенных узлов, сколько вы хотите, чтобы создавать более или менее сложные потоки затенения. В этом уроке , однако мы создадим очень простой шейдер, который имеет только один узел, поэтому мы сделаем все в нашем скрипте Python 🙂

Материалы , затем используем эти шейдеры и применим их к вашей 3D-геометрии. У объекта может быть несколько слотов материала, т.е. он может использовать разные шейдеры для разных частей геометрии, но сегодня мы не будем вдаваться в это, и мы будем придерживаться одного слота материала для каждого объекта.

Выбор типа шейдера

Итак, какой шейдер мы должны создать?

В этом проекте  я использую механизм EEVEE , который также может работать с узлами шейдеров, хотя у него и не все типы узлов, как у механизма Cycles.

Но это нормально, потому что здесь мне нужен тот, который существует в обоих: шейдер Emission . Вы можете представить это как большую лампочку, у которой есть интенсивность (параметр «сила») и цвет. Это заставит ваш 3D-объект излучать свет (так что ваш объект станет источником света в вашей сцене, с которым мы будем взаимодействовать с остальными сетками!) и, по сути, заставит его «светиться» 🙂

Создание шейдера в нашем скрипте Python

Чтобы полностью создать и назначить шейдер с помощью скрипта, нам необходимо:

• создать новый ресурс шейдера, используя подмодуль bpy.data будет с редактором узлов шейдера: мы удалим некоторые узлы, добавим другие, установим их свойства и свяжем их вместе
• получим ссылку на наш вновь созданный материал
• и, наконец, добавим его в данные материалов (т.е. слоты) нашего объекта

Давайте работать над этим шаг за шагом. Мы начнем с создания новой функции под названием create_emission_shader(), которая получит некоторые параметры силы и цвета и будет использовать их для настройки базового двухузлового графа с узлом излучения и выходным узлом.

Идея состоит в том, чтобы начать с базового шаблона узла и очистить все начальные узлы; затем мы можем добавить наши узлы эмиссии и вывода, настроить узел эмиссии, обновив значения его полей ввода, и создать связь между двумя узлами:

 def create_emission_shader (цвет, сила, имя_мата):
    # создать новый материальный ресурс (со своим
    # связанный шейдер)
    мат = bpy.data.materials.new(mat_name)
    # включить режим редактирования нод-графа
    mat.use_nodes = Истина
    
    # очищаем все начальные узлы
    узлы = мат.node_tree.nodes
    узлы.очистить()
    # добавляем узел Emission
    node_emission = nodes.new(type="ShaderNodeEmission")
    # (input[0] - это цвет)
    node_emission.inputs[0].default_value = цвет
    # (input[1] — сила)
    node_emission.inputs[1].default_value = сила
    
    # добавляем узел вывода
    node_output = nodes.new(type="ShaderNodeOutputMaterial")
    
    # связать два узла
    ссылки = mat.node_tree.links
    link = links.new(node_emission. outputs[0], node_output.inputs[0])
    # вернуть ссылку на материал
    возврат мат 

Теперь довольно легко использовать этот метод для создания наших материальных ресурсов и применения их к нашим объектам. Нам понадобится один белый излучающий материал для колец, один желтый излучающий материал для солнца и один излучающий материал для каждой планеты со случайным цветом (хотя я добавлю больше синего для лучшего общего цветового баланса 😉):

 # . ..
N_ПЛАНЕТЫ = 6
ring_mat = create_emission_shader(
    (1, 1, 1, 1), 1, «Рингмат»
)
для n в диапазоне (N_PLANETS):
    # ...
    планета = create_sphere(r, d, "Планета-{:02d}".format(n))
    планета.данные.материалы.приложение(
        create_emission_shader(
            (случайный(), случайный(), 1, 1),
            2,
            "PlanetMat-{:02d}".format(n)
        )
    )
    # добавляем отображение кольца радиуса
    кольцо = create_torus(d, "Радиус-{:02d}".format(n))
    ring.data.materials.append(ring_mat)
# добавляем солнечную сферу
солнце = создать_сферу (12, 0, "Солнце")
sun. data.materials.append(
    create_emission_shader(
        (1, 0,66, 0,08, 1), 10, "Солнцемат"
    )
) 

Если вы измените режим затенения в вашем 3D-виде на «Визуализировано», вы удалите все объекты, которые в настоящее время находятся в сцене, и снова запустите скрипт, вы увидите, что на них теперь есть красивые светящиеся материалы!

Обратите внимание, что после запуска скрипта вы даже можете перейти на вкладку «Затенение», выбрать объект с шейдером и посмотреть график шейдера:

Выглядит как положено: два узла, один Излучение и один выход, связь между ними и некоторые пользовательские значения свойств «Сила» и «Цвет».

Примечание: когда вы впервые открываете панель, все узлы будут собраны вместе посередине друг над другом. Здесь я переместил узлы вручную для демонстрации, но вы можете сделать это и в своем коде с помощью свойства .location .

Шаг 6: Анимация планет

Мы приближаемся к финальному «генератору солнечной системы»! Последнее, о чем нам нужно позаботиться, — это анимация планет, чтобы они вращались вокруг солнца с течением времени.

Чтобы сделать это, мы будем использовать систему анимационных кривых Blender (F-кривые). Это более продвинутая  версия анимации по ключевым кадрам  , в которой вы указываете ключевые значения  для одного или нескольких свойств вашего объекта с течением времени (например, вы задаете его положение, поворот, масштаб… в заданном кадре), а также интерполяция  между ними.

Вот пример того же набора ключевых точек с тремя возможными интерполяциями (слева направо: постоянная, линейная и Безье):

Вы видите, как интерполяция влияет на автоматически вычисляемые промежуточные значения (все сегменты между ключевыми кадрами, которые мы определили вручную) и как это влияет на общую эволюцию этого свойства объекта. Предположим, что эта линия представляет собой высоту маленького вертолета:

• с постоянной интерполяцией, вертолет просто продолжает нырять вверх и вниз, затем движется прямо вперед с небольшим плато
• с линейной интерполяцией, вертолет скользит из одной точки в другую с приятные диагонали, но все же довольно внезапно меняет направление, когда достигает экстремума
• с интерполяцией Безье, вертолет замедляется перед достижением этих долин и хребтов и плавно обновляет свой курс

«Лучшая интерполяция» зависит от типа анимации, которую вы хотите. В нашем случае мы должны выбрать линейную интерполяцию, чтобы планеты просто двигались с постоянной скоростью по своим орбитам.

Чтобы создать анимацию для наших планет, нам просто нужно использовать метод animation_data_create() и поле animation_data наших объектов, чтобы создать, а затем отредактировать F-кривую для свойства Z-вращения. Это свойство на самом деле является частью свойства 3D-вектора объекта, называемого «9».0016 Вращение Эйлера ”(подробнее о режимах вращения Блендера здесь), где ось Z — это третий компонент, то есть компонент с индексом 2 (поскольку компоненты имеют индекс 0).

Получив это свойство, мы просто добавим два ключевых кадра: один для начального кадра (с нашим текущим поворотом 0) и другой для конечного кадра (со случайным поворотом одного или больше полукругов вокруг Солнца, так что планеты имеют различных скоростей ). И мы позаботимся о том, чтобы эти ключевые кадры использовали режим линейной интерполяции 😉

Примечание: все повороты должны быть записаны с использованием  радиан .

 из математического импорта пи
# ...
N_ПЛАНЕТЫ = 6
START_FRAME = 1
КОНЕЦ_КАДР = 200
для n в диапазоне (N_PLANETS):
    # ...
    # настроить данные анимации планеты
    планета.animation_data_create()
    planet.animation_data.action = bpy.data.actions.new(name="RotationAction")
    fcurve = планета.animation_data.action.fcurves.new(
        data_path="rotation_euler", индекс=2
    )
    k1 = fcurve.keyframe_points.insert(
        кадр = START_FRAME,
        значение=0
    )
    k1.interpolation = "ЛИНЕЙНАЯ"
    k2 = fcurve.keyframe_points.insert(
        кадр=END_FRAME,
        значение=(2 + случайный() * 2) * число пи
    )
    k2.interpolation = "ЛИНЕЙНАЯ" 

Если вы очистите свою сцену и перезапустите скрипт, вы увидите, что… ничего не происходит! Планеты не двигаются, даже когда вы воспроизводите анимацию!

И это потому, что они действительно вращаются… но не вокруг правой оси! На данный момент планеты просто вращаются, они вращаются вокруг своей локальной оси Z.

Чтобы исправить это, нам просто нужно изменить точку поворота наших объектов и привязать ее к курсору, находящемуся в исходной точке мира (там же, где находится наше солнце):

 # ...
для n в диапазоне (N_PLANETS):
    # ...
    # сделать планету активным объектом
    bpy.context.view_layer.objects.active = планета
    планета.select_set(Истина)
    # установить источник объекта в начале мира
    bpy.ops.object.origin_set(type="ORIGIN_CURSOR", center="MEDIAN")
    # настроить данные анимации планеты
    # ... 

Теперь, если вы наведете курсор на 3D-изображение и нажмете клавишу пробела, время начнет течь, и заиграет анимация, заставляющая наши планеты вращаться вокруг солнца! 🙂

Шаг 7 (дополнительный): автоматическая очистка сцены при запуске скрипта

После запуска скрипта мы создали два типа ресурсов  в нашей сцене: 3D-объекты для планет, солнце и орбитальные кольца; и динамические материалы для планет.

Избавиться от этого довольно просто: нам просто нужно использовать подмодуль bpy.data, чтобы просмотреть наши объекты и наши материалы, проверить имена и удалить те, которые мы создали при запуске скрипта:

 # ...
def delete_object (имя):
    # пытаемся найти объект по имени
    если имя в bpy.data.objects:
        # если он существует, выделите его и удалите
        obj = bpy.data.objects[имя]
        obj.select_set(Истина)
        bpy.ops.object.delete(use_global=False)
N_ПЛАНЕТЫ = 6
START_FRAME = 1
КОНЕЦ_КАДР = 200
# чистая сцена + материалы планеты
delete_object("Солнце")
для n в диапазоне (N_PLANETS):
    delete_object("Планета-{:02d}".format(n))
    delete_object("Радиус-{:02d}".format(n))
для m в bpy.data.materials:
    bpy.data.materials.remove (м)
# ... 

Теперь вы можете запускать скрипт сколько угодно раз: каждый раз сцена сначала будет очищена  так, что вы получите только один экземпляр нашей «солнечной системы» 🙂

Шаг 8 (бонус): Авто -настройка свойств сцены, механизма рендеринга и настроек 3D-просмотра

Для более приятной визуализации с небольшим эффектом цветения , темным фоном и отсутствием сетки или осей X/Y, вы даже можете добавить следующий фрагмент в начало вашего скрипта для настройки сцены с хорошими настройками:

 # . ..
защита find_3dview_space():
    # находим панель 3D-просмотра и ее экранное пространство
    площадь = нет
    для a в bpy.data.window_managers[0].windows[0].screen.areas:
        если a.type == "VIEW_3D":
            площадь = а
            сломать
    вернуть area.spaces[0], если область еще bpy.context.space_data
определение setup_scene():
    # (установить черный фон)
    bpy.data.worlds["Мир"].node_tree.nodes["Фон"].inputs[0].default_value = (0, 0, 0, 1)
    # (убедитесь, что мы используем движок рендеринга EEVEE + включаем эффект цветения)
    сцена = bpy.context.scene
    scene.render.engine = "BLENDER_EEVEE"
    scene.eevee.use_bloom = Истина
    # (установить начало/конец/текущие кадры анимации)
    сцена.frame_start = START_FRAME
    scene.frame_end = КОНЕЦ_КАДР
    scene.frame_current = START_FRAME
    # получить текущий 3D вид (среди всех видимых окон
    # в рабочей области)
    пробел = find_3dview_space()
    # применить "рендеринговый" режим затенения + скрыть все
    # дополнительные маркеры, сетки, курсоры. ..
    space.shading.type = 'ОТРЕЗАНИРОВАНО'
    space.overlay.show_floor = Ложь
    space.overlay.show_axis_x = Ложь
    space.overlay.show_axis_y = Ложь
    space.overlay.show_cursor = Ложь
    space.overlay.show_object_origins = Ложь
N_ПЛАНЕТЫ = 6
START_FRAME = 1
КОНЕЦ_КАДР = 200
# установить настройки сцены
setup_scene()
# ...
# снять выделение со всех объектов
bpy.ops.object.select_all(action='ОТМЕНИТЬ ВЫБОР') 

Заключение

Blender — не единственная 3D-программа, позволяющая программировать сцены и автоматизировать задачи; но он оправдывает ожидания, и с каждой новой версией Blender постепенно становится надежным универсальным решением для производства компьютерной графики , от раскадровки с помощью Grease Pencil до компоновки на основе узлов.

Тот факт, что вы можете использовать скрипты Python всего с несколькими дополнительными пакетами для пакетного создания экземпляров объектов, генерировать материал процедурно, настраивать параметры рендеринга или даже получать пользовательскую статистику по вашему текущему проекту, — это здорово! Для меня это способ облегчить нагрузку на утомительные задачи, а также привлечь разработчиков к вечеринке, чтобы расширить это сообщество творческих инструментов за пределы художников.