Автоматизация анимации в Blender: Python как секретное оружие

import bpy

# Получение доступа к активному объекту
obj = bpy.context.active_object

# Установка позиции объекта
obj.location = (1.0, 2.0, 3.0)

# Применение вращения (в радианах)
obj.rotation_euler = (0.5, 0, 0)

# Обновление сцены
bpy.context.view_layer.update()

import bpy

# Очистка сцены
bpy.ops.object.select_all(action='DESELECT')
bpy.ops.object.select_by_type(type='MESH')
bpy.ops.object.delete()

# Создание куба
bpy.ops.mesh.primitive_cube_add(size=2, location=(0, 0, 0))
cube = bpy.context.active_object

# Установка начального кадра
bpy.context.scene.frame_set(1)
bpy.context.scene.frame_start = 1

# Создание ключевого кадра для начальной позиции
cube.location = (0, 0, 0)
cube.keyframe_insert(data_path="location", frame=1)

# Перемещение к конечному кадру
bpy.context.scene.frame_set(30)
bpy.context.scene.frame_end = 30

# Установка новой позиции и создание второго ключевого кадра
cube.location = (5, 0, 0)
cube.keyframe_insert(data_path="location", frame=30)

import bpy
import math

# Создаем маятник
bpy.ops.mesh.primitive_uv_sphere_add(radius=1, location=(0, 0, 0))
pendulum = bpy.context.active_object

# Устанавливаем параметры анимации
start_frame = 1
end_frame = 100
amplitude = 30 # амплитуда в градусах
period = 50 # период колебания в кадрах

# Создаем ключевые кадры для колебательного движения
for frame in range(start_frame, end_frame + 1):
# Вычисляем угол в текущем кадре по формуле гармонического колебания
t = (frame – start_frame) / period
angle = amplitude * math.sin(2 * math.pi * t)

# Преобразуем градусы в радианы
angle_rad = math.radians(angle)

# Устанавливаем вращение объекта
pendulum.rotation_euler = (0, angle_rad, 0)

# Вставляем ключевой кадр
pendulum.keyframe_insert(data_path="rotation_euler", frame=frame)

# После создания ключевых кадров
for fcurve in pendulum.animation_data.action.fcurves:
for kf in fcurve.keyframe_points:
kf.interpolation = 'BEZIER' # Можно заменить на другие типы

import bpy
import random
import math

# Количество объектов
num_objects = 20

# Создаем группу кубов
cubes = []
for i in range(num_objects):
x = random.uniform(-10, 10)
y = random.uniform(-10, 10)
bpy.ops.mesh.primitive_cube_add(size=0.5, location=(x, y, 0))
cube = bpy.context.active_object
cubes.append(cube)

# Анимируем каждый куб с небольшими вариациями
for i, cube in enumerate(cubes):
# Уникальные параметры для каждого куба
amplitude = random.uniform(1, 3)
frequency = random.uniform(0.5, 2.0)
phase = random.uniform(0, 2 * math.pi)

# Создаем ключевые кадры
for frame in range(1, 101):
# Вычисляем высоту в текущем кадре
t = frame / 20.0
z = amplitude * math.sin(frequency * t + phase)

# Устанавливаем позицию
cube.location.z = z

# Вставляем ключевой кадр
cube.keyframe_insert(data_path="location", frame=frame)

import bpy
import math

# Параметры сетки
rows, cols = 10, 10
spacing = 2.0

# Параметры волны
wave_speed = 0.1
wave_height = 1.5
wave_frequency = 0.5

# Создаем сетку объектов
objects = []
for i in range(rows):
for j in range(cols):
x = j * spacing – (cols – 1) * spacing / 2
y = i * spacing – (rows – 1) * spacing / 2

bpy.ops.mesh.primitive_uv_sphere_add(radius=0.3, location=(x, y, 0))
obj = bpy.context.active_object
objects.append(obj)

# Создаем обработчик кадра
def animate_wave(scene):
current_frame = scene.frame_current
time = current_frame * wave_speed

for i, obj in enumerate(objects):
# Получаем исходные координаты
row = i // cols
col = i % cols
x = col * spacing – (cols – 1) * spacing / 2
y = row * spacing – (rows – 1) * spacing / 2

# Вычисляем высоту волны для данной позиции и времени
distance_from_center = math.sqrt(x**2 + y**2)
z = wave_height * math.sin(wave_frequency * distance_from_center – time)

# Обновляем позицию объекта
obj.location.z = z

# Регистрируем обработчик в качестве обработчика кадра
bpy.app.handlers.frame_change_pre.append(animate_wave)

