Blender для начинающих/Python: различия между версиями

=== Str ===

Строки предназначены для хранения текстовой информации. Строки могут быть любой длины. Например может быть такая строка:

Строки всегда берутся в кавычки. Одинарные или двойные. Чтобы растянуть строку на несколько строк программы, необходимо заключить её в три пары кавычек. Это не сработает и выдаст ошибку:

Это сработает:

И это тоже:

Символ переноса строки в последнем случае включается в строку.

 

== Переменные ==

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

Имя — имя создаваемой переменной. Значение — начальное значение переменной. Например:

 

 

= — эта операция присваивания (установки значения).

== Списки ==

Список — последовательность элементов одного типа, имеющая имя. Списки в Python создаются так:

Но можно также создавать и пустые списки:

Для создания списков определена такая функция как split (разделение на слова по пробелам), и обратная ей join (объединение). Первая предназначена для получения списка из переменной строки разделением на слова по разделителю. Например:

s = 'Hi user'

a = []

Разделитель — символ по которому строка будет делиться на части. Join — противоположна Split. Она объединяет все элементы списка в одно целое. Например:

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

 

 

Создаются они вот так:

Где a — кортеж.

 

Например:

 

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

 

== Множества ==

# Как следствие, в множестве не может быть двух и более элементов с одинаковыми значениями.

Создать множество из строки можно функцией set():

На выходе получим множество. Все повторяющиеся символы из строки будут записываться единожды:

Другой способ создания множества — перечисление всех в него входящих элементов в {} — литералах:

Писать {} без ничего для декларации множества недопустимо.

 

 

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

Например:

Также объявить их можно функцией dict() следующим образом:

Третий способ создать словарь, заполнив его только ключами, оставив соответствующие им значения значениями по умолчанию можно так:

В списке должны быть сами ключи — просто какие то значения, которые будут ключами для словаря.

 

Для изменения элементов словаря надо писать конструкцию:

Если данного ключа нет в словаре возникнет ошибка.

 

Попытка получить доступ к несуществующему элементу с ключом «s»:

 

=== Операции работы со словарями ===

== Ввод и вывод ==

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

 

Но сначала значение будет строкой. Для избежание этого надо явно указывать тип вводимого значения:

 

 

Для целых чисел: int(input()), для float (вещественных): float(input()), строк: str(input()).

== Оператор if ==

Оператор if — команда, выполняющая блок команд, при выполнении условия.

Условие — любое выражение, которое проверяется на истинность. В нем могут быть знаки сравнения: > (больше), < (меньше), >= (больше или равно), <= (меньше или равно), == (равно), != (не равно). Например:

if a == 1:

В ситуации когда надо проверить много условий поможет такая конструкция как if elif else:

# команды

elif условие:

# команды

else:

elif — дополнительный блок для проверки другого условия, нежели в if. Условие в elif будет проверяться, если в if условие не выполнилось. Соответственно в else выполниться команды, если никакое из условие не было верным. Количество elif неограниченно. При том, если какое то условие оказалось верным, то операторы ниже него выполняться, и выполение блока if завершится — остальные нижестоящие условие не будут проверяться.

 

=== Тип bool ===

Тип bool — тип, который имеет всего два значения: True (истина) и False (ложь). Если надо из true получить число то надо написать:

Имя — имя переменной, которой присвоется 1. Если преобразовать False к числу получится 0. Аналогично почти у строк: если она пуста то получится при преобразовании из str в bool значение 0, иначе 1.

 

В условиях, например чтобы написать условие вида:

где a — переменная, можно использовать сокращенный вариант:

 

== Условия для множеств ==

== Оператор while ==

While позволяет организовывать циклы, команды внутри которых будут выполняются только при выполнении условия. Создавать цикл можно так:

Например:

while a <= 10:

 

== for ==

For предназначен для циклического выполнения команд определенное количество раз. Его синтаксис таков:

Диапазоном может служить как простое значение так и выражение или список значений. Типы в диапазона могут быть любыми:

ind = 0

for s in 'a', 'b', 'c':

print('Букве ', a[ind],'соответствует номер ',s)

 

== Сложные условия ==

