Blender для начинающих/Python

Материал из Викиучебника — открытых книг для открытого мира
Перейти к навигации Перейти к поиску
Blender2017.png



OpenHK2.jpg - перейти к комбинациям клавиш.
Level2.jpg - перейти к первому необязательному для изучения разделу.
NextChapter.jpg - переход к следующей по курсу главе (порядок глав не совпадает с порядком глав по содержанию).

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

Рендеринг Рендер-ферма
Отсечение Шейдер
Трассировка лучей Сжатие текстур

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


Ссылки на материалы
Возможно, Вас заинтересует следующее:
О Blender 2.76 FInfo.jpg Скачать Blender 2.76 FDownload.jpg

Содержание

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

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

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

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

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

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

Str[править]

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

'Hello'

Строки всегда берутся в одинарные кавычки. Они не могут быть растянуты на несколько строк программы. Это неверно:

'He
llo'

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.

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

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

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

имя = значение

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

a = 12

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

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

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

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

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

имя = []

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

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

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

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

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

PythonStrings.jpg

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

  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 = (1, 2, 3)

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

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

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

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

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

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

a = set(строка)

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

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

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

a = {'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() — удаляет все элементы из множества.

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

PythonKeys.jpg

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

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(). Так, эта программа установит значение переменной, которое пользователь ввел с клавиатуры:

имя = input()

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

имя = тип(input())

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

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

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

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

Оператор 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 получить число то надо написать:

имя = int(true)

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

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

if a == True:

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

if a:

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

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

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

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

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 — параметры. Тип параметров не нужно указывать — пишите только их имена. Например:

def Summ(a,b)
    return a+b

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

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

def Summ(a,b)
    return a+b

K = Summ(2,5)

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

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

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

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

lambda x: x**2

Вернет x².

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

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

Например:

f = lambda x: x**3

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

имя(значения параметров)

Вызов лямбды и функции, которые возводят 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 импортирует некоторый модуль в данную программу. Общий синтаксис:

import имя

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

import a, b, c

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

from имя import имя2

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

from modulemy import proc1, proc2, proc3

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

import имя as псевдоним

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

псевдоним.функция()

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

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

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

имя = [формула 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. И так далее.

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

GLSL 3.jpg

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

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

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

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

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

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

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

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

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

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

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

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

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

a= t(10)

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

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

Функция Описание
f = open('name.txt','m')
Открывает имя. f — переменная. name.txt — имя файла. 'm' режим работы с файлом — вместо m должно стоять r (если только для чтения открыть файл), или если для записи то w.
a = [k for k in f.readlines()]
Считывает все строки из файла и сохраняет в список a. Одна строка файла — один элемент списка.

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

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

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

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

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

Команда Описание
forward(n) вперед на n пикселей
backward(n) назад на n пикселей
left(n) влево на n градусов
right(n) вправо на n градусов
goto(x, y) переместить курсор в точку с координатами (x, y)

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

Команда Описание
circle(r) рисует окружность радиуса r
circle(r, n) рисует дугу радиуса r, градусной мерой n против часовой стрелки, если r > 0, по часовой стрелке, если r < 0
down() опустить курсор (будет рисовать)
up() поднять курсор (не будет рисовать)
width(n) установить толщину кисти
сolor(s) установить цвет кисти
  1. «black»
  2. «white»
  3. «red»
  4. «orange»
  5. «green»
  6. «blue»
  7. «purple»

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

Команда Описание
reset() очистить экран и установить курсор в начальную позицию
clear() очистить экран

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

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()
создать UV сферу
bpy.ops.mesh.primitive_ico_sphere_add()
создать ICO сферу
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)
добавить лампу, где T — одно из:
  1. «POINT»
  2. «SUN»
  3. «SPOT»
  4. «HEMI»
  5. «AREA»
bpy.ops.object.text_add()
создать текст
bpy.ops.object.armature_add()
создать арматуру
bpy.ops.object.empty_add(type = T)
создать пустышку, где T — ее тип:
  1. «PLANE_AXES» — Plane Axis
  2. «ARROWS» — Arrows
  3. «SINGLE_ARROW» — Single Arrow
  4. «CIRCLE» — Circle
  5. «CUBE» — Cube
  6. «SPHERE» — Cube
  7. «CONE» — Cone

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

location=(x, y, z)

Например:

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()
установить затенение Smooth
bpy.ops.object.shade_flat()
установить затенение Flat

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

Функция Описание
bpy.ops.transform.translate()
перемещение активных объектов
bpy.ops.transform.rotate()
вращение активных объектов
bpy.ops.transform.resize()
масштабирование активных объектов

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

Параметр Описание
value список, содержащий сдвиг/поворот/изменение размера по каждой из осей
constraint_axis список, содержащий логические значения, указывающие по каким осям не будет двигаться/поворачиваться/изменяться размера объект (значение False)
constraint_orientation система координат, используемая при перемещении/вращении/изменении размеров
  1. «GLOBAL» — глобальная
  2. «LOCAL» — локальная
proportional включено ли пропорциональное моделирование
  1. «ENABLED» — да
  2. «DISABLED» — нет
proportional_edit_falloff тип пропорционального моделирования
  1. «SMOOTH»
  2. «SPHERE»
  3. «ROOT»
  4. «INVERSE_SQUARE»
  5. «SHARP»
  6. «CONSTANT»
  7. «RANDOM»
proportional_size радиус влияния пропорционального моделирования

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

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

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)
создает новую сцену, причем T — тип сцены и может быть одним из:
  1. "NEW" — соответствует New
  2. "EMPTY" — соответствует Copy Settings
  3. "LINK_OBJECTS" соответствует Link Objects
  4. "FULL_COPY" соответствует Full Copy
bpy.ops.scenes.remove()
удаляет активную сцену

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

