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

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

Blender 2.77 - теория 이론

Стандартные движки
1. Основы _{Описание всего по немногу. После прочтения Вы сможете моделировать в Blender.}
2. Меню _{Разбирание меню. После изучения этой главы Вы будете быстрее ориентироваться в меню.}
3. Модификаторы _{Описание модификаторов. После прочтения данной главы Вы сможете плодотворно пользоваться модификаторами в Blender.}
4. Расширенная игровая логика _{В этой главе описывается игровая логика в BGE. В конце прочтения данной главы Вы будете владеть игровой логикой почти на профессиональном уровне.}
5. Ноды в Cycles Render _{Здесь рассказывается о нодах в Blender. В конце прочтения этой главы Вы будете уметь создавать несложные, но красивые материалы.}
6. Ноды в Blender Render _{Глава посвящена нодам в старом рендере «Blender Render». После изучения главы Вы будете способны ориентироваться в нодах старого рендера на среднем уровне.}
7. Анимация _{Эта часть книги дает сведения о создании анимации. После ее прочтения Вы сможете работать с анимацией в Blender.}
8. Пользовательские настройки _{Здесь повествуется о том, как настроить Blender под себя. В конце прочтения этой части книги Вы сможете изменить интерфейс под себя.}
9. Секреты Blender _{Такие тонкости Blender, которые могут сделать работу в нем более комфортной. После изучения этой главы Вы сможете оптимизировать работу программы и работать с объектами на более высоком уровне.}
Blend4Web
1. Blend4Web _{Здесь рассказывается о настройке поведения объектов с помощью нодовой системы. Изучив главу, Вы будуте способны визуально программировать логику нодами.}

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

Рендеринг
1. Game _{Примеры создания простых моделей для игр и самих игр, и материалов для игр. После изучения этой главы Вы будете способны создавать игры средней сложности.}
2. Render _{Примеры использования движка Cycles Render с кратким описанием. В конце изучения этой главы Вы сможете быстрее разбираться в нодах.}
Игровая логика и программирование
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. После прочтения этой главы Вы будете немного знать о различиях этих программ.}

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

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

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

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

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

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

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

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

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

Ссылки на материалы
Официальная справка по Blender Blend4Web _{О создании 3D в браузере.} Blender 3D (первый вариант перевода) _{Перевод английской книги по Blender.} Blender 3D: Noob to Pro (англ.) _{Оригинал английской книги по Blender.} Перевод книги «Getting started with Blender 2.5» (автор: итальянец Joaclint Istgud) _{Перевод книги по Blender 2.5.} HTML book _{О создании графического пользовательского интерфейса в HTML.} Список сайтов с готовыми моделями
Возможно, Вас заинтересует следующее:
Справочник_по_языку_Python_3.1 Пример работы с физикой в Blender Самоучитель по Blender 2.6 Sculptris Уроки скульптинга Основы Sweet Home 3D

О Blender 2.76

Скачать Blender 2.76

Введение

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

Типы

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

Описание

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

Str

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

'Hello'

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

'He
llo'

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

'''He
llo'''

И это тоже:

"""He
llo"""

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

Int

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

Float

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

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

Существуют следующие операции для целых чисел в Python: + (сложение), — (вычитание), * (умножение), ** (возведение в степень), // (деление с отбрасыванием остатка), % (деление с отбрасыванием всего кроме остатка). Например: 2**2 = 4.
Для типа float есть такие операции: + (сложение), — (вычитание), * (умножение), ** (возведение в степень).
Для строк характерна такая операция как сложение (она просто склеит две строки в одну). Например: 'A' + 'S' = 'AS'.
Но если для типа float применить операции: ** или %, то числа этого типа станут числами типа int.
Также если возводить в отрицательную или дробную степень целое число, то оно преобразуется в число типа 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 есть параметр в скобках, определеющий что будет склеиваться в единое целое — то есть имя списка. Перед точкой пишется то что будет заполнителем между склеенными элементами.

