Как написать скрипт для blender 3d

---

Содержание コンテンツ  

Blender 2.77 — практика 实践  

1. Рендеринг
   1. Game _{Примеры создания простых моделей для игр и самих игр, и материалов для игр. После изучения этой главы Вы будете способны создавать игры средней сложности.}
   2. Render _{Примеры использования движка Cycles Render с кратким описанием. В конце изучения этой главы Вы сможете быстрее разбираться в нодах.}
2. Игровая логика и программирование
   1. Game Logic _{Примеры настройки игровой логики в Blender. В конце прочтения этой главы Вы будете уметь создавать свою игровую логику.}
   2. Python практика _{Решение задач на Python с использованием Blender. После прочтения данной главы Вы приобретете навыки написания скриптов.}

Blender 2.49 — теория 이론  

Старый Blender _{Содержит информацию о Blender 2.49. После прочтения данной части книги Вы сможете назвать основные плюсы и минусы Blender 2.49.}

Blender 2.77 & 3DsMax 이론  

Blender & 3DsMax _{Сравнение Blender, 3DsMax, Sweet Home и Art Of Illusion. После прочтения этой главы Вы будете немного знать о различиях этих программ.}

Программирование 이론  

1. Python _{Этот раздел посвящен языку программирования Python и его использованию в Blender. После ее прочтения Вы будете немного ориентироваться в написании скриптов в Blender.}
2. OSL _{Здесь рассказывается о написании шейдеров на языке OSL.}
3. Немного об OpenGL _{Этот раздел посвящен библиотеке OpenGL. Послее его прочтения Вы будуте способны программировать на OpenGL.}
4. Введение в GLSL _{Немного о языке шейдеров GLSL. После его прочтения Вы сможете читать простые программы на этом языке.}
5. Основы Web технологий _{Здесь рассказывается о JS, Ajax и JSON. После изучения этого раздела Вы сможете легче ориентироваться в нодах, предназначенных для сети, в Blend4Web.}

Дополнительное 이론  

Постобработка изображений

1. Постобработка изображений _{Немного о постобработки изображений. После прочтения этой главы книги Вы будете более осведомлены об эффектах, которые можно применять для изображений.}

Музыкальное сопровождение

1. Music _{Список песен и мелодий, которые могут помочь насладиться процессом работы в Blender.}

CTRL+ALT+U	CTRL+U	SHIFT+S	CTRL+Q	A	R
G	S	SHIFT+D	ALT+D	CTRL+NUMPAD+	CTRL+NUMPAD-
SHIFT+L	SHIFT+G	ALT+M	F	CTRL+ALT+SHIFT+C	SHIFT+S
D	T	I	Shift+B	B	C

Одни из главных классов Python: bpy.ops | bpy.data | bpy.types.ID

Расположение элементов интерфейса

Введение[править]

Python — это интерпретируемый высокоуровневый язык программирования, который упростит Вашу работу в Blender. Писать скрипты на нем можно в Text Editor.

Типы[править]

Тип — это именованное множество значений.

Описание[править]

В Python есть следующие типы: str (строка — обычный текст), int (любое целое число), float (вещественное число).

Str[править]

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

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

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

И это тоже:

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

Int[править]

Целые числа называются в данном языке программирования как int. Например: 10.

Float[править]

1. Float — обычная десятичная дробь. Только вместо запятой в программировании используется точка: не 0,5, а 0.5.
2. Также существуют так называемые числа с «плавающей запятой». Это числа такого вида: NeM. Где N — мантиса, а M — степень числа 10, на которое умножается N. Например: 3e6.

Операции для типов[править]

1. Существуют следующие операции для целых чисел в Python: + (сложение), — (вычитание), * (умножение), ** (возведение в степень), // (деление с отбрасыванием остатка), % (деление с отбрасыванием всего кроме остатка). Например: 2**2 = 4.
2. Для типа float есть такие операции: + (сложение), — (вычитание), * (умножение), ** (возведение в степень).
3. Для строк характерна такая операция как сложение (она просто склеит две строки в одну). Например: ‘A’ + ‘S’ = ‘AS’.
4. Но если для типа float применить операции: ** или %, то числа этого типа станут числами типа int.
5. Также если возводить в отрицательную или дробную степень целое число, то оно преобразуется в число типа float.

Линейные программы[править]

Переменные[править]

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

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

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

Списки[править]

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

имя = [значение1, значение2, ... , значениеN]

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

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

s = 'Hi user'
a = []
a = s.split(разделитель)

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

a = ['a', 'b', 'c']
s = заполнитель.join(a)

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

Операции со списками[править]

1. n.append(v) добавит элемент в конец списка.
2. n.extend(L) добавит все элементы списка L в конец списка n.
3. n.insert(i, m) вставляет элемент в список n в место с индексом i.
4. n.remove(i) удалит из списка n элемент с индексом i.
5. n.index(i, s, e) возвращает индекс первого элемента в списке со значение i, смотря список в диапазоне от s до e.
   1. s = 0, e = len(n)-1 по умолчанию. Эти параметры можно не указывать.