Код Описание
bpy.ops.object.mode_set(mode="OBJECT")
установить режим Object Mode
bpy.ops.object.mode_set(mode="EDIT")
установить режим Edit Mode
bpy.ops.object.mode_set(mode="SCULPT")
установить режим Sculpt Mode
bpy.ops.object.mode_set(mode="VERTEX_PAINT")
установить режим Vertex Paint
bpy.ops.object.mode_set(mode="WEIGHT_PAINT")
установить режим Weight Paint
bpy.ops.object.mode_set(mode="TEXTURE_PAINT")
установить режим 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")
добавить новое игровое свойство объекту с именем «P»
bpy.ops.object.game_property_move(index = i, direction = 'UP')
передвинуть вверх свойство с индексом i (индексы считаются от верхнего свойства к нижнему с 0)
bpy.ops.object.game_property_move(index = i, direction = 'DOWN')
передвинуть вниз свойство с индексом i (индексы считаются от верхнего свойства к нижнему с 0)
bpy.ops.object.game_property_remove(index = i)
удалить свойство с индексом i

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

Код Текст заголовка
bpy.ops.object.material_slot_add()
добавить новый слот материала
bpy.ops.object.material_slot_remove()
удалить активный слот материала

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

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

Создать Код
Сенсор ALWAYS bpy.ops.logic.sensor_add(type='ALWAYS')
Сенсор KEYBOARD bpy.ops.logic.sensor_add(type='KEYBOARD')
Сенсор MOUSE bpy.ops.logic.sensor_add(type='MOUSE')
Сенсор COLLISION bpy.ops.logic.sensor_add(type='COLLISION')
Сенсор RADAR bpy.ops.logic.sensor_add(type='RADAR')
Сенсор RADAR bpy.ops.logic.sensor_add(type='RAY')

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

Создать Код
Контроллер AND bpy.ops.logic.controller_add(type='LOGIC_AND')
Контроллер OR bpy.ops.logic.controller_add(type='LOGIC_OR')
Контроллер XOR bpy.ops.logic.controller_add(type='LOGIC_XOR')
Контроллер Python bpy.ops.logic.controller_add(type='Python')

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

Создать Код
Актуатор Action bpy.ops.logic.actuator_add(type='ACTION')
Актуатор Motion bpy.ops.logic.actuator_add(type='MOTION')
Актуатор Camera bpy.ops.logic.actuator_add(type='CAMERA')
Актуатор Property bpy.ops.logic.actuator_add(type='PROPERTY')
Актуатор Parent bpy.ops.logic.actuator_add(type='PARENT')
Актуатор Scene bpy.ops.logic.actuator_add(type='SCENE')

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

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

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

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

bpy.data.scenes["name"].render.engine
Движок Название, хранящееся в bpy.data.scenes[«name»].render.engine
Blender Engine
"BLENDER_GAME"
Blender Render
"BLENDER_RENDER"
Cycles Render
"CYCLES"
Blend4Web
"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.

Свойство Значение
name Имя блока данных.
use_fake_user Использует ли данных блок данных фейкового пользователя. По умолчанию нет — False.

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

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

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

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

bpy.data.scenes["key"]
Свойство Описание
camera камера, используемая для рендеринга (та камера, из которой будет смотреть пользователь на сцену переключившись в просмотр из камеры)
active_layer индекс активного слоя
camera активная камера, с помощью которой происходит рендеринг сцены
cursor_location трехмерный вектор, отражающий положение 3D курсора
objects список, содержащий все объекты сцены
use_gravity использовать ли гравитацию для всех физических объектов
objects список, содержащий все объекты сцены
world мир, который используется в сцене
lock_frame_selection_to_range позволять ли в редакторе Timeline выбирать мышью кадры вне диапазона
frame_preview_start первый кадр Timeline
frame_preview_end последний кадр Timeline
frame_current текущий кадр Timeline
sync_mode режим синхронизации Timeline
  1. «NONE» — None
  2. «FRAME_DROP» — Frame Dropping
  3. «AUDIO_SYNC» — AV-sync
name имя сцены (унаследовано от класса ID)
use_fake_user использовать ли фейкового пользователя (унаследовано от класса ID)
Данные мира[править]

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

Свойство Описание
horizon_color цвет горизонта
zenith_color цвет зенита
use_sky_real будет ли зависеть градиент неба от угла поворота камеры
mist_settings настройки тумана
name имя мира (унаследовано от класса ID)
use_fake_user использовать ли фейкового пользователя (унаследовано от класса ID)

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

Свойство Описание
use_mist использовать ли туман
start расстояние от камеры, на котором туман начинает действовать
intensity минимальная интенсивность тумана
depth расстояние, на котором туман начинает увеличивается
falloff тип увеличения интенсивности тумана
  1. «QUADRATIC» — квадратичная прогрессия
  2. «LINEAR» — линейная прогрессия
Данные объектов сцены[править]
Данные камер[править]

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

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

Код Описание
ortho_scale сила масштабирования изображения (чем больше, тем мельче изображение)
show_passepartout показывать ли затемнение области (при просмотре из камеры), которая не отображается при рендеринге
passepartout_alpha прозрачность области (при просмотре из камеры), которая не отображается при рендеринге
shift_x искривление камеры по оси X плоскости просмотра
shift_y искривление камеры по оси Y плоскости просмотра
show_name показывать ли имя камеры
show_mist показывать ли туман при просмотре через камеру
type тип камеры
  1. "PERSP" — камера с перспективным видом
  2. "ORTHO" — камера с ортогональным видом
name имя камеры (унаследовано от класса ID)
use_fake_user использовать ли фейкового пользователя (унаследовано от класса ID)

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

bpy.data.cameras['Camera'].name = "MyCam1"
Данные текстур[править]
  1. Класс текстуры — bpy.types.Texture(ID). Данные текстур хранятся в словаре bpy.data.textures. Ниже «Tex» — любая текстура.
    Код Описание
    contrast контраст (от 0.0 до 1.0)
    type тип текстуры
    1. 'IMAGE'
    2. 'BLEND'
    3. 'CLOUDS'
    4. 'DISTORTED_NOISE'
    5. 'ENVIRONMENT_MAP'
    6. 'MAGIC'
    7. 'MARBLE'
    8. 'MUSGRAVE'
    9. 'NOISE'
    10. 'POINT_DENSITY'
    11. 'STUCCI'
    12. 'VORONOI'
    13. 'WOOD'
    name имя текстуры (унаследовано от класса ID)
    use_fake_user использовать ли фейкового пользователя (унаследовано от класса ID)

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

    bpy.data.textures['Tex'].name = "MyCam1"
    
  2. Класс текстуры с картинкой — bpy.types.ImageTexture(Texture).
    Свойство Описание
    extension внешний вид изображения за своими реальными границами
    1. «EXTEND»
    2. «CLIP»
    3. «CLIP_CUBE»
    4. «REPEAT»
    5. «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 формат изображения
    1. «BPM»
    2. «PNG»
    3. «JPG»
    4. и остальные
    filepath путь к изображению
    mapping тип наложения картинки в игровом движке
    1. «UV»
    2. «REFLECTION»
    size (только для чтения) размер изображения в пикселях, представленный в виде кортежа [x, y] (x — количество пикселей по X, y — количество пикселей по Y)
    name имя картинки (унаследовано от класса ID)
    use_fake_user использовать ли фейкового пользователя (унаследовано от класса ID)

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

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

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

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