import bpy
import math

# Очистка сцены от существующих объектов
bpy.ops.object.select_all(action='DESELECT')
bpy.ops.object.select_by_type(type='MESH')
bpy.ops.object.delete()

# Создаем сферу для анимации
bpy.ops.mesh.primitive_uv_sphere_add(radius=0.5, location=(0, 0, 0))
sphere = bpy.context.active_object

# Параметры спирали
spiral_radius = 5
spiral_height = 10
spiral_revolutions = 3
frames_total = 240

# Создаем ключевые кадры для спирального движения с затуханием
for frame in range(frames_total + 1):
# Нормализованное время от 0 до 1
t = frame / frames_total

# Параметры спирали
angle = t * spiral_revolutions * 2 * math.pi
radius = spiral_radius * (1 – t**1.5) # Затухающий радиус

# Вычисляем позицию
x = radius * math.cos(angle)
y = radius * math.sin(angle)
z = t * spiral_height

# Устанавливаем позицию объекта
sphere.location = (x, y, z)

# Добавляем ключевой кадр
sphere.keyframe_insert(data_path="location", frame=frame)

import bpy
import math

# Создаем маятник
bpy.ops.mesh.primitive_uv_sphere_add(radius=1, location=(0, 0, -10))
pendulum = bpy.context.active_object

# Параметры физической модели
gravity = 9.8
pendulum_length = 10.0
damping_factor = 0.02
initial_angle = math.radians(45)
frames_per_second = 24
simulation_time = 10 # в секундах

# Функция для вычисления угла маятника в момент времени t
def calculate_angle(t):
# Формула затухающих колебаний
omega = math.sqrt(gravity / pendulum_length) # собственная частота
return initial_angle * math.exp(-damping_factor * t) * math.cos(omega * t)

# Создаем анимацию
frames_total = simulation_time * frames_per_second
for frame in range(frames_total + 1):
# Вычисляем время в секундах
t = frame / frames_per_second

# Вычисляем угол маятника
angle = calculate_angle(t)

# Вычисляем позицию конца маятника
x = pendulum_length * math.sin(angle)
z = -pendulum_length * math.cos(angle)

# Устанавливаем позицию
pendulum.location = (x, 0, z)

# Добавляем ключевой кадр
pendulum.keyframe_insert(data_path="location", frame=frame)

import bpy
import mathutils.noise

# Создаем плоскость для анимации поверхности
bpy.ops.mesh.primitive_grid_add(x_subdivisions=50, y_subdivisions=50, size=20)
grid = bpy.context.active_object

# Переходим в режим редактирования для доступа к вершинам
bpy.ops.object.mode_set(mode='EDIT')
bpy.ops.mesh.select_all(action='SELECT')
bpy.ops.object.mode_set(mode='OBJECT')

# Параметры шума
noise_scale = 1.0
time_scale = 0.05
height_scale = 2.0

# Функция для анимации поверхности с помощью шума Перлина
def animate_surface(scene):
frame = scene.frame_current
time = frame * time_scale

# Перебираем все вершины сетки
for i, vertex in enumerate(grid.data.vertices):
# Получаем исходные координаты (без Z)
x, y = vertex.co.x, vertex.co.y

# Вычисляем значение шума в 3D пространстве (x, y, time)
noise_value = mathutils.noise.noise((x * noise_scale, 
y * noise_scale, 
time))

# Устанавливаем высоту вершины
vertex.co.z = noise_value * height_scale

# Регистрируем обработчик кадра
bpy.app.handlers.frame_change_pre.append(animate_surface)

import bpy
from bpy.props import FloatProperty, IntProperty, BoolProperty

bl_info = {
"name": "Animation Assistant",
"author": "Your Name",
"version": (1, 0),
"blender": (2, 93, 0),
"location": "View3D > Sidebar > Animation Tab",
"description": "Tools for procedural animation",
"category": "Animation",
}

# Оператор для создания волновой анимации
class OBJECT_OT_wave_animation(bpy.types.Operator):
bl_idname = "object.wave_animation"
bl_label = "Create Wave Animation"
bl_options = {'REGISTER', 'UNDO'}

amplitude: FloatProperty(
name="Amplitude",
description="Height of the wave",
default=1.0,
min=0.1,
max=10.0
)

frequency: FloatProperty(
name="Frequency",
description="Frequency of the wave",
default=0.5,
min=0.1,
max=5.0
)

frames: IntProperty(
name="Frames",
description="Number of frames for animation",
default=100,
min=10,
max=1000
)

