Script para hornear acciones de animación en Blender con Python

[SHAZAM]

Script para bakear actions, escrito por vladius para Blender:
(viene de este hilo).

#.Bpy.

Name: bake active action.

Blender: 242a.

Group: object.

Toltip: bake constraints todo action keys.
_author__ = vladius.
_url__ = [vladius, fanatic, ru"]
_versión__ = 1.0.
_bpydoc__ = \
Action bake let you bake the current object action constraints todo normal action keys.

Usage:
Select an object with an active action, and select bake active action from the object->scripts.

Menú of the 3d view.

From Blender import *
From Blender import types.

Import Sys.

Def invertmatrix(mtx):
Mtxi= Mathutils. Matrix(mtx)
Mtxi, invert()
Return mtxi.

Pose_xform= [object. Pose. Loc,object. Pose. Rot].

Def bakeaction(action, armatureobject):
Bakes supplied action for supplied armature.

Returns baked action.

Pose=armatureobject, getpose ()
Armature_data=armatureobject, getdata (),
Pose_bones= pose, Bones, values()
Rest_bones= armature_data, Bones.
 startframe= min(action, getframenumbers()),
Endframe= max(action, getframenumbers()).

Baked_action = armature. Nla. Newaction(baked_+action, getname ())
 old_quats={}
Old_locs={}.

Baked_locs={}
Baked_quats={} action, setactive (armatureobject)
For current_frame in xrange (startframe, endframe+1):
Redraw().

Set(curframe, current_frame) for i in range (len(pose_bones)):
Bone_name=pose_bones[i].name.

Rest_bone=rest_bones[bone_name]
Matrix=Mathutils. Matrix(pose_bones[i].posematrix)
#print pose Matrix\n, Matrix.

Rest_matrix=Mathutils. Matrix(rest_bone, Matrix[armaturespace])
#print rest Matrix\n, rest_matrix parent_bone=rest_bone, parent.

Print frame:, current_frame.

If parent_bone:
Parent_pose_bone=pose, Bones[parent_bone, name]
Matrix=Matrix*invertmatrix(parent_pose_bone, posematrix)
Rest_matrix=rest_matrix*invertmatrix(parent_bone, Matrix[armaturespace]).
#print before\n, Matrix.

Print before quat\n, pose_bones[i].quat.
#print localised postura Matrix\n, Matrix.
#print localised rest Matrix\n, rest_matrix.

Matrix=Matrix*invertmatrix(rest_matrix)
 old_quats[bone_name]=Mathutils. Quaternion(pose_bones[i].quat),
Old_locs[bone_name]=Mathutils. Vector(pose_bones[i].loc).

Baked_locs[bone_name]=Mathutils. Vector(Matrix.translationpart())
Baked_quats[bone_name]=Mathutils. Quaternion(Matrix.toquat()).

Baked_action, setactive (armatureobject)
Set(curframe, current_frame)
For I in range (len(pose_bones)):
Pose_bones[i].quat=baked_quats[pose_bones[i].name]
Pose_bones[i].loc=baked_locs[pose_bones[i].name]
Pose_bones[i].insertkey(armatureobject, current_frame, pose_xform) action, setactive (armatureobject)
Set(curframe, current_frame).

For name, quat in old_quats, iteritems():
Pose, Bones[name].quat=quat for name, Loc in old_locs, iteritems():
Pose, Bones[name].loc=loc.
 pose, update ()
Return baked_action.

Def main():
Main script driver.
# get current scene.

Scene= scene. Getcurrent()
# get current object(must be armature)
Armatureobject= scene, getactiveobject()
If armatureobject, gettype ().=armature:
Print select armature first.

Return.
# get current pose.

For I in range (len(pose_bones)):
Print rest_bones, values()[i].name.

Print head(arm), rest_bones, values()[i].head[armaturespace]
Print tail(arm), rest_bones, values()[i].tail[armaturespace]
Print roll(arm), rest_bones, values()[i].roll[armaturespace]
Print head(bone), rest_bones, values()[i].head[bonespace]
Print tail(bone), rest_bones, values()[i].tail[bonespace]
Print roll(bone), rest_bones, values()[i].roll[bonespace]
Print armature-space\n, rest_bones, values()[i].Matrix[armaturespace]
Print bone-space\n, rest_bones, values()[i].Matrix[bonespace].

For I in range (len(pose_bones)):
Print pose_bones[i].name.

Print pose Matrix\n, pose_bones[i].posematrix.

Print starting todo bake actions.

Actions = armature. Nla. Getactions() for action_name, action in actions, iteritems():
Bakeaction(action, pose_bones, rest_bones)
Action=armatureobject, getaction().

Bakeaction(action, armatureobject).

If __name__==__main__:
#import rpdb2, rpdb2.start_embedded_debugger(password,true)
Main()

[LaUrA-28]

Este script de Blender 2.42a es muy antiguo y ya no funciona en versiones modernas de Blender. La API de Python de Blender cambió por completo alrededor de la versión 2.5. Hoy en día, hornear (bake) acciones es mucho más sencillo y está integrado directamente en la interfaz.

Para hornear una acción de animación en Blender actual (versiones 2.8, 2.9, 3.x y 4.x), el proceso es el siguiente. Primero, selecciona tu objeto con animación, por ejemplo, un brazo con huesos y restricciones. Ve a la ventana de la línea de tiempo o del editor de gráficos de animación. En el menú superior, busca la opción Object o Pose. Allí encontrarás la función Bake Action.

Al seleccionar Bake Action se abrirá un panel de opciones. Debes asegurarte de que el rango de fotogramas esté correcto, desde el fotograma inicial hasta el final de tu animación. Es importante marcar la opción Visual Keying para que se tengan en cuenta todas las restricciones e influencias de la animación. También debes activar Clear Constraints si quieres que las restricciones se eliminen después de hornear, dejando solo los fotogramas clave puros.

Finalmente, haz clic en el botón Bake o OK. Blender calculará la animación fotograma a fotograma y creará una nueva acción con todos los fotogramas clave. Esta nueva acción estará libre de dependencias de restricciones. Puedes asignar un nombre a esta acción horneada en el editor de ventana de propiedades, en la pestaña de animación. Este método es el estándar actual y no requiere ningún script adicional.