Свойство Комментарий
type тип области
width ширина
heigth высота
x координата верхнего левого угла по оси X относительно нижнего левого угла экрана
y координата верхнего левого угла по оси Y относительно нижнего левого угла экрана
name имя области экрана (унаследовано от класса ID)
use_fake_user использовать ли фейкового пользователя (унаследовано от класса ID)

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

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

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

Код Примечание
location[0] положение по оси X
location[1] положение по оси Y
location[2] положение по оси Z
rotation_euler[0] угол поворота по оси X
rotation_euler[1] угол поворота по оси Y
rotation_euler[2] угол поворота по оси Z
scale[0] размер по оси X
scale[1] размер по оси Y
scale[2] размер по оси Z
dimensions[0] абсолютный размер ограничительной рамки по оси X
dimensions[1] абсолютный размер ограничительной рамки по оси Y
dimensions[2] абсолютный размер ограничительной рамки по оси Z
lock_location[0] заблокировано ли изменение положения по оси X
lock_location[1] заблокировано ли изменение положения по оси Y
lock_location[2] заблокировано ли изменение положения по оси Z
lock_rotation[0] заблокировано ли изменение угла поворота по оси X
lock_rotation[1] заблокировано ли изменение угла поворота по оси Y
lock_rotation[2] заблокировано ли изменение угла поворота по оси Z
lock_scale[0] заблокировано ли изменение размеров по оси X
lock_scale[1] заблокировано ли изменение размеров по оси Y
lock_scale[2] заблокировано ли изменение размеров по оси Z
select True, если тело выделено, иначе False
parent объект-родитель
parent_type тип объекта-родителя
  1. «OBJECT»
  2. «VERTEX»
name имя области экрана (унаследовано от класса ID)
use_fake_user использовать ли фейкового пользователя (унаследовано от класса ID)

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

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

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

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

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

Код Примечание
name имя объекта
active_material имя активного (выделенного) материала
active_material_index индекс активного (выделенного) материала
active_shape_key имя активного (выделенного) ключа формы
active_shape_key_index индекс активного (выделенного) ключа формы
show_name показывать ли имя объекта
draw_type максимальный тип отрисовки

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

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

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

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

Код Примечание
name имя материала
type тип материала
  1. «SURFACE» — Surface
  2. «WIRE» — Wire
  3. «VOLUME» — Volume
  4. «HALO» — Halo
use_nodes использовать ли нодовую систему для настройки материала
diffuse_color цвет материала
specular_color цвет блика
mirror_color цвет отражения
diffuse_intensivity яркость диффузного цвета материала
specular_intensivity интенсивность цвет блика
specular_hardless размытость блика
use_shadeless отключить ли тени
use_cubic_interpolation использовать ли кубическую интерполяцию
use_tangent_shading использовать ли кубическую тангенциальное затенение
emit сила самосвечения
use_transparency использовать ли прозрачность
transparency_method метод отрисовки прозрачности
  1. «MASK» — Mask
  2. «Z_TRANSPARENCY» — Z Transparency
  3. «RAYTRACE» — Raytrace
aplha прозрачность
halo.use_texture использовать ли текстуру для halo-материала
halo.use_shaded использовать ли тени halo-материала
halo.use_soft использовать ли смягчение halo-материала
halo.size размер свечения halo-материала
halo.hardness жесткость halo-материала
halo.add сила добавления halo-материала (при наложении)
halo.use_ring визуализировать ли кольца halo-материала
halo.use_lines визуализировать ли кольца halo-материала
halo.use_star визуализировать ли кольца halo-материала
halo.ring_count количество колец halo-материала
halo.line_count количество линий halo-материала
halo.star_tip_count количество вершин звезд halo-материала

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

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
режим смешивания кисти, может быть одним из:
  1. «MIX» — Mix
  2. «ADD» — Mix
  3. «SUB» — Subtract
  4. «MUL» — Multiply
  5. «BLUR» — Blur
  6. «LIGHTEN» — Lighten
  7. «DARKEN» — Darken
bpy.data.brushes["B"].stroke_method
режим рисования кисти, может быть одним из:
  1. «DOTS» — Dots
  2. «SPACE» — Space
  3. «AIRBRUSH» — Sirbrush
  4. «LINE» — Line
  5. «CURVE» — Curve
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
сила сглаживания штрихов Factor
bpy.data.brushes["B"].spacing
расстояние между двумя штрихами при режиме Spacing
bpy.data.brushes["B"].rate
интервалы между срабатываниями кисти распылителя при режиме Airbrush
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
режим смешивания кисти, может быть одним из:
  1. «MIX» — Mix
  2. «ADD» — Mix
  3. «SUB» — Subtract
  4. «MUL» — Multiply
  5. «BLUR» — Blur
  6. «LIGHTEN» — Lighten
  7. «DARKEN» — Darken