6. n.count(v) предназначен для получения количества элементов v в списке.

Кортежи[править]

Кортеж — неизменяемый список. Поддерживает все функции работы со списками, которые не изменяют списки.

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

a = (v, k, d, ... , p, r)

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

Например:

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

a = tuple('string') # получим кортеж ('s', 't', 'r', 'i', 'n', 'g')

Множества[править]

Множество почти то же что и список, только с рядом ограничений:

1. Нет индексации элементов — они располагаются в памяти в случайном порядке.
2. Как следствие, в множестве не может быть двух и более элементов с одинаковыми значениями.

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

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

a = set('aaajs') # результат {'a', 'j', 's'}

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

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

Операции с множествами[править]

1. s.update(a, b, … n) — объединить все множества. Получится множество, в которое вошли элементы всех множеств.
2. s.intersection_update(a, b, … n) — найти пересечение множеств. На выходе будет множество, в котором находятся элементы, которые есть в каждом из перечисленных множеств.
3. s.difference_update(a, b, … n) — вычесть все множества из s. Будут убраны все элементы множеств, указанных в скобках, из s.
4. s.add(e) добавляет элемент в множество.
5. s.discard(e) — удаление элемента со значением e из множества s.
6. s.clear() — удаляет все элементы из множества.

Словари[править]

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

a = {ключ:значение, ... , ключN:значениеN}

Например:

a = {'year':'2016','date':'19:08:16'}

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

a = dict(ключ=значение, ... , ключN=значениеN)

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

a = dict.fromkeys([список])

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

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

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

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

a = {'a':1, 'b':2, 's':4}
print(a['s'])

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

Словари располагают такими функциями работы над ними:

1. d.clear() — удаляет все из словаря.
2. d.copy() — возвращает копию словаря.
3. d.get(k, v) — вернет значение из словаря d по ключу k, если же его нет то вернет значие v (по умолчанию None).
4. d.keys() — вернет список, состоящий из всех ключей словаря.
5. d.items() — вернет список, состоящий из всех значений словаря.

Ввод и вывод[править]

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

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

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

Нелинейные программы[править]

Когда в программах нужно проверить какие либо условия либо повторить что-то несколько раз на помощь приходят: if, while и for операторы.

Оператор if[править]

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

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

a = int(1)
if a == 1:
    print('a ранво 1')

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

if условие:
    # команды
elif условие:
    # команды
else:
    # команды

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

Тип bool[править]

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

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

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

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

Условия для множеств[править]

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

1. a.isdisjoint(b) — результат будет True, если общих элементов у множеств нет.
2. Операция == в выражении «a == b» приобретет смысл «множества a и b полностью совпадают».
3. А запись «a < b» означает «множество a является подмножеством b».
   1. Аналогично и для <.

Оператор while[править]

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

Например:

a = int(1)
while a <= 10:
    a = a + 1

for[править]

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

for переменная in диапазон:
    команды

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

a = [1, 2, 3]
ind = 0
for s in 'a', 'b', 'c':
    print('Букве ', a[ind],'соответствует номер ',s)
    ind = ind + 1

Сложные условия[править]

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

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

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

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

a = 'a'
if not (a == 'd'):
    print('true')

Функции[править]

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

def имя(a,b,c...n)
    # команды

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

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

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

def Summ(a,b)
    return a+b

K = Summ(2,5)

Лямбды[править]

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

lambda параметры: результат

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

Вернет x².

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

имя = lambda параметры: результат

Например:

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

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

def F(x):
   return x**2

f = lambda x: x**2

d = f(3) # вызов лямбды
d = F(3) # вызов функции

Условия в лямбда-функциях[править]

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

lamba параметры: выражение if условие

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

f = lamba x: x**2 if x > 0
a = 0
print(f(a)) # на экран выведется 0

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

lamba параметры: выражение if условие else выражение2

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

f = lamba x: x**2 if x > 0 else 123
a = 0
print(f(a)) # на экран выведется 123

Вложенные лямбда-функции[править]

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

lambda параметры: (lambda параметры2: результат)

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

f = lambda x: (lambda j: x*j)
a = f(10)

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

f1 = f(параметры)
f2 = f1(параметры)
...
fN = fM(параметры)

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

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

Lmain = lambda x: (lambda y: (lambda z: x+y+z))
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

Исключения[править]

Исключения — это ошибки, обнаруженные при выполнении программы. Существуют как системное исключения, так и обычные.

Системные исключения[править]

1. SystemExit — исключение, порождаемое функцией sys.exit при выходе из программы.
2. KeyboardInterrupt — возникает при прерывании программы сочетанием клавиш пользователем.

Обычные исключения[править]

1. StopIteration — исключение, сигнализирующее, что итератор цикла for не может дальше продолжаться, так как цикл for исчерпал доступные значения(если в итераторе нет элементов).
2. Арифметические ошибки (класса ArithmeticError):
   1. ArithmeticError.FloatingPointError возникает при неудачном выполнении операции с плавающей запятой.
   2. ArithmeticError.OverflowError появляется при невозможности удержать в памяти результат некоторой арифметической операции из-за того, что ее результат слишком велик.
   3. ArithmeticError.ZeroDivisionError — ошибка деления на 0.