def execute(self, context):
obj = context.active_object

if obj is None:
self.report({'ERROR'}, "No active object selected")
return {'CANCELLED'}

# Создаем анимацию волны
for frame in range(self.frames + 1):
# Устанавливаем текущий кадр
context.scene.frame_set(frame)

# Вычисляем значение волны
import math
value = self.amplitude * math.sin(frame * self.frequency * 0.1)

# Применяем к Z-координате
obj.location.z = value

# Вставляем ключевой кадр
obj.keyframe_insert(data_path="location", frame=frame)

self.report({'INFO'}, "Wave animation created successfully")
return {'FINISHED'}

# Панель интерфейса для анимационных инструментов
class VIEW3D_PT_animation_tools(bpy.types.Panel):
bl_label = "Animation Tools"
bl_idname = "VIEW3D_PT_animation_tools"
bl_space_type = 'VIEW_3D'
bl_region_type = 'UI'
bl_category = 'Animation'

def draw(self, context):
layout = self.layout

layout.label(text="Procedural Animations:")
layout.operator("object.wave_animation")

# Здесь можно добавить другие операторы и настройки

# Регистрация и отмена регистрации
classes = (
OBJECT_OT_wave_animation,
VIEW3D_PT_animation_tools,
)

def register():
for cls in classes:
bpy.utils.register_class(cls)

def unregister():
for cls in reversed(classes):
bpy.utils.unregister_class(cls)

if __name__ == "__main__":
register()

import bpy
import gpu
import blf
from gpu_extras.batch import batch_for_shader
from bpy_extras import view3d_utils

# Оператор для интерактивной анимации
class ANIMATION_OT_interactive_animate(bpy.types.Operator):
bl_idname = "animation.interactive_animate"
bl_label = "Interactive Animation"

# Переменные для отслеживания состояния
_active_obj = None
_start_location = None
_handle = None

def modal(self, context, event):
# Обработка выхода из режима
if event.type in {'ESC'} or event.type == 'RIGHTMOUSE':
# Удаляем обработчик отрисовки
bpy.types.SpaceView3D.draw_handler_remove(self._handle, 'WINDOW')
return {'CANCELLED'}

# Обработка завершения операции
elif event.type == 'LEFTMOUSE' and event.value == 'RELEASE':
# Вставляем ключевой кадр для текущего положения
if self._active_obj:
self._active_obj.keyframe_insert(data_path="location", frame=context.scene.frame_current)
# Увеличиваем текущий кадр
context.scene.frame_current += 1
return {'RUNNING_MODAL'}

# Обработка движения мыши
elif event.type == 'MOUSEMOVE' and self._active_obj:
# Получаем координаты 3D-курсора в пространстве сцены
region = context.region
rv3d = context.region_data
coord = event.mouse_region_x, event.mouse_region_y

# Получаем направление луча из позиции камеры
view_vector = view3d_utils.region_2d_to_vector_3d(region, rv3d, coord)
ray_origin = view3d_utils.region_2d_to_origin_3d(region, rv3d, coord)

# Вычисляем новую позицию объекта в плоскости XY
# (упрощенный подход для демонстрации)
plane_normal = (0, 0, 1)
plane_co = (0, 0, self._active_obj.location.z)

intersection = intersect_line_plane(ray_origin, ray_origin + view_vector, plane_co, plane_normal)

if intersection:
self._active_obj.location.x = intersection[0]
self._active_obj.location.y = intersection[1]
# Z-координата остается неизменной

return {'RUNNING_MODAL'}

return {'PASS_THROUGH'}

def invoke(self, context, event):
if context.active_object:
self._active_obj = context.active_object
self._start_location = self._active_obj.location.copy()

# Добавляем обработчик для отрисовки информации
args = (self, context)
self._handle = bpy.types.SpaceView3D.draw_handler_add(self.draw_callback_px, args, 'WINDOW', 'POST_PIXEL')

context.window_manager.modal_handler_add(self)
return {'RUNNING_MODAL'}
else:
self.report({'WARNING'}, "No active object")
return {'CANCELLED'}

# Функция для отрисовки информации на экране
def draw_callback_px(self, op, context):
# Отображение информации о текущем кадре и режиме
font_id = 0
blf.position(font_id, 15, 30, 0)
blf.size(font_id, 20.0)
blf.draw(font_id, f"Frame: {context.scene.frame_current}")

blf.position(font_id, 15, 60, 0)
blf.draw(font_id, "Interactive Animation Mode")