Когда требуется объединить условия следует пользоваться такими словами как and, or. And — вернет true, если все условия, которые были объединены с его помощью выполнились. Or — вернет true, когда хотя бы одно условие выполнилось. Например:

if (a == 'a') and (a != 'b'):

if (a == 'a') or (a == 'b'):

Объединяемые условия следует брать в скобки. Также как и в других языках логическое отрицание обозначаемся словом not. Читается как: если условие не такое как в скобках.

if not (a == 'd'):

 

= Функции =

Функция — это группа команд, которая имеет свое имя. Создавать ее можно так:

Вместо имени должно стоять название функции. a, b, c и n — параметры. Тип параметров не нужно указывать — пишите только их имена. Например:

Здесь слово return говорит о том, что функция возвращает результат равный a + b. То есть дает возможность присвоить сумму a и b другой переменной. Вместо a + b может стоять любое выражение.

 

Для использования функций (вызова) надо просто написать имя функции и значения ее параметров.

return a+b

 

 

== Лямбды ==

Лямбда — эта функция, записанная в простой упрощенной форме. Общий синтаксис:

Параметрами тут могут выступать как и переменные, так и любые другие объекты. Результат может записываться как любое выражение. Вот пример лямбды:

Вернет x².

 

Также лямбды можно именовать. Для этого пишите:

Например:

Для ее вызова используйте стандартный синтаксис вызова функций:

Вызов лямбды и функции, которые возводят d в квадрат:

def F(x):

return x**2

d = f(3) # вызов лямбды

d = F(3) # вызов функции

 

=== Условия в лямбда-функциях ===

Лямбды позволяют использовать в себе условия:

В данном случае лямбда вернет указанное после if выражение, только если проверяемое условие будет истинным:

a = 0

Можно также использовать if с else:

Лямбда-функция вернет выражение2 только, если условие не выполнилось.

a = 0

 

=== Вложенные лямбда-функции ===

Лямбда функция может возвращать лямбда функцию следующим образом:

Внешняя лямбда вернет ссылку на вложенную функцию. Например:

Для вызова таких лямбд можно писать:

f2 = f1(параметры)

...

fN = fM(параметры)

Где f — сложная лямбда, N на единицу больше M, а все остальные f (ниже определенной лямбды) — ссылки на более вложенные лямбды. Каждая внешняя лямбда для своей вложенной будет возвращать ссылку на нее.

 

При достижении самой вложенной лямбды Вы получите накопившейся результат:

f1= Lmain(1) # получаем ссылку на (lambda y: (lambda z: x+y+z))

f2 = f1(3) # получаем ссылку на (lambda z: x+y+z)

f3(5) # вызываем самую вложенную лямбду x = 1, y = 3, z = 5

print(f3(5)) # получится 9

 

= Исключения =

= Конструкция try — except =

Любые ошибки можно обработать (выполнить некоторые команды при возникновении исключения, избежав сбоя работы программы). Это делается с помощью операторов try и except:

try

# команды

except название исключени:

# команды, выполняемые при возникновении исключения

Например, переменной b присвоется значение 1, если произойдет деление на 0:

a = 3

b = int(input())

except ZeroDivisionError:

b = 1

Стоит заметить, что перехватывая (обрабатывая) исключение Вы дадите интерпретатору обрабатывать все, являющиеся потомками данного исключения.

 

Пример обработки всех исключений — потомков класса ArithmeticError:

a = 3

b = int(input())

except ArithmeticError:

b = 1

 

= Импорт =

Команда import импортирует некоторый модуль в данную программу. Общий синтаксис:

Вместо имени пишите название подключаемого модуля. Если их много, то имена модулей пишите через запятую.

При нужде в сокращении кода используйте конструкцию from n import m:

Вместо имени пишите имя модуля, из которого будет импортироваться что нибудь с именем имя2.

Также можно импортировать модули, присваивая им псевдонимы (другое название):

Модуль будет подключен к программе и вызов функций из него будет происходить следующим образом:

Аналогично будут использоваться другие данные из него (переменные, списки, классы и т. д.).

 

= Генераторы =

Когда требуется создать список по некоторой формуле надо использовать следующую конструкцию:

Формула — формула, по которой строится список. Переменная — имя переменной, которая используется в формуле и значение которой берется из функции range().

 

Например, список квадратов чисел Вы можете создать так:

Также вместо range() можно использовать строку, по которой пробежится переменная из формулы:

Создание списка из строки, где каждая буква повторится 3 раза:

 

== Генераторы с условиями ==

В генераторы можно ключать условия с if таким образом:

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

 

Например, создание списка только из четных элементов:

 

== Вложенные генераторы ==

Один генератор может быть вложенным в другой:

Здесь второй генератор это:

Два генератора вложены друг в друга:

Не исключается возможность включения условий в такой генератор:

Степень вложенности генераторов один в другой не имеет предела. Например:

Создание списка при вложенном генераторе идет следующим образом:

# Переменная самого вложенного генератора всегда изменяется первой.

 

Классы в Python объявляются следующим образом:

class имя:

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

def __init__ (self):

Если это метод класса (а не метод экземпляра класса), то следует писать @classmethod перед описанием функции (метода класса):

@classmethod def f ():

 

== Переменные классов ==

# Обращение к переменным класса внутри классов должно начинаться с self.имя_переменной.

# Для того, чтобы переменная не была видна снаружи класса, в ее имени используйте двойное нижнее подчеркивание. Например:

 

== Создание инстансов ==

Инстанс (объект или экземпляр класса) — что то созданной с помощью класса. Общий синтаксис создания объекта:

Имя — это имя объекта; класс — это имя класса, экземпляр (или объект) которого мы желаем создать; параметры конструктора — параметры функции __init__ данного класса (self при создании объекта писать на надо). Пример:

class t:

time

self.time = T

 

 

= Дополнение =

! Функция !! Описание

|-

|-

|}

 

 

=== Пример рисования ===

import turtle

 

turtle.circle(100)

turtle.mainloop()

 

= Алгоритмы =

=== Определение цветов ===

Определим цвета как три значения в списках:

c1 = [r, g, b]

c2 = [r, g, b]

r, g, b — числа, соответствующие RGB.

 

=== Mix ===

Смешивание цветов через нахождения их средних значений:

def Mix(c1, c2):