bpy.data.brushes["B"].stroke_method
режим рисования кисти, может быть одним из:
  1. «DOTS» — Dots
  2. «SPACE» — Space
  3. «AIRBRUSH» — Sirbrush
  4. «LINE» — Line
  5. «CURVE» — Curve
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
сила сглаживания штрихов Factor
bpy.data.brushes["B"].spacing
расстояние между двумя штрихами при режиме Spacing
bpy.data.brushes["B"].rate
интервалы между срабатываниями кисти распылителя при режиме Airbrush
Специфичные для 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
тип физики объекта
  1. «NO_COLLISION» — No Collision
  2. «STATIC» — Static
  3. «DYNAMIC» — Dynamic
  4. «RIGID_BODY» — Rigid Body
  5. «SENSOR» — Sensor
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]
сила анизотропного трения по оси X
bpy.data.objects["name"].game.friction_coefficients[1]
сила анизотропного трения по оси Y
bpy.data.objects["name"].game.friction_coefficients[2]
сила анизотропного трения по оси Z
bpy.data.objects["name"].game.use_collision_bounds
использовать ли границы столкновения отличные от по умолчанию
bpy.data.objects["name"].game.collision_bounds_type
тип границ столкновения
  1. «TRIANGLE_MESH» — Triangle Mesh
  2. «CONVEX_HULL» — Convex Hull
  3. «CONE» — Cone
  4. «RIGID_BODY» — Cylinder
  5. «SPHERE» — Sphere
  6. «BOX» — Box
  7. «CAPSULE» — Capsule
bpy.data.objects["name"].game.collision_margin
маленькое расстояние от границ объекта 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

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

blMats["Mat1"].emit

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

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

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

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

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

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

УпрощеннаяСхемаКлассов.jpg

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

Имя Класс Свойства и функции Типы свойств
Always class bge.types.KX_AlwaysSensor(SCA_ISensor) нет свойств нет свойств
Collision class bge.types.KX_TouchSensor(SCA_ISensor)
  1. propName — имя свойства; если объект столкнется с объектом, имеющим это свойство то это будет считаться столкновением; если propName == , то столкновение с любым объектом будет считаться столкновением
  2. useMaterial — будет ли выполняться проверка на столкновение объекта со свойством (True) или с материалом (False)
propName — string; useMaterial — boolean
Delay class bge.types.SCA_DelaySensor(SCA_ISensor)
  1. delay — время между положительными сигналами, посылаемыми контроллеру
  2. duration — время, которое посылаются сигналы через промежутки времени Delay
  3. repeat — если равно 1, то цикл выполнения сенсора будет бесконечный, иначе должно равняться 0
delay, duration и repeat — integer
Keyboard class bge.types.SCA_KeyboardSensor(SCA_ISensor)
  1. key — главная клавиша
  2. hold1, hold2 — две остальные клавиши из комбинации клавиш
  3. useAllKeys — реагировать ли на нажатие любых клавиш (если равно True, то да)
  4. getKeyStatus(keycode) — получить состояние клавиши keycode (вместо keycode любая константа)

key, hold1, hold2 — тип клавиши; useAllKeys — логическое значение

Message class bge.types.SCA_NetworkMessageSensor(SCA_ISensor)
  1. subject — тема сообщения

subject — строка

Ray class bge.types.SCA_RaySensor(SCA_ISensor)
  1. propName — свойство, объекты с которым следует обнаруживать
  2. range — длина луча
  3. useMaterial — если равно True, то в propName следует будет вписать имя материала для обнаружения его лучом
  4. useXRay — если равно True, луч будет проходить сквозь все объекты, даже которые не имеют свойства
  5. axis — локальная ось, по которой будет направлен лучь
    1. KX_RAY_AXIS_POS_X — +X
    2. KX_RAY_AXIS_POS_Y — +Y
    3. KX_RAY_AXIS_POS_Z — +Z
    4. KX_RAY_AXIS_NEG_X — -X
    5. KX_RAY_AXIS_NEG_Y — -Y
    6. KX_RAY_AXIS_NEG_Z — -Z
propName — строковое значение; range — float; useMaterial, useXRay — логическое значение; axis — целое число
Near class bge.types.KX_NearSensor(KX_NearSensor)
  1. distance — расстояние, требуемое для активации сенсора
  2. resetDistance — дистанция, на которое следует отдалиться другому объекту, чтобы активный сенсор деактивировался
distance, resetDistance — float
Radar class bge.types.KX_RadarSensor(KX_NearSensor)
  1. propName — свойство, объекты с которым следует обнаруживать
  2. range — длина радара
  3. angle — угол радара
  4. useMaterial — если равно KX_True, то в propName следует будет вписать имя материала для обнаружения его лучом, иначе — при KX_False — имя свойства
  5. axis — локальная ось, по которой будет направлен конус радара
    1. KX_RADAR_AXIS_POS_X — +X
    2. KX_RADAR_AXIS_POS_Y — +Y
    3. KX_RADAR_AXIS_POS_Z — +Z
    4. KX_RADAR_AXIS_NEG_X — -X
    5. KX_RADAR_AXIS_NEG_Y — -Y
    6. KX_RADAR_AXIS_NEG_Z — -Z
propName — строковое значение; range, angle — float; useMaterial — логическое значение

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

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

Имя Класс Свойства и функции Типы свойств
AND class bge.types.SCA_ANDController(SCA_IController) нет свойств нет свойств
OR class bge.types.SCA_ORController(SCA_IController) нет свойств нет свойств
XOR class bge.types.SCA_XORController(SCA_IController) нет свойств нет свойств
NOR class bge.types.SCA_NORController(SCA_IController) нет свойств нет свойств
Script class bge.types.SCA_PythonController(SCA_IController)
  1. script — имя запускаемого скрипта
  2. activate(act) — активация актуатора act, подключенного к скрипту
  3. deactivate(act) — деактивация актуатора act, подключенного к скрипту
script, act — строки

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

a = bge.logic.GetCurrentController()

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

obj = a.owner

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

Имя Класс Свойства Типы свойств
Action class bge.types.BL_ActionActuator(SCA_IActuator)
  1. action — имя действия (анимации)
  2. frameStart — кадр, с которого будет проигрываться анимация
  3. frameEnd — кадр, на котором закончится проигрываться анимация
action — string; frameStart, frameEnd — float
Camera class bge.types.KX_CameraActuator(SCA_IActuator)
  1. min — минимальная дистанция до объекта, за которым следит камера
  2. max — максимальная дистанция от объекта, за котором следит камера
  3. object — имя объекта, за которым следит камера

min, max — float; object — KX_GameObject