# Функция для определения пересечения луча и плоскости
def intersect_line_plane(line_a, line_b, plane_co, plane_no):
"""
Вычисляет пересечение между линией и плоскостью
"""
u = line_b – line_a
dot = plane_no.dot(u)

if abs(dot) > 1e-6:
w = line_a – plane_co
fac = -plane_no.dot(w) / dot
return line_a + u * fac

return None

import bpy

# Функция для копирования анимации с одного объекта на другие
def copy_animation(source_obj, target_objs):
# Проверяем, есть ли у исходного объекта анимация
if not source_obj.animation_data or not source_obj.animation_data.action:
print(f"Source object '{source_obj.name}' has no animation")
return False

source_action = source_obj.animation_data.action

# Копируем анимацию на каждый целевой объект
for obj in target_objs:
# Убеждаемся, что у объекта есть animation_data
if not obj.animation_data:
obj.animation_data_create()

# Копируем действие (Action)
obj.animation_data.action = source_action.copy()
print(f"Animation copied to '{obj.name}'")

return True

# Основной скрипт
def batch_apply_animation():
# Получаем выбранные объекты
selected_objs = bpy.context.selected_objects

if len(selected_objs) < 2:
print("Select at least two objects (source first, then targets)")
return

# Первый выбранный объект будет источником анимации
source_obj = selected_objs[0]
target_objs = selected_objs[1:]

if copy_animation(source_obj, target_objs):
print(f"Animation successfully copied from '{source_obj.name}' to {len(target_objs)} objects")
else:
print("Failed to copy animation")

# Запускаем функцию
batch_apply_animation()

import bpy
import math

# Функция для проверки, является ли ключевой кадр избыточным
def is_keyframe_redundant(kf_prev, kf_curr, kf_next, tolerance=0.001):
if kf_prev is None or kf_next is None:
return False

# Проверяем, лежат ли три точки примерно на одной линии
t1 = (kf_curr.co[0] – kf_prev.co[0])
t2 = (kf_next.co[0] – kf_curr.co[0])

if t1 == 0 or t2 == 0:
return False

# Вычисляем наклоны между точками
slope1 = (kf_curr.co[1] – kf_prev.co[1]) / t1
slope2 = (kf_next.co[1] – kf_curr.co[1]) / t2

# Если наклоны примерно одинаковы, кадр избыточен
return abs(slope1 – slope2) < tolerance

# Функция для оптимизации анимационных кривых объекта
def optimize_animation_curves(obj, tolerance=0.001):
if not obj.animation_data or not obj.animation_data.action:
print(f"Object '{obj.name}' has no animation")
return 0

action = obj.animation_data.action
total_removed = 0

# Обрабатываем каждую кривую анимации
for fcurve in action.fcurves:
keyframes = fcurve.keyframe_points

if len(keyframes) < 3:
continue # Нужно минимум 3 точки для анализа

# Создаем список ключевых кадров для удаления
to_remove = []

# Проверяем каждый ключевой кадр (кроме первого и последнего)
for i in range(1, len(keyframes) – 1):
kf_prev = keyframes[i-1]
kf_curr = keyframes[i]
kf_next = keyframes[i+1]

if is_keyframe_redundant(kf_prev, kf_curr, kf_next, tolerance):
to_remove.append(i)

# Удаляем избыточные ключевые кадры (с конца, чтобы не сбить индексы)
for i in reversed(to_remove):
fcurve.keyframe_points.remove(keyframes[i])

total_removed += len(to_remove)

return total_removed

# Основной скрипт для оптимизации анимации выбранных объектов
def batch_optimize_animation(tolerance=0.001):
selected_objs = bpy.context.selected_objects

if not selected_objs:
print("No objects selected")
return

total_removed = 0
for obj in selected_objs:
removed = optimize_animation_curves(obj, tolerance)
if removed > 0:
print(f"Removed {removed} redundant keyframes from '{obj.name}'")
total_removed += removed

print(f"Total keyframes removed: {total_removed}")

# Запускаем оптимизацию с определенным порогом точности
batch_optimize_animation(tolerance=0.005)

import bpy
import os
from datetime import datetime

# Функция для настройки и запуска рендерa анимации
def setup_and_render_animation(output_path=None, resolution_percentage=100,
start_frame=None, end_frame=None, file_format='PNG'):
# Получаем текущую сцену
scene = bpy.context.scene

# Сохраняем оригинальные настройки
original_path = scene.render.filepath
original_res_pct = scene.render.resolution_percentage
original_start = scene.frame_start
original_end = scene.frame_end
original_format = scene.render.image_settings.file_format