c3 = [(c1[0]+c2[0])//2, (c1[1]+c2[1])//2, (c1[2]+c2[2])//2]

return c3

 

=== Add ===

Смешивание цветов через суммирование их значений:

def Add(c1, c2):

c3 = [c1[0]+c2[0], c1[1]+c2[1], c1[2]+c2[2]]

return c3

То же самое, но с учетом силы смешивания Strength (которая колеблется от 0.0 до 1.0):

def Add(c1, c2, Strength):

c3 = [c1[0]+abs(c1[0]-c2[0])*Strength, c1[1]+abs(c1[1]-c2[1])*Strength, c1[2]+abs(c1[2]-c2[2])*Strength] # Берем по модулю так как разность может быть отрицательной.

return c3

 

=== Subtract ===

Смешивание цветов через вычитание их значений:

def Substr(c1, c2):

c3 = [c1[0]-c2[0], c1[1]-c2[1], c1[2]-c2[2]]

return c3

 

=== Multiply ===

Смешивание цветов через перемножение их значений:

def Mult(c1, c2):

c3 = [c1[0]*c2[0], c1[1]*c2[1], c1[2]*c2[2]]

return c3

 

=== Screen ===

Смешивание цветов через перемножение первого компонентного и второго инвертированного:

def Screen(c1, c2):

c3 = [c1[0]*(255-c2[0]), c1[1]*(255-c2[1]), c1[2]*(255-c2[2])]

return c3

 

=== Lighten ===

Смешивание цветов через выборку наиболее светлых значений компонентов цветов:

def Lighten(c1, c2):

f = lambda x, y: x if x > y else y

c3 = [f(c1[0], c2[0]), f(c1[1], c2[1]), f(c1[2], c2[2])

return c3

 

=== Darken ===

Смешивание цветов через выборку наиболее темных значений компонентов цветов:

def Darken(c1, c2):

f = lambda x, y: x if x < y else y

c3 = [f(c1[0], c2[0]), f(c1[1], c2[1]), f(c1[2], c2[2])

return c3

 

= Основы Python в Blender =

=== Создание объектов ===

Для того чтобы создать объект в Object Mode с помощью Python надо в консоли или в текстовом редакторе (Text Editor) написать следующее:

Имя — название примитива с маленькой буквы. Например:

{| class="wikitable sortable"

! Код !! Описание

|-

|-

|-

|-

|-

|-

|-

|-

|-

|-

|-

# «POINT»

# «SUN»

# «AREA»

|-

|-

|-

# «PLANE_AXES» — Plane Axis

# «ARROWS» — Arrows

|}

Можно указать сразу и точное положение центра добавляемого объекта:

Например:

Вы можете также установить поворот объекта по каждой из осей с помощью rotation(x, y, z):

Создание синусоидноподобной фигуры:

for a in range(-10,10):

bpy.ops.mesh.primitive_uv_sphere_add(location=(a, 0, math.sin(a)))

for a in range(-10,10):

bpy.ops.mesh.primitive_uv_sphere_add(location=(0, a, math.sin(a)))

Визуализация списка списков:

matrix = [[10, 2, 3, 3, 6],

[4, 6, 4, 12, 5],

for x in range(0, 5):

for y in range(0, 5):

 

=== Затенение ===

! Код !! Описание

|-

|-

|}

 

! Функция !! Описание

|-

|-

|-

|}

У этих трех функций есть следующие параметры:

=== Копирование ===

Копирование осуществляется функцией:

Параметрами функции являются словари OBJECT_OT_dublicate и TRANSFORM_OT_translate.

<ol>

<li>

В первом из них содержится информация о том является ли это копирование копированием объекта или созданием связанной его копии:

Ключ «linked» позволяет установить как будет копироваться объект — если равно True, то создасться его связанная копия, иначе будет скопирован весь объект.

</li>

<li>Во втором хранятся сами данные преобразования объекта:

Здесь:

# x, y, z — значения перемещения по каждой из осей

</ol>

Пример использования функции:

 

=== Создание сцен ===

! Код !! Описание

|-

# <nowiki>"NEW"</nowiki> — соответствует New

# <nowiki>"EMPTY"</nowiki> — соответствует Copy Settings

# <nowiki>"FULL_COPY"</nowiki> соответствует Full Copy

|-

|}

 

! Код !! Описание

|-

|-

|-

|-

|-

|-

|}

 

! Код !! Описание

|-

|-

|-

|-

|-

|-

|}

 

! Код !! Примечание

|-

|-

|-

|}

 

! Код !! Текст заголовка

|-

|-

|-

|-

|}

 

! Код !! Текст заголовка

|-

|-

|}

 

=== Типы движка ===

Ниже «name» — имя любой сцены, с данными которой будем работать. Через словарь bpy.data.scenes можно получить имя используемого для рендеринга движка:

{| class="wikitable sortable"

|-

! Движок !! Название, хранящееся в bpy.data.scenes[«name»].render.engine

|-

|-

|-

|-

|}

Функция, устанавливающая тип движка по его номеру:

def SetEngine(scn, i):

engines = ['BLENDER_GAME', 'BLENDER_RENDER', 'CYCLES', 'BLEND4WEB']

i = 3

bpy.data.scenes[scn].render.engine = engines[i]

 

=== Класс bpy.types.ID ===

 

Получить доступ к сцене можно по ее имени — ключу в словаре scenes:

{| class="wikitable sortable"

|-

|}

Изменение имени камеры:

 

====== Данные текстур ======

|}

Изменение имени текстуры:

<li>

Класс текстуры с картинкой — bpy.types.ImageTexture(Texture).

|}

Изменение положения объекта по оси X:

 

==== Объекты и материалы ====

|}

Получение имени активного материала:

Данные материалов хранятся в словаре bpy.data.materials. Ниже «mat» — имя любого материала.

 

|}

Изменение имени материала:

 

==== Режимы редактирования ====

! Код !! Примечание

|-

|-

|-

|}