3. Остальные исключения:
   1. AttributeError — у класса данного объекта нет атрибута, на который Вы сослались.
   2. EOFError — функция не смогла выполнить некоторую операцию, так как наткнулась на конец файла.
   3. ImportError — ошибка при попытке импортировать модуль.
   4. MemoryError возникает при нехватке памяти для работы программы.
   5. RuntimeError такая ошибка, которая не является ни одным выше указанным исключением.

Синтаксические ошибки[править]

В отдельную группу можно отнести синтаксические ошибки. Все они наследуются от класса SysntaxError.

1. IndentationError — исключение, порождаемое интерпретатором при неправильных отступах.
2. TabError — смешивание пробелов и табуляции (через клавишу Tab).

Конструкция try — except[править]

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

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

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

a = 3
b = int(input())
try
   a = a / b
except ZeroDivisionError:
   b = 1

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

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

a = 3
b = int(input())
try
   a = a / b
except ArithmeticError:
   b = 1

Импорт[править]

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

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

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

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

from modulemy import proc1, proc2, proc3

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

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

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

Генераторы[править]

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

имя = [формула for переменная in range()]

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

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

a = [n**2 for n in range(0,10,1)]

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

имя = [формула for переменная in строка]

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

a = [c**3 for c in 'Example']

Генераторы с условиями[править]

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

имя = [формула for переменная in range() if условие]

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

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

a = [x for x in range(0,100,1) if x % 2 == 0]

Вложенные генераторы[править]

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

имя = [формула for переменная in range() for переменная2 in range()]

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

for переменная2 in range()

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

a = [c + d for c in 'ab' for d in 'ef'] # результатом будет список ['ae', 'af', 'be', 'bf']

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

a = [c + d for c in 'ab' for d in 'erf' if d != r] # результатом будет список ['ae', 'af', 'be', 'bf']

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

a = [c + d + p + s for c in 'ab' for d in 'ef' for p in 'tu' for s in 'qw']

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

1. Переменная самого вложенного генератора всегда изменяется первой.
2. Когда эта переменная доходит до конца своего диапазона, она принимает опять первое значение своего диапазона; также значение перемен ной внешнего генератора сдвигается на следующее значение в диапазоне.
3. И так далее.

Классы[править]

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

class имя:
    # содержание класса

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

def __init__ (self):
    # команды

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

@classmethod def f ():
    # команды

Переменные классов[править]

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

Создание инстансов[править]

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

имя = класс(параметры_конструктора)

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

class t:
    time
    def __init__(self,T):
        self.time = T

a= t(10)

Дополнение[править]

Работа с файлами[править]

f = open('name.txt','m')

a = [k for k in f.readlines()]

Модуль random[править]

1. random.randrange(start, stop, step) — возвращает случайно выбранное число из последовательности, которая начинается с start, заканчивается end и идет с шагом step
2. random.random() — случайное число от 0 до 1

Черепашья графика[править]

Самый простой модуль для рисования — turtle.

Функции перемещения[править]

Функции рисования[править]

Дополнительные функции[править]

Пример рисования[править]

import turtle

turtle.reset()
turtle.down()
turtle.forward(35)
turtle.left(55)
turtle.up()
turtle.forward(30)


turtle.goto(100,150)
turtle.down()
turtle.color("red")
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[править]

Модуль bpy.ops[править]

Создание объектов[править]

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

bpy.ops.mesh.primitive_имя_add()

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

bpy.ops.mesh.primitive_plane_add()

bpy.ops.mesh.primitive_cube_add()

bpy.ops.mesh.primitive_circle_add()

bpy.ops.mesh.primitive_uv_sphere_add()

bpy.ops.mesh.primitive_ico_sphere_add()

bpy.ops.mesh.primitive_cylinder_add()

bpy.ops.mesh.primitive_cone_add()

bpy.ops.mesh.primitive_torus_add()

bpy.ops.mesh.primitive_grid_add()

bpy.ops.mesh.primitive_monkey_add()

bpy.ops.object.lamp_add(type = T)

bpy.ops.object.text_add()

bpy.ops.object.armature_add()

bpy.ops.object.empty_add(type = T)

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

Например:

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

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

bpy.ops.mesh.primitive_plane_add(rotation=(x, y, z))

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

import bpy, math
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)))

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

import bpy
matrix = [[10, 2, 3, 3, 6],
         [4, 6, 4, 12, 5],
         [0, -1, 5, 8, 9],
         [0, 1, 1, 3, 15],
         [4, 12, 0, 0, 13]]
for x in range(0, 5):
    for y in range(0, 5):
        bpy.ops.mesh.primitive_plane_add(location = (x*4, y*4, matrix[x][y]))

Затенение[править]

bpy.ops.object.shade_smooth()

bpy.ops.object.shade_flat()

Движение, вращение и масштабирование[править]

bpy.ops.transform.translate()