try:
# Устанавливаем путь для вывода
if output_path is None:
# Генерируем путь на основе текущего времени
now = datetime.now().strftime("%Y%m%d_%H%M%S")
output_path = os.path.join(os.path.expanduser("~"), "BlenderRenders", f"render_{now}")

# Создаем директорию, если она не существует
os.makedirs(output_path, exist_ok=True)

scene.render.filepath = output_path

# Устанавливаем разрешение
scene.render.resolution_percentage = resolution_percentage

# Устанавливаем диапазон кадров
if start_frame is not None:
scene.frame_start = start_frame
if end_frame is not None:
scene.frame_end = end_frame

# Устанавливаем формат файла
scene.render.image_settings.file_format = file_format

# Выводим информацию о рендеринге
print(f"Rendering animation to: {output_path}")
print(f"Frames: {scene.frame_start} – {scene.frame_end}")
print(f"Resolution: {scene.render.resolution_x}x{scene.render.resolution_y} at {resolution_percentage}%")

# Запускаем рендер
bpy.ops.render.render(animation=True)

print("Rendering completed successfully!")
return True

except Exception as e:
print(f"Error during rendering: {str(e)}")
return False

finally:
# Восстанавливаем оригинальные настройки
scene.render.filepath = original_path
scene.render.resolution_percentage = original_res_pct
scene.frame_start = original_start
scene.frame_end = original_end
scene.render.image_settings.file_format = original_format

# Вызов функции с пользовательскими параметрами
setup_and_render_animation(
output_path="/path/to/output/folder",
resolution_percentage=50, # Половинное разрешение для быстрого рендера
start_frame=10,
end_frame=50,
file_format='PNG'
)

import bpy
import os
import subprocess
import platform

def export_animation_to_fbx(obj, output_file, frame_range=None):
# Выбираем только нужный объект
bpy.ops.object.select_all(action='DESELECT')
obj.select_set(True)
bpy.context.view_layer.objects.active = obj

# Устанавливаем диапазон кадров, если указан
if frame_range:
start_frame, end_frame = frame_range
else:
# Используем весь диапазон анимации
start_frame = bpy.context.scene.frame_start
end_frame = bpy.context.scene.frame_end

# Экспортируем в FBX
bpy.ops.export_scene.fbx(
filepath=output_file,
use_selection=True,
bake_anim=True,
bake_anim_use_all_bones=False,
bake_anim_use_nla_strips=False,
bake_anim_use_all_actions=False,
bake_anim_force_startend_keying=True,
bake_anim_step=1.0,
bake_anim_simplify_factor=0.0,
path_mode='RELATIVE',
embed_textures=True,
batch_mode='OFF',
use_metadata=True,
global_scale=1.0,
axis_forward='-Z',
axis_up='Y',
bake_space_transform=False,
use_mesh_modifiers=True,
mesh_smooth_type='EDGE',
use_armature_deform_only=False,
add_leaf_bones=False,
primary_bone_axis='Y',
secondary_bone_axis='X',
use_custom_props=False
)

return os.path.exists(output_file)

def send_system_notification(title, message):
"""Отправляет системное уведомление"""
system = platform.system()

if system == 'Darwin': # macOS
cmd = ['osascript', '-e', f'display notification "{message}" with title "{title}"']
elif system == 'Linux':
cmd = ['notify-send', title, message]
elif system == 'Windows':
# На Windows используем PowerShell
ps_script = f'[System.Windows.Forms.MessageBox]::Show("{message}", "{title}")'
cmd = ['powershell', '-Command', ps_script]
else:
print(f"System {system} not supported for notifications")
return False

try:
subprocess.run(cmd, check=True)
return True
except subprocess.SubprocessError:
print("Failed to send notification")
return False

# Пример использования: экспорт анимации и отправка уведомления
def export_animation_workflow():
# Получаем активный объект
obj = bpy.context.active_object

if not obj:
print("No active object selected")
return

# Определяем путь для экспорта
output_dir = os.path.expanduser("~/Desktop/BlenderExports")
os.makedirs(output_dir, exist_ok=True)

filename = f"{obj.name}_animation.fbx"
output_file = os.path.join(output_dir, filename)

# Экспортируем анимацию
if export_animation_to_fbx(obj, output_file, frame_range=(10, 50)):
message = f"Animation exported to {output_file}"
print(message)
send_system_notification("Blender Export Complete", message)
else:
message = "Failed to export animation"
print(message)
send_system_notification("Blender Export Failed", message)

# Запускаем рабочий процесс
export_animation_workflow()