Game class bge.types.KX_GameActuator(SCA_IActuator)
  1. fileName — имя файла игры, который откроется
  2. mode — режим работы актуатора (bge.logic.KX_GAME_START — открыть файл fileName; bge.logic.KX_GAME_RESTART — перезапустить игру; bge.logic.KX_GAME_QUIT — выйти из игры)

fileName — string; mode — int

Scene class bge.types.KX_SceneActuator(SCA_IActuator)
  1. scene — имя сцены, с которой следует произвести какие-то изменения
  2. camera — имя камеры, которую следует установить
  3. mode — режим работы актуатора (от 0 — 5)
scene — string; camera — KX_Camera; mode — integer
Sound class bge.types.KX_SoundActuator(SCA_IActuator)
  1. volume — громкость звука
  2. time — секунда, с которой начнет воспроизводится аудио
  3. mode — режим воспроизведения аудио (KX_SOUNDACT_PLAYSTOP — проиграть один раз; KX_SOUNDACT_LOOPEND — проигрывать бесконечно)
  4. is3D — звучит ли музыка объемно
  5. volume_maximum — максимальная громкость звука (не зависит от расстояния)
  6. volume_minimum — минимальная громкость звука (не зависит от расстояния)
volume, time, volume_maximum, volume_minimum — float; mode — integer; is3D — boolean
State class bge.types.KX_StateActuator(SCA_IActuator)
  1. operation — операция, которая изменит состояние объекта (KX_STATE_OP_SET — установит новое состояние)
operation — integer
Sound class bge.types.KX_SoundActuator(SCA_IActuator)
  1. startSound() — начинает проигрывать звук
  2. pauseSound() — прекращает проигрывать звук
  3. stopSound() — прекращает проигрывать звук и при следующем проигрывании проигрывание звука начнется с секунды, указанной в time
startSound, pauseSound, stopSound — None

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

с.activate(a)

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

с.deactivate(a)

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

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

Константа Значение
bge.logic.KX_TRUE True
bge.logic.KX_FALSE False

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

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

Константа Описание
bge.logic.KX_SENSOR_INACTIVE сенсор неактивен
bge.logic.KX_SENSOR_ACTIVE сенсор активен
bge.logic.KX_SENSOR_JUST_ACTIVATED сенсор активировался только что
bge.logic.KX_SENSOR_JUST_DEACTIVATED сенсор деактивировался только что

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

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

  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).

Функция Описание
getMaterialName(i) возвращает имя материала из списка materials с индексом i
getTextureName(i) возвращает имя текстуры, которая используется материалом с индексом i
getVertexArrayLength(i) возвращает длину списка вершин, у которых установлен материал с индексом i
getVertex(i, vi) возвращает объект вершины, у которой материал с индексом i и которая находится на vi-ой позиции в списке вершин для этого материала

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

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

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

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

Свойство Описание
XYZ вектор, указывающий положение точки в пространстве
UV вектор, указывающий текстурные координаты точки
normal вектор, указывающий направление нормали вершины
color список, определяющий цвет точки в формате [r, g, b, a]
x координата X вершины
y координата Y вершины
z координата Z вершины
u координата U текстуры вершины
v координата V текстуры вершины
u2 вторая координата U текстуры вершины
v2 вторая координата V текстуры вершины
r значение красного компонента цвета от 0.0 до 1.0
g значение зеленого компонента цвета от 0.0 до 1.0
b значение синего компонента цвета от 0.0 до 1.0
a значение прозрачного компонента цвета от 0.0 до 1.0

Пример скрипта, который автоматически раскрашивает вершины, в зависимости от координаты 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]

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

ScriptWork 1.jpg

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

Свойство Описание
material_name (только для чтения) имя материала, который использует материал
material (только для чтения) материал, используемый полигоном
texture_name (только для чтения) имя текстуры, которую использует полигон
material_id (только для чтения) имндекс материала, который использует полигон
v1 (только для чтения) первая вершина полигона
v2 (только для чтения) вторая вершина полигона
v3 (только для чтения) третья вершина полигона
v4 (только для чтения) четвертая вершина полигона
visible (только для чтения) полигон видим при True, иначе — не видим

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

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

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

Константа Описание
bge.events.LEFTMOUSE Нажатие левой кнопки мыши.
bge.events.RIGHTMOUSE Нажатие правой кнопки мыши.
bge.events.MIDDLEMOUSE Нажатие колесика кнопки мыши.
bge.events.WHEELUPMOUSE Движение колесика мыши от себя.
bge.events.WHEELDOWNMOUSE Движение колесика мыши на себя.

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

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

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

bge.events.имя_клавишиKEY
Константа Название соответствующей клавиши
bge.events.AKEY A
bge.events.BKEY B
bge.events.CKEY C
bge.events.DKEY D
bge.events.EKEY E
bge.events.FKEY F
bge.events.GKEY G
bge.events.HKEY H
bge.events.IKEY I
bge.events.JKEY J
bge.events.KKEY K
bge.events.LKEY L
bge.events.MKEY M
bge.events.NKEY N
bge.events.OKEY O
bge.events.PKEY P
bge.events.QKEY Q
bge.events.RKEY R
bge.events.SKEY S
bge.events.TKEY T
bge.events.UKEY U
bge.events.VKEY V
bge.events.WKEY W
bge.events.XKEY X
bge.events.YKEY Y
bge.events.ZKEY Z

Класс 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) Добавляет на сцену объект
    1. object — имя объекта, который следует добавить
    2. reference — имя объекта, в центр которого следует поместить добавленный объект
    3. time — время жизни объекта (если = 0, то объект живет вечно)
    object, reference — KX_GameObject or string; time — integer
    end() Удаляет из игры сцену нет параметров нет параметров
    restart() Перезапускает сцену нет параметров нет параметров
    replace() Перезапускает сцену
    1. scene — имя сцены, на которую следует заменить
    scene — string

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

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