Операции со списками

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

Кортежи

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

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

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

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

Например:

a = (1, 2, 3)

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

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

Множества

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

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

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

a = set(строка)

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

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

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

a = {'a', 'j', 's'}

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

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

s.update(a, b, … n) — объединить все множества. Получится множество, в которое вошли элементы всех множеств.
s.intersection_update(a, b, … n) — найти пересечение множеств. На выходе будет множество, в котором находятся элементы, которые есть в каждом из перечисленных множеств.
s.difference_update(a, b, … n) — вычесть все множества из s. Будут убраны все элементы множеств, указанных в скобках, из s.
s.add(e) добавляет элемент в множество.
s.discard(e) — удаление элемента со значением e из множества s.
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'])

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

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

d.clear() — удаляет все из словаря.
d.copy() — возвращает копию словаря.
d.get(k, v) — вернет значение из словаря d по ключу k, если же его нет то вернет значие v (по умолчанию None).
d.keys() — вернет список, состоящий из всех ключей словаря.
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. Если преобразовать False к числу получится 0. Аналогично почти у строк: если она пуста то получится при преобразовании из str в bool значение 0, иначе 1.

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

if a == True:

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

if a:

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

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

a.isdisjoint(b) — результат будет True, если общих элементов у множеств нет.
Операция == в выражении «a == b» приобретет смысл «множества a и b полностью совпадают».
А запись «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

Исключения

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

Системные исключения

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

Обычные исключения

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

Синтаксические ошибки

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

IndentationError — исключение, порождаемое интерпретатором при неправильных отступах.
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']

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

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

Классы

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

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

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

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

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

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

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

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

__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

random.randrange(start, stop, step) — возвращает случайно выбранное число из последовательности, которая начинается с start, заканчивается end и идет с шагом step
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)	установить цвет кисти «black» «white» «red» «orange» «green» «blue» «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 — одно из: «POINT» «SUN» «SPOT» «HEMI» «AREA»
bpy.ops.object.text_add()	создать текст
bpy.ops.object.armature_add()	создать арматуру
bpy.ops.object.empty_add(type = T)	создать пустышку, где T — ее тип: «PLANE_AXES» — Plane Axis «ARROWS» — Arrows «SINGLE_ARROW» — Single Arrow «CIRCLE» — Circle «CUBE» — Cube «SPHERE» — Cube «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	система координат, используемая при перемещении/вращении/изменении размеров «GLOBAL» — глобальная «LOCAL» — локальная
proportional	включено ли пропорциональное моделирование «ENABLED» — да «DISABLED» — нет
proportional_edit_falloff	тип пропорционального моделирования «SMOOTH» «SPHERE» «ROOT» «INVERSE_SQUARE» «SHARP» «CONSTANT» «RANDOM»
proportional_size	радиус влияния пропорционального моделирования

Копирование

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

bpy.ops.object.dublicate_move()

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