bpy.ops.transform.rotate()

bpy.ops.transform.resize()

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

Копирование[править]

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

bpy.ops.object.dublicate_move()

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

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

   OBJECT_OT_dublicate = {"linked":False, "mode":"TRANSLATION"}
   

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

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

   TRANSFORM_OT_translate = {"value":(x, y, z), "constraint_axis":(cX, cY, cZ), "constraint_orientation":"T", "proportional":"ED", "proportional_edit_falloff":"FT", "proportional_size":S}
   

   Здесь:

   1. x, y, z — значения перемещения по каждой из осей
   2. cX, cY, cZ — логические значения, указывающие по каким осям объект не перемещается (False)
   3. «T» — тип системы координат
   4. ED — значение, указывающее включено ли пропорциональное моделирования
   5. «FT» — тип пропорционального моделирования
   6. S — радиус влияния пропорционального моделирования

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

bpy.ops.object.dublicate_move(OBJECT_OT_dublicate = {"linked":False, "mode":"TRANSLATION"}, TRANSFORM_OT_translate = {"value":(0, 2, 2), "constraint_axis":(True, False, False), "constraint_orientation":"GLOBAL", "proportional":"ENABLE", "proportional_edit_falloff":"SPHERE", "proportional_size":4})

Создание сцен[править]

Ниже «name» — имя любой сцены, с данными которой будем работать.

bpy.ops.scenes.new(type = T)

bpy.ops.scenes.remove()

Управление режимами редактирования[править]

bpy.ops.object.mode_set(mode="OBJECT")

bpy.ops.object.mode_set(mode="EDIT")

bpy.ops.object.mode_set(mode="SCULPT")

bpy.ops.object.mode_set(mode="VERTEX_PAINT")

bpy.ops.object.mode_set(mode="WEIGHT_PAINT")

bpy.ops.object.mode_set(mode="TEXTURE_PAINT")

Управление Weight Paint[править]

bpy.ops.object.vertex_group_normalize()

bpy.ops.object.vertex_group_mirror()

bpy.ops.object.vertex_group_invert()

bpy.ops.object.vertex_group_clean()

bpy.ops.object.vertex_group_quantize()

bpy.ops.paint.weight_gradient()

Управление Vertex Paint[править]

Ниже «P» — имя палитры.

bpy.ops.palette.color_add()

bpy.ops.palette.color_delete()

bpy.ops.palette.new()

Редактор логики — свойства[править]

Ниже a — активный объект, со свойствами которого работаем.

bpy.ops.object.game_property_new(name = "P")

bpy.ops.object.game_property_move(index = i, direction = 'UP')

bpy.ops.object.game_property_move(index = i, direction = 'DOWN')

bpy.ops.object.game_property_remove(index = i)

Управление слотами материалов[править]

bpy.ops.object.material_slot_add()

bpy.ops.object.material_slot_remove()

Добавление логических блоков[править]

Создание сенсоров[править]

Создание контроллеров[править]

Создание актуаторов[править]

Применение модуля bpy.data[править]

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

Типы движка[править]

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

bpy.data.scenes["name"].render.engine

"BLENDER_GAME"

"BLENDER_RENDER"

"CYCLES"

"BLEND4WEB"

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

def SetEngine(scn, i):
    engines = ['BLENDER_GAME', 'BLENDER_RENDER', 'CYCLES', 'BLEND4WEB']
    if i < 0:
        i = 0
    if i > 3:
        i = 3
    bpy.data.scenes[scn].render.engine = engines[i]

Класс bpy.types.ID[править]

Уникальный идентификатор некоторого блока данных. Доступ к которому можно получить, например через bpy.data.

Работа со сценой[править]

Данные сцены[править]

Класс сцены — bpy.types.Scene(ID).

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

Данные мира[править]

Класс сцены — bpy.types.World(ID).

Класс настроек тумана — bpy.types.WorldMistSettings(bpy_struct).

Данные объектов сцены[править]

Данные камер[править]

Класс камеры — bpy.types.Camera(ID).

Данные камер хранятся в словаре bpy.data.cameras. Ниже «Camera» — имя произвольной существующей камеры.

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

bpy.data.cameras['Camera'].name = "MyCam1"

Данные текстур[править]

1. Класс текстуры — bpy.types.Texture(ID).

   Данные текстур хранятся в словаре bpy.data.textures. Ниже «Tex» — любая текстура.

   Код	Описание
   contrast	контраст (от 0.0 до 1.0)
   type	тип текстуры ‘IMAGE’ ‘BLEND’ ‘CLOUDS’ ‘DISTORTED_NOISE’ ‘ENVIRONMENT_MAP’ ‘MAGIC’ ‘MARBLE’ ‘MUSGRAVE’ ‘NOISE’ ‘POINT_DENSITY’ ‘STUCCI’ ‘VORONOI’ ‘WOOD’
   name	имя текстуры (унаследовано от класса ID)
   use_fake_user	использовать ли фейкового пользователя (унаследовано от класса ID)

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

   bpy.data.textures['Tex'].name = "MyCam1"
   

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

   Свойство	Описание
   extension	внешний вид изображения за своими реальными границами «EXTEND» «CLIP» «CLIP_CUBE» «REPEAT» «CHECKER»
   repeat_x	количество изображений по X, которые вместятся в реальные границы изображения
   repeat_x	количество изображений по Y, которые вместятся в реальные границы изображения
   invert_alpha	инвестировать все значения альфа канала
   use_checker_even	использовать ли четные положения для расположения текстуры на шахматной доске
   use_checker_odd	использовать ли нечетные положения для расположения текстуры на шахматной доске
   image	используемое изображение
   name	имя текстуры (унаследовано от класса ID)
   use_fake_user	использовать ли фейкового пользователя (унаследовано от класса ID)