{| class="wikitable sortable"

! Код !! Примечание

|-

|-

|-

|-

# «MIX» — Mix

# «ADD» — Mix

# «DARKEN» — Darken

|-

# «DOTS» — Dots

# «SPACE» — Space

# «CURVE» — Curve

|-

|-

|-

|-

|-

|-

|}

 

! Код !! Примечание

|-

|-

|}

{| class="wikitable sortable"

! Код !! Примечание

|-

|-

|-

# «MIX» — Mix

# «ADD» — Mix

# «DARKEN» — Darken

|-

# «DOTS» — Dots

# «SPACE» — Space

# «CURVE» — Curve

|-

|-

|-

|-

|-

|-

|}

 

! Код !! Примечание

|-

|-

|-

|}

 

! Код !! Примечание

|-

# «NO_COLLISION» — No Collision

# «STATIC» — Static

# «SENSOR» — Sensor

|-

|-

|-

|-

|-

|-

|-

|-

|-

|-

|-

# «TRIANGLE_MESH» — Triangle Mesh

# «CONVEX_HULL» — Convex Hull

# «CAPSULE» — Capsule

|-

|-

|}

 

=== Переобозначения ===

Возможно укорачивать код с введением своих обозначений, например:

blCams = bpy.data.cameras

blTexs = bpy.data.textures

blObjs = bpy.data.objects

blMats = bpy.data.materials

Потом, например, вместо:

bpy.data.materials["Mat1"].emit

можно будет писать:

blMats["Mat1"].emit

 

= Профессиональный уровень =

|}

Получить контроллер, управляющий скриптом можно так:

А получить объект, у которого данный контроллер можно так:

 

=== Описание актуаторов ===

|}

Активировать актуатор можно через тот контроллер, к которому он подсоединен:

Где c — контроллер, a — актуатор.

Деактивация происходит подобным образом:

Где c — контроллер, a — актуатор.

 

|}

Пример скрипта, который автоматически раскрашивает вершины, в зависимости от координаты Z:

import math

cont = logic.getCurrentController() # получение контроллера, который запустил этот скрипт

vertex.color = [0.8, 0.744, 0.074, 1.0]

else:

Результат работы скрипта:

 

===== Алфабитные клавиши =====

В общем пишится:

{| class="wikitable sortable"

|-

=== Класс bge.types.KX_Scene(PyObjectPlus) ===

Класс bge.types.KX_Scene(PyObjectPlus) позволяет получить данные о сцене. А для получения сцены, в которой запущен данный скрипт следует писать:

Здесь a — объект сцены-владельца скрипта.

<ol>

<ol>

<li>Функция, которая позволяет проверить где находится точка по отношению к frustum имеет следующий вид:

Тут x, y, z — координаты центра точки.</li>

<li>Функция, которая позволяет проверить где находится сфера по отношению к frustum имеет следующий вид:

Где x, y, z — координаты центра сферы, а r — ее радиус.</li>

<li>Функция, которая позволяет проверить где находится параллелепипед по отношению к frustum имеет такой вид:

Здесь box — список, хранящий 8 списков (в которых хранятся по 4 координаты каждой точки). Например:

box.append([-1.0, -1.0, -1.0])

box.append([-1.0, -1.0, 1.0])

box.append([ 1.0, -1.0, 1.0])

box.append([ 1.0, 1.0, -1.0])

</li>

</ol>

|}

Настраивание лампы так, что она станет направленным источником света и будет светить красным:

import bge

 

light.energy = 3.0

light.color = [1.0, 0.0, 0.0]

Изменение яркости в зависимости от расстояния по закону синуса:

import bge, math

 

 

main()

 

===== Модели изменения силы света =====

# dist — расстояние на котором сила света не равна 0.

# plus_d — расстояние на котором сила света постепенно линейно возрастает от минимальной (min_energy) до максимальной (max_energy).

import bge, math

 

 

main()

# (d-const_dist) — узнаем дистанцию между объектом и лампой, отбросив расстояние const_dist

# plus_d-(d-const_dist) — разность между расстояниями для того, чтобы сила света увеличивалась, а не уменьшалась по приближению объекта

=== Изменение материалов с помощью bge.types.KX_BlenderMaterial(PyObjectPlus) ===