Имя атрибута сцены Описание Возвращаемое значение
mistEnable Включен ли туман boolean
mistStart Дистанция от точки наблюдателя, с которой начинается туман float
mistDistance Расстояние от дистанции mistStart, требующиеся для того, чтобы туман стал 100 процентным float
mistIntensity Минимальная интенсивность тумана float
mistType Тип тумана (KX_MIST_QUADRATIC — квадратичный; KX_MIST_LINEAR — линейный; KX_MIST_INV_QUADRATIC — инвертированный квадратичный)
mistColor Цвет тумана [r, g, b]
ambientColor Фоновый цвет окружающей среды [r, g, b]

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

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

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

Свойство Значение
a.name (только для чтения) Имя объекта.
a.worldPosition (только для чтения) Вектор, указывающий координаты центра объекта.
a.localPosition Вектор, указывающий координаты центра объекта.
a.mass Масса объекта.
a.isSuspendDynamics (только для чтения) Является ли объект статическим или динамическим.
a.linearDamping Затухание скорости.
a.angularDamping Затухание вращения.
a.linVelocityMin Минимальное значение линейной скорости.
a.linVelocityMax Максимальное значение линейной скорости.
a.angularVelocityMin Минимальное значение скорости вращения.
a.angularVelocityMax Минимальное значение скорости вращения.
a.localInertia Вектор, отвечающий за инерцию объекта.
a.parent (только для чтения) Родитель объект.
a.children Список всех ближайших потомков.
a.childrenRecursive Список всех потомков.
a.scene (только для чтения) Имя сцены, на которой расположен объект.
a.visible Если равно True, то объект видим, иначе нет.
a.record_animation Если равно True, то будет записываться анимация движения объекта в виде f-кривых, иначе нет.
a.color Цвет объекта в виде [r, g, b, a] вектора.
a.life Время жизни объекта.
a.endObject Удаление тела.
a.sensors Словарь всех сенсоров объекта.
a.controllers Словарь всех контроллеров объекта.
a.actuators Словарь всех актуаторов объекта.

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

  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)[править]

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

Свойство Описание
lens Значение Focal Length.
ortho_scale Размер изображения при ортогональной проекции.
near Ближнее расстояние отсечения для камеры.
far Дальнее расстояние отсечения для камеры.
shift_x Сдвиг камеры по локальной оси X.
shift_y Сдвиг камеры по локальной оси Y.
perspective Если равно True, то вид из камеры перспективный, иначе ортогональный.
useViewport Если равно True, то вид Вы будете смотреть из этой камеры на сцену во время игры.

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

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

PyCam2.jpg

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

Значение Описание
a.INTERSECT Сфера или параллелепипед пересекает frustum.
a.INSIDE Сфера или параллелепипед находится внутри frustum.
a.OUTSIDE Сфера или параллелепипед находится вне frustum.
  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 — источник освещения.

Свойство Описание
L.type Тип источника освещения. Может быть одним из:
  1. SPOT — обычная лампа Lamp
  2. SUN — солнце
  3. SPOT — направленный источник освещения
L.energy сила освещения
L.layer слой, объекты на котором будут освещены этим источником света
L.shadowClipStart (только для чтения) расстояние от источника света, на котором начинается расчет карты теней
L.shadowClipEnd (только для чтения) расстояние от источника света, на котором начинается расчет карты теней
L.shadowColor цвет тени
L.distance то расстояние от лампы, дальше которого свет не идет (только для NORMAL и SPOT)
L.spotsize радиус освещаемой окружности источником освещения типа SPOT
L.spotblend управляет мягкостью краев освещенной области

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

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()
Модели изменения силы света[править]

EnergyModel1X.jpgEnergyModel2G.jpg

  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 — материал.

Свойство Описание
M.material_index индекс материала
M.alpha прозрачность материала
M.diffuseIntensity интенсивность диффузного цвета
M.specularIntensity яркость блика
M.diffuseColor диффузный цвет
M.specularColor цвет блика
M.hardness жесткость блика (чем меньше, тем размытее и больше блик)
M.emit самосвечение

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

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

Функция Описание Параметры
clear() очищает данные о меше нет
copy() копирует данные меша нет
from_mesh(mesh, face_normals=True, use_shape_key=False, shape_key_index=0) создает меш, идентичный другому мешу
  1. mesh — тот меш, с которого создается копия
  2. use_shape_key — если равно True, то будут использоваться измененные ключом формы с индексом shape_key_index координаты вершин
to_mesh(mesh) записывает данные меша в mesh mesh — имя меша, в который будут записаны данные другого меша
normal_update() обновляет данные нормалей нет

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

bm = bmesh.new()

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

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

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

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

Свойство Описание
hide видимость вершины — True (видима), иначе нет
is_wire (только для чтения) True, если вершина ни с одним полигоном не соединена
link_edges (только для чтения) список связанных ребер
link_faces (только для чтения) список связанных полигонов
normal 3D вектор, определяющий направление нормали
select True, если вершина выделена, иначе — False

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

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

Свойство Описание
hide видимость ребра — True (видима), иначе нет
is_wire (только для чтения) True, если ребро ни с одним полигоном не соединено
link_faces (только для чтения) список связанных полигонов
normal 3D вектор, определяющий направление нормали
select True, если ребро выделенло, иначе — False
link_verts (только для чтения) список вершин, из которых состоит ребро

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

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

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

Свойство Описание
hide видимость полигона — True (видима), иначе нет
link_edges (только для чтения) список связанных ребер
normal 3D вектор, определяющий направление нормали
select True, если ребро выделенло, иначе — False
material_index индекс используемого материала

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

Функция Описание Параметры
f.normal_flip() поворачивает нормаль на 180 градусов по всем осям нет
f.calc_perimeter() возвращает периметр полигона нет
f.calc_area() возвращает площадь полигона нет
f.calc_center_bounds() возвращает вектор, показывающий координаты центра полигона нет

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

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

Функция Описание Параметры
remove(vert) удаляет вершину vert — объект вершины
new(co=(x, y, z)) создает новую вершину co — вектор, указывающий координаты вершины

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

Функция Описание Параметры
remove(egde) удаляет ребро egde — объект ребра
new(verts) создает новое ребро verts — список, состоящий их двух вершин

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

Функция Описание Параметры
remove(face) удаляет полигон egde — объект полигон
new(verts) создает новый полигон verts — список вершин

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