3. Класс картинки — bpy.types.Image(ID).

   Код	Описание
   contrast	контраст (от 0.0 до 1.0)
   file_format	формат изображения «BPM» «PNG» «JPG» и остальные
   filepath	путь к изображению
   mapping	тип наложения картинки в игровом движке «UV» «REFLECTION»
   size (только для чтения)	размер изображения в пикселях, представленный в виде кортежа [x, y] (x — количество пикселей по X, y — количество пикселей по Y)
   name	имя картинки (унаследовано от класса ID)
   use_fake_user	использовать ли фейкового пользователя (унаследовано от класса ID)

Области просмотра[править]

Класс разметки экрана — bpy.types.Screen(ID).

Области экрана[править]

Класс области экрана, в которой находится редактор — bpy.types.Area(bpy_struct).

Свойства объекта[править]

Класс объекта — bpy.types.Object(ID).

Данные объектов хранятся в словаре bpy.data.objects. Ниже «name» — имя любого объекта, с данными которого будем работать.

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

bpy.data.objects["name"].location[0] = 1

Объекты и материалы[править]

Все изложенное ниже можно применять как в интерактивном режиме, так и просто написав в виде скрипта. Ниже «name» — имя любого объекта, с данными которого будем работать.

Некоторые свойства, связанные с материалами можно получить через словарь bpy.data.objects.

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

a = bpy.data.objects["name"].active_material

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

Класс материала — bpy.types.Material(ID).

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

bpy.data.materials["mat"].name = "MyMat1"

Режимы редактирования[править]

Weight Paint[править]

Класс кисти — bpy.types.Brush(ID).

Ниже «Scene» — название сцены, на которой будут меняться настройки кисти; «B» — название кисти.

bpy.data.scenes["Scene"].tool_settings.unified_paint_settings.weight

bpy.data.scenes["Scene"].tool_settings.unified_paint_settings.size

bpy.data.scenes["Scene"].tool_settings.unified_paint_settings.strength

bpy.data.brushes["B"].weight

bpy.data.brushes["B"].size

bpy.data.brushes["B"].strength

bpy.data.brushes["B"].vertex_tool

bpy.data.brushes["B"].stroke_method

bpy.data.brushes["B"].jitter

bpy.data.brushes["B"].use_smooth_stroke

bpy.data.brushes["B"].smooth_stroke_radius

bpy.data.brushes["B"].smooth_stroke_factor

bpy.data.brushes["B"].spacing

bpy.data.brushes["B"].rate

Vertex Paint[править]

Ниже «Scene» — название сцены, на которой будут меняться настройки кисти; «B» — название кисти.

bpy.data.scenes["Scene"].tool_settings.unified_paint_settings.size

bpy.data.scenes["Scene"].tool_settings.unified_paint_settings.strength

bpy.data.brushes["B"].size

bpy.data.brushes["B"].strength

bpy.data.brushes["B"].vertex_tool

bpy.data.brushes["B"].stroke_method

bpy.data.brushes["B"].jitter

bpy.data.brushes["B"].use_smooth_stroke

bpy.data.brushes["B"].smooth_stroke_radius

bpy.data.brushes["B"].smooth_stroke_factor

bpy.data.brushes["B"].spacing

bpy.data.brushes["B"].rate

Специфичные для Vertex Paint[править]

Ниже «P» — имя палитры.

bpy.data.brushes["B"].color

bpy.data.palettes["P"].name

bpy.data.palettes["P"].use_fake_user

Физические настройки объекта[править]

Ниже «name» — имя любого объекта, с данными которого будем работать.

bpy.data.objects["name"].game.physics_type

bpy.data.objects["name"].game.use_actor

bpy.data.objects["name"].game.use_ghost

bpy.data.objects["name"].game.use_record_animation

bpy.data.objects["name"].game.hide_render

bpy.data.objects["name"].game.radius

bpy.data.objects["name"].game.use_anisotropic_friction

bpy.data.objects["name"].game.friction_coefficients[0]

bpy.data.objects["name"].game.friction_coefficients[1]

bpy.data.objects["name"].game.friction_coefficients[2]

bpy.data.objects["name"].game.use_collision_bounds

bpy.data.objects["name"].game.collision_bounds_type

bpy.data.objects["name"].game.collision_margin

bpy.data.objects["name"].game.use_collision_compound