С помощью данного класса можно работать с материалами. Для доступа к конкретному материалу следует писать:

meshes — список, в котором хранятся ссылки на используемые в объекте меши, materials — список материалов, m — индекс меша для которого следует получить все имеющиеся на нем материалы, n — индекс материала. Причем, порядок элементов в meshes и materials соответствует друг другу.

Ниже M — материал.

|}

Пример создания меша:

В классе bmesh.types.BMesh есть такие последовательности:

# verts — список вершин меша

=== Работа с цветом с применением mathutils.Color ===

Этот класс нужен для работы с цветом. Объект цвет создается так:

n — имя объекта цвета; r, g и b — значения компонентов цвета.

 

Также можно узнавать r, g, b, h, s или v так:

Где c может быть одним из:

# r

=== Класс для работы с углами mathutils.Euler ===

С помощью mathutils.Euler Вы можете создавать углы Эйлера. Для создания инстанса класса пишите:

angles — список, состоящий из трех углов; порядок, в котором указываются углы устанавливается вторым параметром и может быть равен:

# 'XYZ'

# 'ZXY'

Например:

Получить значение аттрибутов можно следующим образом:

{| class="wikitable sortable"

=== Работа с векторами через класс mathutils.Vector ===

Класс для работы с векторами. Создается вектор так:

Где v — список, состоящий из 3-х компонентов вектора. Например:

Ниже n — вектор.

{| class="wikitable sortable"

|}

Включение видимости имен у всех выделенных объектов, положение которых по оси X>0:

import bpy

 

if C.selected_objects[i].location.x > 0:

C.selected_objects[i].show_name = True

 

== Системные данные ==

 

= Полезные скрипты =

# Скрипт создания объектов по кольцу

import bpy

bpy.ops.mesh.primitive_cone_add(location=(x, y, z))

else:

# Визуализация молекул

from math import degrees, acos

     bpy.ops.mesh.primitive_cylinder_add(radius=0.3, depth=(r2-r1).length,location=(r3.x,r3.y,r3.z))

     bpy.ops.transform.rotate(value=(angle,), axis=rot_axis)

# Класс для работы с векторами

# coding: utf8

    print "normal(%s): %s" % (v2, v2.normal())

    print "angle(%s, %s): %f" % (v2, v1, v2.angle(v1))

# Передвижение объекта

import bge

 

main()

import bge

 

sce = bge.logic.getCurrentScene()

 

# Проигрывание музыки по окончанию рендеринга

import bpy

 

bpy.app.handlers.render_complete.append(play)

# Выключение компьютера по окончанию рендеринга (вариант для Windows)

import bpy

 

bpy.app.handlers.render_complete.append(shutdown)

 

# Выключение компьютера по окончанию рендеринга (вариант для Linux)

import bpy

 

bpy.app.handlers.render_complete.append(shutdown)

 

import math

import bpy

# Пример использования:

EditMesh(-1, 0, 0, 0, 0, -1, 0.4, False, False, True)

# Вывод текста Hello world!

# импорт игровых модулей

blf.size(font_id, 50, 72)

blf.draw(font_id, "Hello World")

-->

 

| shiftY || искривление по оси Y

|}

from Blender import Camera, Object, Scene

cam = Camera.New("ortho") # создаем камеру (не указав на какой сцене она будет располагаться)

scn = Scene.GetCurrent() # получаем объект текущей сцены

obj = scn.objects.new(cam) # добавляем камеру на сцену scn

 

=== Подмодуль Blender.Lamp ===

| type || тип лампы («Lamp», «Sun», «Spot», «Hemi», «Area»)

|}

from Blender import Lamp, Scene

lamp1 = Lamp.New("Spot") # создаем лампу (не указав на какой сцене она будет располагаться)

scn = Scene.GetCurrent() # получаем объект текущей сцены

obj = scn.objects.new(lamp1) # добавляем лампу на сцену scn

 

=== Подмодуль Blender.Object ===

| sel || True, если объект выделен, иначе False

|}

import Blender

scn = Blender.Scene.GetCurrent() # получает текущую сцену

 

Blender.Redraw() # перерисовывает все 3D окна

 

=== Подмодуль Blender.Scene ===