Функция Описание Параметры
math.radians(d) Преобразует градусы в радианы. d — градусы

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

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

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

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

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

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

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

n.c

Где 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.x Угол поворота по оси X.
a.y Угол поворота по оси Y.
a.z Угол поворота по оси Z.
a.order Порядок, в котором указываются углы.

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

Функция Описание
a.zero() Устанавливает все три угла в значения 0.0.
a.to_matrix Возвращает матрицу размера 3x3.
a.rotate(obj) Поворачивает каждую ось угла Эйлера на значение другого угла Эйлера. Каждая ось поворачивается на ей соответствующую (X на X2, Y на Y2, Z на Z2, где буквы без индексов — изначальный угол Эйлера, а буквы с 2 — второй угол Эйлера).

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

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

n = mathutils.Vector(v)

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

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

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

Функция Описание
n.normilize() Укорачивает длину вектора до 1.0.
n.normilized() Возвращает новый укороченный вектор n до 1.0.
len(n) Возвращает длину вектора.
n.angle(b, fallback = any) Узнает угол векторами n и b, если это невозможно (они из векторов является нулевым вектором), то возвращает any (по умолчанию вместо any возвращает None).
n.resize_2d() Преобразует вектор n в 2d вектор.
n.resize_3d() Преобразует вектор n в 3d вектор.
n.rotate(a) Вращает вектор на угол Эйлера a.
n.lerp(b, f)

Возвращает вектор, полученный интерполяцией между двумя векторами n и b.

  1. f меняется от 0.0 до 1.0.
  2. Чем больше значение f, тем ближе полученный вектор к вектору b.

VectorsInterpolation.jpg

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

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

Имя функции Описание Параметры Возвращаемое значение
bge.render.getWindowWidth() Вернет ширину окна в пикселях нет параметров integer
bge.render.getWindowHeight() Вернет высоту окна в пикселях нет параметров integer
bge.render.setWindowSite(x, y) Устанавливает размер окна x, y — размеры окна в пикселях (integer) None
bge.render.showMouse(visible) Делает курсор видимым или скрывает его visible (boolean) — видимость курсора (true — видим, false — скрыт) None
bge.render.setMousePosition(x, y) Устанавливает позицию курсора x, y — позиция курсора (integer) None
bge.render.setMaterialMode(mode) Устанавливает режим отображения материалов mode — режим отображения материалов (KX_TEXFACE_MATERIAL — самый простой метод прорисовки материалов, KX_BLENDER_MULTITEX_MATERIAL — мультитекстура, KX_BLENDER_GLSL_MATERIAL режим отоюражения GLSL) None
bge.render.getMaterialMode() Вернет режим отображения материалов нет параметров Вернет метод отображения материалов
bge.render.setMipmapping(value) Установит режим сглаживания текстур или уберет его value — установит режим сглаживания материалов (true — включен, false — выключен) None

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

Код Описание
bpy.context.visible_objects список видимых объектов
bpy.context.selectable_objects список объектов, которые могут быть выделены
bpy.context.selected_objects список выделенных объектов
bpy.context.active_object активный объект

Включение видимости имен у всех выделенных объектов, положение которых по оси 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.

Свойство Описание
version возвращает кортеж, состоящий из трех чисел, и показывающих текущую версию

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

Для KX_GameObject(SCA_IObject):

  1. orientation
  2. scaling

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

Пример текста ошибки Смысл ошибки
IndentationError: unexpected indent интерпретатор обнаружил ненужный отступ
TypeError: unsupported operand type(s) for /: 'str' and 'int' попытка делить строку на число
SyntaxError: invalid syntax неверный синтаксис

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

# Скрипт создания объектов по кольцу
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)
# Класс для работы с векторами
# coding: utf8
import math
 
class Vector(object):
    #Класс для работы с векторами в двухмерном пространстве.
 
 
    def __init__(self, x, y):
        self.x = float(x)
        self.y = float(y)
 
    def __repr__(self):
        return u'<Vector: (%f; %f)>' % (self.x, self.y)
 
    def __str__(self):
        return u'(%.2f; %.2f)' % (self.x, self.y)
 
    def __add__(self, other):
        # сложение
        return self.__class__(self.x + other.x, self.y + other.y)
 
    def __sub__(self, other):
        #вычитание
        return self.__class__(self.x - other.x, self.y - other.y)
 
    def __mul__(self, other):
        # скаляр
        if other.__class__.__name__ in self.__class__.__name__:
            # если скаляр векторов
            return self.x * other.x + self.y * other.y
        # скаляр вектора на число
        return self.x * other + self.y * other
 
    def length(self):
        # длинна вектора
        return math.sqrt(self.x ** 2 + self.y ** 2)
 
    def distance(self, other):
        # расстояние до другого(other) вектора -> float
        v = self - other
        return v.length()
 
    def normal(self):
        # нормализация    
        return self.__class__(self.x / self.length(), self.y / self.length())
 
    def angle(self, other):
        # угол между векторами        
        return ((self.x * other.x + self.y * other.y)/(self.length() * other.length()))
 
if __name__ == '__main__':
    v1 = Vector(2, 3)
    v2 = Vector(15, -5)
    print "%s + %s = %s" % (v1, v2, v1 + v2)
    print "%s - %s = %s" % (v1, v2, v1 - v2)
    print "%s * %s = %s" % (v1, v2, v1 * v2)
    print "%s * %s = %s" % (v1, 5, v1 * 5)
    print "length(%s): %f" % (v1, v1.length())
    print "distance(%s %s): %f " %(v1, v2, v1.distance(v2))
    print "normal(%s): %s" % (v2, v2.normal())
    print "angle(%s, %s): %f" % (v2, v1, v2.angle(v1))
# Передвижение объекта
import bge

def main():
    cont=bge.logic.getCurrentController()
    player=cont.owner
    
    keyboard=bge.logic.keyboard
    
    wKey=bge.logic.KX_INPUT_ACTIVE==keyboard.events[bge.events.WKEY]
    sKey=bge.logic.KX_INPUT_ACTIVE==keyboard.events[bge.events.SKEY]
    aKey=bge.logic.KX_INPUT_ACTIVE==keyboard.events[bge.events.AKEY]
    dKey=bge.logic.KX_INPUT_ACTIVE==keyboard.events[bge.events.DKEY]
    moveSpd=0.4
    rotSpd=0.04
    if wKey:
        player.applyMovement((0,moveSpd,0), True)
        
    elif sKey:
        player.applyMovement((0,-moveSpd,0), True)
    #################################################
    if aKey:
        player.applyRotation((0,0,rotSpd), True)
        
    elif dKey:
        player.applyRotation((0,0,-rotSpd), True)