Переобозначения[править]

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

blCams = bpy.data.cameras
blTexs = bpy.data.textures
blObjs = bpy.data.objects
blMats = bpy.data.materials

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

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

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

Профессиональный уровень[править]

Blender Game Engine[править]

Схема работы в BGE[править]

1. Все подключенные к контроллеру Python сенсоры посылают ему сигналы, а он их обрабатывает.
2. Также можно с помощью скрипта использовать подключенные к контроллеру Python актуаторы.

Главные типы[править]

1. class bge.types.PyObjectPlus — класс большинства объектов в игровом движке BGE.
2. Вот так выглядит упрощенная схема классов в BGE:

Описание сенсоров[править]

Сенсор Always всегда активен.

Описание контроллеров[править]

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

a = bge.logic.GetCurrentController()

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

Описание актуаторов[править]

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

Где c — контроллер, a — актуатор.
Деактивация происходит подобным образом:

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

Константы[править]

Состояния логических блоков[править]

Сенсоры[править]

Состояния[править]

Для состояний есть следующие константы:

1. bge.logic.KX_STATE1
2. bge.logic.KX_STATE2
3. bge.logic.KX_STATE3
4. bge.logic.KX_STATE4
5. bge.logic.KX_STATE5
6. bge.logic.KX_STATE6
7. bge.logic.KX_STATE7
8. bge.logic.KX_STATE8
9. bge.logic.KX_STATE9
10. bge.logic.KX_STATE10
11. bge.logic.KX_STATE11
12. bge.logic.KX_STATE12
13. bge.logic.KX_STATE13
14. bge.logic.KX_STATE14
15. bge.logic.KX_STATE15
16. bge.logic.KX_STATE16
17. bge.logic.KX_STATE17
18. bge.logic.KX_STATE18
19. bge.logic.KX_STATE19
20. bge.logic.KX_STATE20
21. bge.logic.KX_STATE21
22. bge.logic.KX_STATE22
23. bge.logic.KX_STATE23
24. bge.logic.KX_STATE24
25. bge.logic.KX_STATE25
26. bge.logic.KX_STATE26
27. bge.logic.KX_STATE27
28. bge.logic.KX_STATE28
29. bge.logic.KX_STATE29
30. bge.logic.KX_STATE30

Изменение меша в BGE[править]

За меш в BGE отвечает класс bge.types.KX_MeshProxy(SCA_IObject).

Также есть и некоторые переменные класса:

1. numPolygons — количество полигонов меша
2. materials — список всех материалов меша

Класс вершины bge.types.KX_VertexProxy(SCA_IObject)[править]

При работе с вершиной следует учитывать, что начальной точкой системы координат для каждого объекта является его собственный центр.

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

from bge import logic
import math
cont = logic.getCurrentController() # получение контроллера, который запустил этот скрипт
object = cont.owner # получение объекта, у которого есть контроллер, запустивший этот скрипт

BorderMinZ, BorderMaxZ = -4, 4 # границы раскраски
R = abs(BorderMinZ)+abs(BorderMaxZ)
for mesh in object.meshes:
    for m_index in range(len(mesh.materials)):
        for v_index in range(mesh.getVertexArrayLength(m_index)):
            vertex = mesh.getVertex(m_index, v_index)
            if (vertex.z >= BorderMinZ) and (vertex.z <= BorderMinZ+R*0.25):
                vertex.color = [0.093, 0.105, 0.8, 1.0]
            elif (vertex.z >= BorderMinZ+R*0.25) and (vertex.z <= BorderMinZ+R*0.5):
                vertex.color = [0.139, 0.8, 0.140, 1.0]
            elif (vertex.z >= BorderMinZ+R*0.5) and (vertex.z <= BorderMinZ+R*0.75):
                vertex.color = [0.8, 0.744, 0.074, 1.0]
            else:
                vertex.color = [0.8, 0.077, 0.87, 1.0]

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

Класс полигона bge.types.KX_PolyProxy(SCA_IObject)[править]

Класс bge.events[править]

Данный класс предназначен для работы с клавишами. Он содержит следующие константы:

Кнопки мыши[править]

Клавиатура[править]

Алфабитные клавиши[править]

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

bge.events.имя_клавишиKEY

Класс bge.types.KX_Scene(PyObjectPlus)[править]

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

from bge import logic
a = logic.getCurrentScene()

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

1. Любая сцена располагает следующими атрибутами, доступными сейчас только для чтения:
   

   Имя атрибута сцены	Описание	Возвращаемое значение
   name	Имя сцены	string
   objects	Список всех объектов в сцене	CListValue of KX_GameObject
   lights	Список источников света в сцены	CListValue of KX_LightObject
   cameras	Список всех камер на сцене	CListValue of KX_Camera
   active_camera	Ссылка на объект — текущую камеру	KX_Camera
   world	Хранит ссылку на объект мира, который используется в данный момент	KX_WorldInfo
   gravity	Устанавливает вектор гравитации	Vector((gx, gy, gz))
   pre_draw	Список всех функций, вызываемых перед рендерингом сцены	list
   post_draw	Список всех функций, вызываемых после рендеринга сцены	list