В первом из них содержится информация о том является ли это копирование копированием объекта или созданием связанной его копии:
```
OBJECT_OT_dublicate = {"linked":False, "mode":"TRANSLATION"}
```
Ключ «linked» позволяет установить как будет копироваться объект — если равно True, то создасться его связанная копия, иначе будет скопирован весь объект.
Во втором хранятся сами данные преобразования объекта:
```
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 — тип сцены и может быть одним из: "NEW" — соответствует New "EMPTY" — соответствует Copy Settings "LINK_OBJECTS" соответствует Link Objects "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 «NONE» — None «FRAME_DROP» — Frame Dropping «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	тип увеличения интенсивности тумана «QUADRATIC» — квадратичная прогрессия «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	тип камеры "PERSP" — камера с перспективным видом "ORTHO" — камера с ортогональным видом
name	имя камеры (унаследовано от класса ID)
use_fake_user	использовать ли фейкового пользователя (унаследовано от класса ID)

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

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

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

Класс текстуры — 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"

Класс текстуры с картинкой — 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)

Класс картинки — 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).

Свойство	Комментарий
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	тип объекта-родителя «OBJECT» «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	тип материала «SURFACE» — Surface «WIRE» — Wire «VOLUME» — Volume «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	метод отрисовки прозрачности «MASK» — Mask «Z_TRANSPARENCY» — Z Transparency «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	режим смешивания кисти, может быть одним из: «MIX» — Mix «ADD» — Mix «SUB» — Subtract «MUL» — Multiply «BLUR» — Blur «LIGHTEN» — Lighten «DARKEN» — Darken
bpy.data.brushes["B"].stroke_method	режим рисования кисти, может быть одним из: «DOTS» — Dots «SPACE» — Space «AIRBRUSH» — Sirbrush «LINE» — Line «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	режим смешивания кисти, может быть одним из: «MIX» — Mix «ADD» — Mix «SUB» — Subtract «MUL» — Multiply «BLUR» — Blur «LIGHTEN» — Lighten «DARKEN» — Darken
bpy.data.brushes["B"].stroke_method	режим рисования кисти, может быть одним из: «DOTS» — Dots «SPACE» — Space «AIRBRUSH» — Sirbrush «LINE» — Line «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	тип физики объекта «NO_COLLISION» — No Collision «STATIC» — Static «DYNAMIC» — Dynamic «RIGID_BODY» — Rigid Body «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	тип границ столкновения «TRIANGLE_MESH» — Triangle Mesh «CONVEX_HULL» — Convex Hull «CONE» — Cone «RIGID_BODY» — Cylinder «SPHERE» — Sphere «BOX» — Box «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

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

Главные типы

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

Описание сенсоров

Имя	Класс	Свойства и функции	Типы свойств
Always	class bge.types.KX_AlwaysSensor(SCA_ISensor)	нет свойств	нет свойств
Collision	class bge.types.KX_TouchSensor(SCA_ISensor)	propName — имя свойства; если объект столкнется с объектом, имеющим это свойство то это будет считаться столкновением; если propName == , то столкновение с любым объектом будет считаться столкновением useMaterial — будет ли выполняться проверка на столкновение объекта со свойством (True) или с материалом (False)	propName — string; useMaterial — boolean
Delay	class bge.types.SCA_DelaySensor(SCA_ISensor)	delay — время между положительными сигналами, посылаемыми контроллеру duration — время, которое посылаются сигналы через промежутки времени Delay repeat — если равно 1, то цикл выполнения сенсора будет бесконечный, иначе должно равняться 0	delay, duration и repeat — integer
Keyboard	class bge.types.SCA_KeyboardSensor(SCA_ISensor)	key — главная клавиша hold1, hold2 — две остальные клавиши из комбинации клавиш useAllKeys — реагировать ли на нажатие любых клавиш (если равно True, то да) getKeyStatus(keycode) — получить состояние клавиши keycode (вместо keycode любая константа)	key, hold1, hold2 — тип клавиши; useAllKeys — логическое значение
Message	class bge.types.SCA_NetworkMessageSensor(SCA_ISensor)	subject — тема сообщения	subject — строка
Ray	class bge.types.SCA_RaySensor(SCA_ISensor)	propName — свойство, объекты с которым следует обнаруживать range — длина луча useMaterial — если равно True, то в propName следует будет вписать имя материала для обнаружения его лучом useXRay — если равно True, луч будет проходить сквозь все объекты, даже которые не имеют свойства axis — локальная ось, по которой будет направлен лучь KX_RAY_AXIS_POS_X — +X KX_RAY_AXIS_POS_Y — +Y KX_RAY_AXIS_POS_Z — +Z KX_RAY_AXIS_NEG_X — -X KX_RAY_AXIS_NEG_Y — -Y KX_RAY_AXIS_NEG_Z — -Z	propName — строковое значение; range — float; useMaterial, useXRay — логическое значение; axis — целое число
Near	class bge.types.KX_NearSensor(KX_NearSensor)	distance — расстояние, требуемое для активации сенсора resetDistance — дистанция, на которое следует отдалиться другому объекту, чтобы активный сенсор деактивировался	distance, resetDistance — float
Radar	class bge.types.KX_RadarSensor(KX_NearSensor)	propName — свойство, объекты с которым следует обнаруживать range — длина радара angle — угол радара useMaterial — если равно KX_True, то в propName следует будет вписать имя материала для обнаружения его лучом, иначе — при KX_False — имя свойства axis — локальная ось, по которой будет направлен конус радара KX_RADAR_AXIS_POS_X — +X KX_RADAR_AXIS_POS_Y — +Y KX_RADAR_AXIS_POS_Z — +Z KX_RADAR_AXIS_NEG_X — -X KX_RADAR_AXIS_NEG_Y — -Y 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)	script — имя запускаемого скрипта activate(act) — активация актуатора act, подключенного к скрипту deactivate(act) — деактивация актуатора act, подключенного к скрипту	script, act — строки

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

a = bge.logic.GetCurrentController()

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

obj = a.owner

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

Имя	Класс	Свойства	Типы свойств
Action	class bge.types.BL_ActionActuator(SCA_IActuator)	action — имя действия (анимации) frameStart — кадр, с которого будет проигрываться анимация frameEnd — кадр, на котором закончится проигрываться анимация	action — string; frameStart, frameEnd — float
Camera	class bge.types.KX_CameraActuator(SCA_IActuator)	min — минимальная дистанция до объекта, за которым следит камера max — максимальная дистанция от объекта, за котором следит камера object — имя объекта, за которым следит камера	min, max — float; object — KX_GameObject
Game	class bge.types.KX_GameActuator(SCA_IActuator)	fileName — имя файла игры, который откроется 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)	scene — имя сцены, с которой следует произвести какие-то изменения camera — имя камеры, которую следует установить mode — режим работы актуатора (от 0 — 5)	scene — string; camera — KX_Camera; mode — integer
Sound	class bge.types.KX_SoundActuator(SCA_IActuator)	volume — громкость звука time — секунда, с которой начнет воспроизводится аудио mode — режим воспроизведения аудио (KX_SOUNDACT_PLAYSTOP — проиграть один раз; KX_SOUNDACT_LOOPEND — проигрывать бесконечно) is3D — звучит ли музыка объемно volume_maximum — максимальная громкость звука (не зависит от расстояния) volume_minimum — минимальная громкость звука (не зависит от расстояния)	volume, time, volume_maximum, volume_minimum — float; mode — integer; is3D — boolean
State	class bge.types.KX_StateActuator(SCA_IActuator)	operation — операция, которая изменит состояние объекта (KX_STATE_OP_SET — установит новое состояние)	operation — integer
Sound	class bge.types.KX_SoundActuator(SCA_IActuator)	startSound() — начинает проигрывать звук pauseSound() — прекращает проигрывать звук 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	сенсор деактивировался только что

Состояния

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

bge.logic.KX_STATE1
bge.logic.KX_STATE2
bge.logic.KX_STATE3
bge.logic.KX_STATE4
bge.logic.KX_STATE5
bge.logic.KX_STATE6
bge.logic.KX_STATE7
bge.logic.KX_STATE8
bge.logic.KX_STATE9
bge.logic.KX_STATE10
bge.logic.KX_STATE11
bge.logic.KX_STATE12
bge.logic.KX_STATE13
bge.logic.KX_STATE14
bge.logic.KX_STATE15
bge.logic.KX_STATE16
bge.logic.KX_STATE17
bge.logic.KX_STATE18
bge.logic.KX_STATE19
bge.logic.KX_STATE20
bge.logic.KX_STATE21
bge.logic.KX_STATE22
bge.logic.KX_STATE23
bge.logic.KX_STATE24
bge.logic.KX_STATE25
bge.logic.KX_STATE26
bge.logic.KX_STATE27
bge.logic.KX_STATE28
bge.logic.KX_STATE29
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-ой позиции в списке вершин для этого материала

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

numPolygons — количество полигонов меша
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]

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

Класс полигона 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 — объект сцены-владельца скрипта.

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

Имя атрибута сцены	Описание	Возвращаемое значение
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

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

Имя функции	Описание	Параметры	Возвращаемое значение
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)

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

Имя атрибута сцены	Описание	Возвращаемое значение
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	Словарь всех актуаторов объекта.

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

applyMovement(movement, local=False) — переместить объект (тут movement — трехмерный вектор, указывающий перемещение по каждой оси; local = True означает, что тело будет двигаться в локальном пространстве, а при False — в глобальном)
applyForce(force, local=False) — переместить объект (тут force — трехмерный вектор, указывающий перемещение по каждой оси; local = True означает, что тело будет двигаться в локальном пространстве, а при False — в глобальном)
applyRotation(rotation, local=False) — повернуть объект (тут rotation — трехмерный вектор, указывающий угол поворота по каждой оси; local = True означает вращать в локальном пространстве, а при False — в глобальном)
applyTorque(torque, local=False) — повернуть объект с затуханием силы поворота (тут torque — трехмерный вектор, указывающий угол поворота по каждой оси; local = True означает вращать в локальном пространстве, а при False — в глобальном)
setParent(parent, compound=True, ghost=True) — установить родителя для объекта (parent — объект-родитель; при compound = True физические границы объектов будут объединены; при ghost = True пока объект имеет родителя он будет являться призраком)
addDebugProperty(name, debug = True) — включить/выключить отображение игрового свойства с именем name (включено при debug = True)
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)	Вернет список, содержащий относительные X и Y (от 0 до 1) спроецированного на экран центра объекта object.

Работа с Frustum

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

Значение	Описание
a.INTERSECT	Сфера или параллелепипед пересекает frustum.
a.INSIDE	Сфера или параллелепипед находится внутри frustum.
a.OUTSIDE	Сфера или параллелепипед находится вне frustum.

Функция, которая позволяет проверить где находится точка по отношению к frustum имеет следующий вид:
```
cam.sphereInsideFrustum([x, y, z])
```
Тут x, y, z — координаты центра точки.
Функция, которая позволяет проверить где находится сфера по отношению к frustum имеет следующий вид:
```
cam.sphereInsideFrustum([x, y, z], r)
```
Где x, y, z — координаты центра сферы, а r — ее радиус.
Функция, которая позволяет проверить где находится параллелепипед по отношению к 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	Тип источника освещения. Может быть одним из: SPOT — обычная лампа Lamp SUN — солнце 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()

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

dist — расстояние на котором сила света не равна 0.
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()

(d-const_dist) — узнаем дистанцию между объектом и лампой, отбросив расстояние const_dist
plus_d-(d-const_dist) — разность между расстояниями для того, чтобы сила света увеличивалась, а не уменьшалась по приближению объекта
(((plus_d-(d-const_dist))/plus_d) — узнаем какую часть от plus_d составляет текущее инвертированное расстояние с отбросом const_dist
((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)	создает меш, идентичный другому мешу	mesh — тот меш, с которого создается копия use_shape_key — если равно True, то будут использоваться измененные ключом формы с индексом shape_key_index координаты вершин
to_mesh(mesh)	записывает данные меша в mesh	mesh — имя меша, в который будут записаны данные другого меша
normal_update()	обновляет данные нормалей	нет

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

bm = bmesh.new()

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

verts — список вершин меша
edges — список ребер меша
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 может быть одним из:

r
g
b
h
s
v

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

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

n = mathutils.Euler(angles, O)

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

'XYZ'
'YXZ'
'YZX'
'XZY'
'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. f меняется от 0.0 до 1.0. Чем больше значение f, тем ближе полученный вектор к вектору b.

Настройка окна при помощи 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):

orientation
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

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

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