main()
# Изменение цвета тумана на красный.
import bge

sce = bge.logic.getCurrentScene()

sce.world.mistColor = [1.0, 0.0, 0.0]
# Проигрывание музыки по окончанию рендеринга
import bpy
import aud
 
def play(scene):
	Device = aud.device()
	Factory = aud.Factory('C:/music.mp3')
	Device.play(Factory.volume(1))
 
bpy.app.handlers.render_complete.append(play)
# Выключение компьютера по окончанию рендеринга (вариант для Windows)
import bpy
import subprocess
 
def shutdown(scene):
	subprocess.call('Shutdown.exe -s -t 05')
 
bpy.app.handlers.render_complete.append(shutdown)
# Выключение компьютера по окончанию рендеринга (вариант для Linux)
import bpy
import os
 
def shutdown(scene):
        os.system('sudo chmod u+s /sbin/shutdown')
	os.system('shutdown -P 01')
 
bpy.app.handlers.render_complete.append(shutdown)
import math
import bpy
import bmesh

def EditMesh(funcIndex, minX, maxX, minY, maxY, minZ, maxZ, Xlim, Ylim, Zlim):
    functions = [lambda t: math.sin(t), lambda t: math.cos(t), lambda t: math.sin(t)]
    # Get the active mesh
    me = bpy.context.object.data
    
    
    # Get a BMesh representation
    bm = bmesh.new()   # create an empty BMesh
    bm.from_mesh(me)   # fill it in from a Mesh
    
    
    # Modify the BMesh, can do anything here...
    for v in bm.verts:
        if Xlim == True:
            if v.co.x < minX:
               v.co.x = minX
            if v.co.x > maxX:
               v.co.x = maxX
        
        if Ylim == True:
            if v.co.y < minY:
               v.co.y = minY
            if v.co.y > maxY:
               v.co.y = maxY
        
        if Zlim == True:
            if v.co.z < minZ:
               v.co.z = minZ
            if v.co.z > maxZ:
               v.co.z = maxZ
        
        if funcIndex != -1:
            v.co.x = functions[funcIndex](v.co.x)
            v.co.y = functions[funcIndex](v.co.y)
            v.co.z = functions[funcIndex](v.co.z)
    # Finish up, write the bmesh back to the mesh
    bm.to_mesh(me)
    bm.free()  # free and prevent further access

'''

Скрипт позволяет изменить весь меш по некоторой математической функции - синуса, косинуса или тангенса.
Для работы скрипты пишите под комментарием вызов функции EditMesh(funcIndex, Effect, minX, maxX, minY, maxY, minZ, maxZ).
Здесь - funcIndex - индекс используемой функции для изменения меша. Если хотите, чтобы меш изменялся по sin - пишите вместо funcIndex число 0; для косинуса - пишите 1; для тангенса - 2. Если не хотите использовать никакую математическую функцию - пишите -1.
Далее можно выбрать минимальное и максимальное для всех координат вершин значение.
'''
# Пример использования:
EditMesh(-1, 0, 0, 0, 0, -1, 0.4, False, False, True)

Blender 2.49[править]

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

  1. Функция Get(str) возвращает некоторое значение в соответствии с str:
    1. str == «curframe», то вернется текущий кадр анимации
    2. str == «curtime», то вернется текущий время анимации
    3. str == «staframe», то вернется первый кадр проигрываемого диапазона анимации
    4. str == «endframe», то вернется последний кадр проигрываемого диапазона анимации
    5. str == «version», то вернется версия Blender
  2. Run(scr) запускает скрипт с именем scr, находящийся в Blender.

Подмодуль Blender.Camera[править]

Свойство Описание
alpha прозрачность PassPort
clipStart первая граница отсечения Frustum
clipEnd вторая граница отсечения Frustum
lens сила линз
scale сила уменьшения
type тип камеры («persp» или «ortho»)
shiftX искривление по оси X
shiftY искривление по оси Y
from Blender import Camera, Object, Scene
cam = Camera.New("ortho") # создаем камеру (не указав на какой сцене она будет располагаться)
scn = Scene.GetCurrent() # получаем объект текущей сцены
obj = scn.objects.new(cam) # добавляем камеру на сцену scn

Подмодуль Blender.Lamp[править]

Свойство Описание
R компонента цвета света R
G компонента цвета света G
B компонента цвета света B
col трехмерный вектор (список, из трех элементов), указывающий цвет
dist расстояние освещения
energy сила свечения
spotBlend сила смягчания для лампы-прожектора
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[править]

Свойство Описание
Get(name="name") возвращает ссылку на объект с именем «name»
GetSelected() возвращает список всех выделенных объектов

Описанное ниже относится к классу Object этого модуля.

Функция Описание
LocX положение по оси X
LocY положение по оси Y
LocZ положение по оси Z
RotX угол поворота по оси X
RotY угол поворота по оси Y
RotZ угол поворота по оси Z
SizeX размер по оси X
SizeY размер по оси Y
SizeZ размер по оси Z
Parent объект-родитель
ParentType тип объекта-родителя
sel True, если объект выделен, иначе False
import Blender
scn = Blender.Scene.GetCurrent()      # получает текущую сцену
cam = Blender.Camera.New('ortho')     # создает камеру
ob = scn.objects.new(cam)             # устанавливает камеру на текущую сцену
ob.LocX = 2.5       # позиционирует объект

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

Подмодуль Blender.Scene[править]

Свойство Описание
camera камера, с помощью которой будет рендерится сцена
cursor трехмерный вектор, указывающий положение 3D курсора
objects список всех объектов сцены

PEP 8[править]

PEP 8 — соглашение о том, как форматировать код.

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

Обработка списков на Python

Задачи на рекурсию