2. Также можно работать со сценой следующими способами:
   

   Имя функции	Описание	Параметры	Возвращаемое значение
   addObject(object, reference, time=0)	Добавляет на сцену объект	object — имя объекта, который следует добавить reference — имя объекта, в центр которого следует поместить добавленный объект time — время жизни объекта (если = 0, то объект живет вечно)	object, reference — KX_GameObject or string; time — integer
   end()	Удаляет из игры сцену	нет параметров	нет параметров
   restart()	Перезапускает сцену	нет параметров	нет параметров
   replace()	Перезапускает сцену	scene — имя сцены, на которую следует заменить	scene — string

Класс bge.types.KX_WorldInfo(PyObjectPlus)[править]

У тумана есть следующие атрибуты:

KX_GameObject(SCA_IObject)[править]

Данный класс — главный класс, от которого все остальные классы объектов являются потомками. В нем есть следующие свойства.

Ниже a — имя объекта.

Есть следующие функции для объекта:

1. applyMovement(movement, local=False) — переместить объект (тут movement — трехмерный вектор, указывающий перемещение по каждой оси; local = True означает, что тело будет двигаться в локальном пространстве, а при False — в глобальном)
2. applyForce(force, local=False) — переместить объект (тут force — трехмерный вектор, указывающий перемещение по каждой оси; local = True означает, что тело будет двигаться в локальном пространстве, а при False — в глобальном)
3. applyRotation(rotation, local=False) — повернуть объект (тут rotation — трехмерный вектор, указывающий угол поворота по каждой оси; local = True означает вращать в локальном пространстве, а при False — в глобальном)
4. applyTorque(torque, local=False) — повернуть объект с затуханием силы поворота (тут torque — трехмерный вектор, указывающий угол поворота по каждой оси; local = True означает вращать в локальном пространстве, а при False — в глобальном)
5. setParent(parent, compound=True, ghost=True) — установить родителя для объекта (parent — объект-родитель; при compound = True физические границы объектов будут объединены; при ghost = True пока объект имеет родителя он будет являться призраком)
6. addDebugProperty(name, debug = True) — включить/выключить отображение игрового свойства с именем name (включено при debug = True)
7. sendMessage(subject, body=»«, to=»») — отправить сообщение с темой subject, телом body, к объекту с именем, указанном в параметре to.

Класс bge.types.KX_Camera(KX_GameObject)[править]

Данный класс нужен для работы с объектами‐камерами.

Ниже a — камера.

Функция	Описание
a.getScreenPosition(object)	Вернет список, содержащий относительные X и Y (от 0 до 1) спроецированного на экран центра объекта object.

Работа с Frustum[править]

Frustum — усеченная пирамида. На пересечение с ней можно проверять как параллелепипед, так и сферу. Ниже a — объект-камера.

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

   cam.sphereInsideFrustum([x, y, z])
   

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

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

   cam.sphereInsideFrustum([x, y, z], r)
   

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

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

   cam.boxInsideFrustum(box)
   

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

   box = []
   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])
   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])
   

Класс KX_LightObject(KX_GameObject)[править]

Этот класс нужен для настройки источников освещения.

Ниже L — источник освещения.

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

import bge

co = bge.logic.getCurrentController()
light = co.owner

light.type = KX_LightObject.SPOT
light.energy = 3.0
light.color = [1.0, 0.0, 0.0]

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

import bge, math

def main():
    cont=bge.logic.getCurrentController()
    player=cont.owner
    
    lamp=bge.logic.getCurrentScene().lights['Lamp']
    lamp.energy = math.sin(math.sqrt((player.localPosition.x-lamp.localPosition.x)**2+(player.localPosition.y-lamp.localPosition.y)**2+(player.localPosition.z-lamp.localPosition.z)**2))+2

main()

Модели изменения силы света[править]

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

import bge, math

def main():
    cont=bge.logic.getCurrentController()
    player=cont.owner
    
    dist = 100
    plus_d = 50
    const_dist = dist - plus_d
    max_energy = 2.0
    
    lamp=bge.logic.getCurrentScene().lights['Lamp']
    d = math.sqrt((player.localPosition.x-lamp.localPosition.x)**2+(player.localPosition.y-lamp.localPosition.y)**2+(player.localPosition.z-lamp.localPosition.z)**2)
    if d > dist:
        lamp.energy = 0
    elif d < const_dist:
        lamp.energy = max_energy
    else:
        lamp.energy = ((plus_d-(d-const_dist))/plus_d)*max_energy

main()

1. (d-const_dist) — узнаем дистанцию между объектом и лампой, отбросив расстояние const_dist
2. plus_d-(d-const_dist) — разность между расстояниями для того, чтобы сила света увеличивалась, а не уменьшалась по приближению объекта
3. (((plus_d-(d-const_dist))/plus_d) — узнаем какую часть от plus_d составляет текущее инвертированное расстояние с отбросом const_dist
4. ((plus_d-(d-const_dist))/plus_d)*max_energy — получаем силу свечения

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

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

obj.meshes[m].materials[n]

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

Непосредственное редактирование меша[править]

Для возможности изменения меша следует использовать класс bmesh. Редактирование не для BGE.

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

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

1. verts — список вершин меша
2. edges — список ребер меша
3. faces — список полигонов меша

Класс вершины bmesh.types.BMVert[править]

Этот класс располагает возможностями по изменению свойств вершин меша.

Класс ребра bmesh.types.BMEdge[править]

Этот класс располагает возможностями по изменению свойств ребер меша.

С помощью функции calc_length() можно узнать длину ребра.

Класс полигона bmesh.types.BMFace[править]

Этот класс располагает возможностями по изменению свойств полигонова, входящих в меш.

Ниже f — полигон.

Последовательности данных меша[править]

Класс списка вершин bmesh.types.BMVertSeq[править]

Класс списка ребер bmesh.types.BMEdgeSeq[править]

Класс списка полигонов bmesh.types.BMFaceSeq[править]

Модуль math[править]

Класс для математических операций mathutils[править]

Данный класс предназначен для проведения некоторых математических операций.

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

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

n = mathutils.Color(r, g, b)

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

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

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

1. r
2. g
3. b
4. h
5. s
6. v

Класс для работы с углами mathutils.Euler[править]

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

n = mathutils.Euler(angles, O)

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

1. ‘XYZ’
2. ‘YXZ’
3. ‘YZX’
4. ‘XZY’
5. ‘ZXY’

Например:

Euler1 = mathutils.Euler([0,0,math.radians(45)], order='XYZ')

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

Здесь a — угол Эйлера.

Работа с векторами через класс mathutils.Vector[править]

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

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

n = mathutils.Vector((0.0,3.0,5.0))

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

Настройка окна при помощи bge.render[править]

Модуль bge.render содержит следующие функции для работы с окном:

Работа с контекстом через bpy.context[править]

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

import bpy

C = bpy.context

if len(C.selected_objects) > 0:
    for i in range(len(C.selected_objects)):
        if C.selected_objects[i].location.x > 0:
            C.selected_objects[i].show_name = True

Системные данные[править]

Системные данные можно узнать через модуль bpy.app.

Удаленные функции и свойства[править]

Для KX_GameObject(SCA_IObject):

1. orientation
2. scaling

Ошибки в консоли[править]

Полезные скрипты[править]

# Скрипт создания объектов по кольцу
import bpy
from math import radians, cos, sin

# AngleArray - создает массив объектов по окружности.
# RotationAngle - угол поворота последющего элемента относительно предыдущего
# MaxRotation - длина дуги поворота в грудусах
# Size - радиус окружности, на которой лежит дуга
# Type - тип элементов (мешей)

def AngleArray(RotationAngle, MaxRotation, Size,type):
    # Получаем положение курсора
    cursor = bpy.context.scene.cursor_location
    # Задаём радиус окружности
    radius = Size
    # Пространство между кубами по окружности составляет 36 градусов
    # Получаем список углов преобразующихся в радианы
    anglesInRadians = [radians(degree) for degree in range(0,MaxRotation,RotationAngle)]
    # В цикле определяем х, у в полярных координатах и создаём объект
    for theta in anglesInRadians:
        x = cursor.x + radius * cos(theta)
        y = cursor.y + radius * sin(theta)
        z = cursor.z
        if type == 'plane':
            bpy.ops.mesh.primitive_plane_add(location=(x, y, z))
        elif type == 'cube':
            bpy.ops.mesh.primitive_cube_add(location=(x, y, z))
        elif type == 'circle':
            bpy.ops.mesh.primitive_circle_add(location=(x, y, z))
        elif type == 'uv sphere':
            bpy.ops.mesh.primitive_uv_sphere_add(location=(x, y, z))
        elif type == 'ico sphere':
            bpy.ops.mesh.primitive_ico_sphere_add(location=(x, y, z))
        elif type == 'cylinder':
            bpy.ops.mesh.primitive_cylinder_add(location=(x, y, z))
        elif type == 'cone':
            bpy.ops.mesh.primitive_cone_add(location=(x, y, z))
        else:
            bpy.ops.mesh.primitive_torus_add(location=(x, y, z))

# Визуализация молекул
from math import degrees, acos
from mathutils import Vector
 
spheres = (Vector((2,3,3)),Vector((1,1,2)),Vector((2,3,4)),Vector((4,5,3)))
edges = ((0,1),(1,2),(2,3))
 
for i in range(0, len(spheres)):
    r1 = spheres[i]
    bpy.ops.mesh.primitive_uv_sphere_add(location=(r1.x, r1.y, r1.z))
 
for i in range(0,len(edges)):
     r1 = spheres[edges[i][0]]
     r2 = spheres[edges[i][1]]
     r3 = (r1+r2)/2
     z = Vector((0,0,1))
     z_desired = (r1-r2).normalized()
     rot_axis = z.cross(z_desired)
     angle = acos(z.dot(z_desired))
     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)