Gracias Gracias:  1
Página 1 de 5 12345 ÚltimoÚltimo
Resultados 1 al 15 de 62

Tema: Necesito un Script para bakear animacion de bones manejados por constraints

  1. #1
    BlenderAdicto Avatar de Caronte
    Fecha de ingreso
    Dec 2004
    Ubicación
    Valencia-España
    Mensajes
    14,691

    Blender Necesito un Script para bakear animación de bones manejados por constraints.

    Si alguien tiene un script para hacer eso que funcione en Blender 2.57, que avise
    Además, si alguno de los gurus de Python se atreve a hacerlo, que me diga cuanto me cobraría por si podemos llegar a un acuerdo

    Gracias!
    "Algún día todo será digital". Caronte.
    Mi web: NicoDigital.com

  2. #2
    Senior Member Avatar de oscurart
    Fecha de ingreso
    Jul 2009
    Mensajes
    354

    Re: Necesito un Script para bakear animación de bones manejados por constraints.

    Yo necesitaría tiempo, pero no es muy difícil... creo.

    Si lo hago no es por dinero, pero, para cuando lo necesitasí

    [edito]: Estoy buscando la forma de encontrar el parámetro de location para objetos con constraint, por que al parecer no se modifican las coordenadas!!!
    Última edición por oscurart; 17-05-2011 a las 20:20
    Eugenio Pignataro
    Site: www.oscurart.com.ar
    Blog: oscurart.blogspot.com
    Email: infoARROBAoscurart.com.ar
    Teléfono: 1551774936

  3. #3
    BlenderAdicto Avatar de Caronte
    Fecha de ingreso
    Dec 2004
    Ubicación
    Valencia-España
    Mensajes
    14,691

    Re: Necesito un Script para bakear animación de bones manejados por constraints.

    Gracias

    La prisa es relativa, lo necesitaría para la semana que viene, pero si no puede ser, en cualquier momento me vale, porque siempre uso constraints y muchas veces me he encontrado con ese problema

    Hmmm... :-que No es tan fácil como buscar ese parámetro, porque los huesos que no tienen curvas de animación, están (si no me equivoco) a cero sin importar lo que hagan por otros medios, como constraints o movimientos del padre. Creo que hay que usar matrices y calcular la posición en coordenadas del World, pero no me hagas mucho caso.

    Había un Script que hizo Seyacat hace mucho que bakeaba la animación del game-engine y creo que usaba ese método, lo he buscado por si le sirve a alguien de ayuda, pero no lo encuentro.

    Este script es muy interesante para los que tenemos que lidiar con exportaciones a otros softs, así que si lo hicieses (tú o cualquier otro) estaría encantado de pagar por él y si insistes en no hacerlo por dinero, pues no sé, te presento a alguna amiga que este buena
    "Algún día todo será digital". Caronte.
    Mi web: NicoDigital.com

  4. #4
    Senior Member Avatar de oscurart
    Fecha de ingreso
    Jul 2009
    Mensajes
    354

    Re: Necesito un Script para bakear animación de bones manejados por constraints.

    Jajaja, te agradezco el ofrecimiento, pero se me complica!.

    Estoy viendo los parámetros entre render y render. Es evidente que hace falta esté parámetro.
    Si encuentro este punto ya casi que lo tengo.



    Edito, Encontré la opción, ahora estoy interpretandola para recuperarla.
    Última edición por oscurart; 17-05-2011 a las 21:11
    Eugenio Pignataro
    Site: www.oscurart.com.ar
    Blog: oscurart.blogspot.com
    Email: infoARROBAoscurart.com.ar
    Teléfono: 1551774936

  5. #5
    Senior Member Avatar de oscurart
    Fecha de ingreso
    Jul 2009
    Mensajes
    354

    Re: Necesito un Script para bakear animación de bones manejados por constraints.

    Si, es con matrices, evidentemente.

    Tengo que estudiar eso ya que es un tema pendiente. Me parece que te la debo..

    Deberia haber un valor resultante eh.... seria muy bueno.
    Eugenio Pignataro
    Site: www.oscurart.com.ar
    Blog: oscurart.blogspot.com
    Email: infoARROBAoscurart.com.ar
    Teléfono: 1551774936

  6. #6
    BlenderAdicto Avatar de Caronte
    Fecha de ingreso
    Dec 2004
    Ubicación
    Valencia-España
    Mensajes
    14,691

    Re: Necesito un Script para bakear animación de bones manejados por constraints.

    Ok, no te preocupes, se agradece igualmente
    A ver si algún otro forero se anima
    "Algún día todo será digital". Caronte.
    Mi web: NicoDigital.com

  7. #7
    Senior Member Avatar de oscurart
    Fecha de ingreso
    Jul 2009
    Mensajes
    354

    Blender Re: Necesito un Script para bakear animación de bones manejados por constraints.

    Bueno, encontré algo a ver si lo puedo hacer.
    Si lo logro te digo.
    Eugenio Pignataro
    Site: www.oscurart.com.ar
    Blog: oscurart.blogspot.com
    Email: infoARROBAoscurart.com.ar
    Teléfono: 1551774936

  8. #8
    Senior Member Avatar de oscurart
    Fecha de ingreso
    Jul 2009
    Mensajes
    354

    Re: Necesito un Script para bakear animación de bones manejados por constraints.

    import bpy
    import math

    #bpy.data.objects['Cube.001'].rotation_euler = bpy.data.objects['Cube'].matrix_world.to_euler()

    START=1
    END=50

    while START < END:
    """
    bpy.data.objects['Cube'].rotation_euler = bpy.data.objects['Cube'].matrix_world.to_euler()
    bpy.data.objects['Cube'].keyframe_insert("rotation_euler",frame=START)
    bpy.context.scene.frame_current= START
    """
    print(bpy.data.objects['Cube'].matrix_world.to_euler())
    print(START)
    START+=1

    No se como resolver el problema de refresco....
    Es un WIP, hay que ver como solucionar eso....
    Archivos adjuntados Archivos adjuntados
    Eugenio Pignataro
    Site: www.oscurart.com.ar
    Blog: oscurart.blogspot.com
    Email: infoARROBAoscurart.com.ar
    Teléfono: 1551774936

  9. #9
    Senior Member Avatar de oscurart
    Fecha de ingreso
    Jul 2009
    Mensajes
    354

    Blender Re: Necesito un Script para bakear animación de bones manejados por constraints.

    Bien, lo logré con un cubo.
    Aun no entiendo como es la matrix de un joint.


    Te dejo el blend...

    Abrilo y dale manualmente run script, run script, run script.... ya que el for, while y todo eso no funciona.
    Vamos avanzando.
    Archivos adjuntados Archivos adjuntados
    Eugenio Pignataro
    Site: www.oscurart.com.ar
    Blog: oscurart.blogspot.com
    Email: infoARROBAoscurart.com.ar
    Teléfono: 1551774936

  10. #10
    BlenderAdicto Avatar de Caronte
    Fecha de ingreso
    Dec 2004
    Ubicación
    Valencia-España
    Mensajes
    14,691

    Re: Necesito un Script para bakear animación de bones manejados por constraints.

    Me estas alegrando el día
    Ahora estoy en el trabajo, pero esta tarde le echo un vistazo
    "Algún día todo será digital". Caronte.
    Mi web: NicoDigital.com

  11. #11
    BlenderAdicto Avatar de Caronte
    Fecha de ingreso
    Dec 2004
    Ubicación
    Valencia-España
    Mensajes
    14,691

    Re: Necesito un Script para bakear animación de bones manejados por constraints.

    ¡Ostras, qué cortito! Me encanta que el API sea ahora más completo y se pueda hacer esto más facilmente.
    Bueno, he probado tu ejemplo y funciona perfecto, pero tendré que esperar a ver si puedes hacer que funcione con Bones o no me servirá, además de que son muchos Bones :-que Lo suyo sería seleccionar (en modo pose) todos los que necesitase bakear y que el script lo haga. y ya para terminar de pulirlo, si pudiese bakear la posición y el tamaño, ya sería la hostia, aunque lo que realmente necesito ahora es el bakeo de la rotación, porque al ser una jerarquia, si roto el padre, lógicamente el hijo cambia de posición automáticamente.
    Gracias!!
    P.D: Ains! Qué gustillo me ha dado ver la curva de animación bakeada
    "Algún día todo será digital". Caronte.
    Mi web: NicoDigital.com

  12. #12
    BlenderAdicto Avatar de Caronte
    Fecha de ingreso
    Dec 2004
    Ubicación
    Valencia-España
    Mensajes
    14,691

    Re: Necesito un Script para bakear animación de bones manejados por constraints.

    Hola
    Yo no controlo Python, pero como la lógica es la misma en todos los lenguajes, voy a intentar echar una mano...
    Creo que entiendo porqué no te funciona el bucle, bueno no es que no te funcione, sino que la primera vez que insertas un keyframe el objeto ya no va a rotar, porqué ese keyframe se extrapola durante toda la animación, así que si no me equivoco, lo que hay que hacer es usar dos bucles, en el primero se guardan los valores en un array y en el segundo se crean los keyframes
    ¿Tiene sentido?
    "Algún día todo será digital". Caronte.
    Mi web: NicoDigital.com

  13. #13
    BlenderAdicto Avatar de Caronte
    Fecha de ingreso
    Dec 2004
    Ubicación
    Valencia-España
    Mensajes
    14,691

    Re: Necesito un Script para bakear animación de bones manejados por constraints.

    Mira, he encontrado este Script viejo de la 2.4x del que quizás puedas aprovechar alguna parte:
    Código:
    #!BPY
    
    """
    Name: 'Bake Constraints'
    Blender: 246
    Group: 'Animation'
    Tooltip: 'Bake a Constrained object/rig to IPOs'
    Fillename: 'Bake_Constraint.py'
    """
    
    __author__ = "Roger Wickes (rogerwickes(at)yahoo.com)"
    __script__ = "Animation Bake Constraints"
    __versión__ = "0.7"
    __url__ = ["Commúnicate problems and errors, http://www.blenderartists.com/forum/private.php?do=newpm to PapaSmurf"]
    __email__= ["Roger Wickes, rogerwickes@yahoo.com", "scripts"]
    __bpydoc__ = """\
    
    bake_constraints
    
    This script bakes the real-world LocRot of an object (the net effect of any constraints - 
    (Copy, Limit, Track, Follow, - that affect Location, Rotation)
    (usually one constrained to match another's location and/or Tracked to another)
    and creates a clone with a set of Ipo Curves named Ipo<objname>
    These curves control a non-constrained object and thus make it mimic the constrained object
    Actions can be then be edited without the need for the drivers/constraining objects
    
    Developed for use with MoCap data, where a bone is constrained to point at an empty
    moving through space and time. This records the actual locrot of the armature
    so that the motion can be edited, reoriented, scaled, and used as NLA Actions
    
    see alos wiki Scripts/Manual/ Tutorial/Motion Capture <br>
    
    Usage: <br>
     - Select the reference Object(s) you want to bake <br>
     - Set the frame range to bake in the Anim Panel <br>
     - Set the test code (if you want a self-test) in the RT field in the Anim Panel <br>
    	-- Set RT:1 to create a test armature <br>
    	-- Set RT: up to 100 for more debug messages and status updates <br>
    <br>
     - Run the script <br>
     - The clone copy of the object is created and it has an IPO curve assigned to it. <br>
     - The clone shadows the object by an offset locrot (see usrDelta) <br>
     - That Object has Ipo Location and Rotation curves that make the clone mimic the movement <br>
    	of the selected object, but without using constraints. <br>
     - If the object was an Armature, the clone's bones move identically in relation to the <br>
    	original armature, and an Action is created that drives the bone movements. <br>
    
    Version History:
    	0.1: bakes Loc Rot for a constrained object
    	0.2: bakes Loc and Rot for the bones within Armature object
    	0.3: UI for setting options
    	0.3.1 add manual to script library
    	0.4: bake múltiple objects
    	0.5: root bone worldspace rotation
    	0.6: re-integration with BPyArmature
    	0.7: bakes parents and leaves clones selected
     
    License, Copyright, and Attribution:
     by Roger WICKES May 2008, released under Blender Artistic Licence to Public Domain
     feel free to add to any Blender Python Scripts Bundle.
     Thanks to Jean-Baptiste PERIN, IdeasMan42 (Campbell Barton), Basil_Fawlty/Cage_drei (Andrew Cruse)
     much lifted/learned from blender.org/documentation/245PytonDoc and wiki
     some modules based on c3D_Import.py, PoseLib16.py and IPO/Armature code examples e.g. camera jitter
    
    Pseudocode:
    	Initialize
    	If at least one object is selected
    		For each selected object,
    			create a cloned object
    			remove any constraints on the clone
    			create or reset an ipo curve named like the object
    			for each frame
    				 set the clone's locrot key based on the reference object
    			if it's an armature,
    				create an action (which is an Ipo for each bone)
    				for each frame of the animation
    					for each bone in the armature
    						set the key
    	Else you're a smurf
    
    Test Conditions and Regressions:
    	1. (v0.1) Non-armatures (the cube), with ipo curve and constraints at the object level
    	2. armatures, with ipo curve and constraints at the object level
    	3. armatures, with bones that have ipo curves and constraints
    	4. objects without parents, children with unselected parents, select children first.
     
    Naming conventions:
    	arm = a specific objec type armature
    	bone = bones that make up the skeleton of an armature
    
    	ob = object, an instance of an object type
    	ebone = edit bone, a bone in edit mode
    	pbone = pose bone, a posed bone in an object
    	tst = testing, self-test routines
    	usr = user-entered or designated stuff 
    """
    ########################################
    
    import Blender
    from Blender import *
    from Blender.Mathutils import *
    import struct
    import string
    import bpy
    import BPyMessages
    import BPyArmature
    # reload(BPyArmature)
    from BPyArmature import getBakedPoseData
    
    Vector= Blender.Mathutils.Vector
    Euler= Blender.Mathutils.Euler
    Matrix= Blender.Mathutils.Matrix #invert() function at least
    RotationMatrix = Blender.Mathutils.RotationMatrix
    TranslationMatrix= Blender.Mathutils.TranslationMatrix
    Quaternion = Blender.Mathutils.Quaternion
    Vector = Blender.Mathutils.Vector
    POSE_XFORM= [Blender.Object.Pose.LOC, Blender.Object.Pose.ROT]
    
    #=================
    # Global Variables
    #=================
    
    # set senstitivity for displaying debug/console messages. 0=none, 100=max
    # then call debug(num,string) to conditionally display status/información in console window
    MODE=Blender.Get('rt') #execution mode: 0=run normal, 1=make test armature
    DEBUG=Blender.Get('rt') #how much detail on internal processing for user to see. range 0-100
    BATCH=False #called from command line? is someone there? Would you like some cake?
    
    #there are two coordinate systems, the real, or absolute 3D space,
    # and the local relative to a parent.
    COORDINATE_SYSTEMS = ['local','real']
    COORD_LOCAL = 0
    COORD_REAL = 1
    
    # User Settings - Change these options manually or via GUI (future TODO)
    usrCoord = COORD_REAL # what the user wants
    usrParent = False # True=clone keeps original parent, False = clone's parent is the clone of the original parent (if cloned)
    usrFreeze = 2 #2=yes, 0=no. Freezes shadow object in place at current frame as origin
    # delta is amount to offset/change from the reference object. future set in a ui, so technically not a constant
    usrDelta = [10,10,0,0,0,0] #order specific - Loc xyz Rot xyz
    usrACTION = True # Offset baked Action frames to start at frame 1
    
    CURFRAME = 'curframe' #keyword to use when getting the frame number that the scene is presently on
    ARMATURE = 'Armature' #en anglais
    BONE_SPACES = ['ARMATURESPACE','BONESPACE']
    		# 'ARMATURESPACE' - this matrix of the bone in relation to the armature
    		# 'BONESPACE' - the matrix of the bone in relation to itself
    
    #Ipo curves created are prefixed with a name, like Ipo_ or Bake_ followed by the object/bone name
    #bakedArmName = "b." #used for both the armature class and object instance
    usrObjectNamePrefix= ""
    #ipoBoneNamePrefix = ""
    # for example, if on entry an armature named Man was selected, and the object prefix was "a."
    # on exit an armature and an IPO curve named a.Man exists for the object as a whole
    # if that armature had bones (spine, neck, arm) and the bone prefix was "a."
    # the bones and IPO curves will be (a.spine, a.neck, a.arm)
    
    R2D = 18/3.1415 # radian to grad
    BLENDER_VERSION = Blender.Get('versión')
    
    # Gets the current scene, there can be many scenes in 1 blend file. 
    scn = Blender.Scene.GetCurrent()
    
    #=================
    # Methods
    #=================
    ########################################
    def debug(num,msg): #use log4j or just console here.
    	if DEBUG >= num:
    		if BATCH == False:
    			print 'debug: '[:num/10+7]+msg
    		#TODO: else write out to file (runs faster if it doesnt have to display details)
    	return
    
    ########################################
    def error(str):
    	debug(0,'ERROR: '+str)
    	if BATCH == False:
    		Draw.PupMenu('ERROR%t|'+str)
    	return
    
    ########################################
    def getRenderInfo():
    	context=scn.getRenderingContext() 
    	staframe = context.startFrame()
    	endframe = context.endFrame()
    	if endframe<staframe: endframe=staframe
    	curframe = Blender.Get(CURFRAME)
    	debug(90,'Scene is on frame %i and frame range is %i to %i' % (curframe,staframe,endframe))
    	return (staframe,endframe,curframe)
    
    ########################################
    def sortObjects(obs): #returns a list of objects sorted based on parent dependency
    	obClones= [] 
    	while len(obClones) < len(obs):
    		for ob in obs:
    			if not ob in obClones:
    				par= ob.getParent()
    				#if no parent, or the parent is not scheduled to be cloned
    				if par==None:
    					obClones.append(ob) # add the independent
    				elif par not in obs: # parent will not be cloned
    					obClones.append(ob) # add the child
    				elif par in obClones: # is it on the listí
    					obClones.append(ob) # add the child
    				# parent may be a child, so it will be caught next time thru
    	debug(100,'clone object order: \n%s' % obClones)
    	return obClones # ordered list of (ob, par) tuples
    
    ########################################
    def sortBones(xbones): #returns a sorted list of bones that should be added,sorted based on parent dependency
    # while there are bones to add,
    # look thru the list of bones we need to add
    # if we have not already added this bone
    # if it does not have a parent
    # add it
    # else, it has a parent
    # if we already added it's parent
    # add it now.
    # else #we need to keep cycling and catch its parent
    # else it is a root bone
    # add it
    # else skip it, it's already in there
    # endfor
    # endwhile
    	xboneNames=[]
    	for xbone in xbones: xboneNames.append(xbone.name)
    	debug (80,'reference bone order: \n%s' % xboneNames)
    	eboneNames=[]
    	while len(eboneNames) < len(xboneNames):
    		for xbone in xbones:
    			if not xbone.name in eboneNames:
    				if not xbone.parent:
    					eboneNames.append(xbone.name)
    				else:
    					if xbone.parent.name in eboneNames:
    						eboneNames.append(xbone.name)
    					#else skip it
    				#endif
    			#else prego
    		#endfor
    	#endwhile
    	debug (80,'clone bone order: \n%s' % eboneNames)
    	return eboneNames
    
    ########################################
    def dupliArmature(ob): #makes a copy in current scn of the armature used by ob and its bones
    	ob_mat = ob.matrixWorld
    	ob_data = ob.getData()
    	debug(49,'Reference object uses %s' % ob_data)
    	arm_ob = Armature.Get(ob_data.name) #the armature used by the passed object
    	
    	arm = Blender.Armature.New()
    	debug(20,'Cloning Armature %s to create %s' % (arm_ob.name, arm.name))
    	arm.drawType = Armature.STICK #set the draw type
    
    	arm.makeEditable() #enter editmode
    
    	# for each bone in the object's armature,
    	xbones=ob.data.bones.values()
    	usrSpace = 0 #0=armature, 1=local
    	space=[BONE_SPACES[usrSpace]][0] 
    
    	#we have to make a list of bones, then figure out our parents, then add to the arm
    	#when creating a child, we cannot link to a parent if it does not yet exist in our armature 
    	ebones = [] #list of the bones I want to create for my arm
    
    	eboneNames = sortBones(xbones)
    
    	i=0
    	# error('bones sorted. continue?')
    	for abone in eboneNames: #set all editable attributes to fully define the bone.
    		for bone in xbones: 
    			if bone.name == abone: breaque # get the reference bone
    		ebone = Armature.Editbone() #throw me a bone, bone-man!
    		ebones.append(ebone) #you're on my list, buddy
    
    		ebone.name = bone.name
    		ebone.headRadius = bone.headRadius
    		ebone.tailRadius = bone.tailRadius
    		ebone.weight = bone.weight
    		ebone.options = bone.options
    		
    		ebone.head = bone.head[space] #dictionary lookups
    		ebone.tail = bone.tail[space]
    		ebone.matrix = bone.matrix[space]
    		ebone.roll = bone.roll[space]
    
    		debug(30,'Generating new %s as child of %s' % (bone,bone.parent))
    		if bone.hasParent(): 
    # parent=bone.parent.name
    # debug(100,'looking for %s' % parent)
    # for parbone in xbones: if parbone.name == parent: breaque # get the parent bone
    # ebone.parent = arm.bones[ebones[j].name]
    			ebone.parent = arm.bones[bone.parent.name]
    # else:
    # ebone.parent = None
    		debug(30,'Generating new editbone %s as child of %s' % (ebone,ebone.parent))
    		arm.bones[ebone.name] = ebone # i would have expected an append or add function, but this works
    
    	debug (100,'arm.bones: \n%s' % arm.bones)
    	debug (20,'Cloned %i bones now in armature %s' %(len(arm.bones),arm.name)) 
    
    	myob = scn.objects.new(arm) #interestingly, object must be created before 
    	arm.update() #armature can be saved
    	debug(40,'dupArm finished %s instanced as object %s' % (arm.name,myob.getName()))
    	print ob.matrix
    	print myob.matrix
    	
    	return myob
    ########################################
    def scrub(): # scrubs to startframe
    	staFrame,endFrame,curFrame = getRenderInfo()
    
    	# eye-candy, go from current to start, fwd or back
    	if not BATCH:
    		debug(100, "Positioning to start...")
    		frameinc=(staFrame-curFrame)/10
    		if abs(frameinc) >= 1:
    			for i in range(10):
    				curFrame+=frameinc
    				Blender.Set(CURFRAME,curFrame) # computes the constrained location of the 'real' objects
    				Blender.Redraw()
    	Blender.Set(CURFRAME, staFrame)
    	return
    
    ########################################
    def bakeBones(ref_ob,arm_ob): #copy pose from ref_ob to arm_ob
    	scrub()
    	staFrame,endFrame,curFrame = getRenderInfo()
    	act = getBakedPoseData(ref_ob, staFrame, endFrame, ACTION_BAKE = True, ACTION_BAKE_FIRST_FRAME = usrACTION) # bake the pose positions of the reference ob to the armature ob
    	arm_ob.action = act
    	scrub() 
    	
    	# user comprehension feature - change action name and channel ipo names to match the names of the bone they drive
    	debug (80,'Renaming each action ipo to match the bone they pose')
    	act.name = arm_ob.name
    	arm_channels = act.getAllChannelIpos()
    	pose= arm_ob.getPose()
    	pbones= pose.bones.values() #we want the bones themselves, not the dictionary lookup
    	for pbone in pbones:
    		debug (100,'Channel listing for %s: %s' % (pbone.name,arm_channels[pbone.name] ))
    		ipo=arm_channels[pbone.name]
    		ipo.name = pbone.name # since bone names are unique within an armature, the pose names can be the same since they are within an Action
    
    	return
    
    ########################################
    def getOrCreateCurve(ipo, curvename):
    	"""
    	Retrieve or create a Blender Ipo Curve named C{curvename} in the C{ipo} Ipo
    	Either an ipo curve named C{curvename} exists before the call then this curve is returned,
    	Or such a curve doesn't exist before the call .. then it is created into the c{ipo} Ipo and returned 
    	"""
    	try:
    		mycurve = ipo.getCurve(curvename)
    		if mycurve != None:
    			pass
    		else:
    			mycurve = ipo.addCurve(curvename)
    	except:
    		mycurve = ipo.addCurve(curvename)
    	return mycurve
    
    ########################################
    def eraseCurve(ipo,numCurves):
    	debug(90,'Erasing %i curves for %' % (numCurves,ipo.GetName()))
    	for i in range(numCurves):
    		nbBezPoints= ipo.getNBezPoints(i)
    		for j in range(nbBezPoints):
    			ipo.delBezPoint(i)
    	return
    
    ########################################
    def resetIPO(ipo):
    	debug(60,'Resetting ipo curve named %s' %ipo.name)
    	numCurves = ipo.getNcurves() #like LocX, LocY, etc
    	if numCurves > 0:
    		eraseCurve(ipo, numCurves) #erase data if one exists
    	return
    
    ########################################
    def resetIPOs(ob): #resets all IPO curvess assocated with an object and its bones
    	debug(30,'Resetting any ipo curves linked to %s' %ob.getName())
    	ipo = ob.getIpo() #may be None
    	ipoName = ipo.getName() #name of the IPO that guides/controls this object
    	debug(70,'Object IPO is %s' %ipoName)
    	try:
    		ipo = Ipo.Get(ipoName)
    	except:
    		ipo = Ipo.New('Object', ipoName)
    	resetIPO(ipo)
    	if ob.getType() == ARMATURE:
    		arm_data=ob.getData()
    		bones=arm_data.bones.values()
    		for bone in bones:
    			#for each bone: get the name and chek for a Pose IPO
    			debug(10,'Processing '+ bone.name)
    	return
    
    ########################################
    def parse(string,delim):
    	index = string.find(delim) # -1 if not found, else pointer to delim
    	if index+1: return string[:index]
    	return string
    
    ########################################
    def newIpo(ipoName): #add a new Ipo object to the Blender scene
    	ipo=Blender.Ipo.New('Object',ipoName)
    
    	ipo.addCurve('LocX')
    	ipo.addCurve('LocY')
    	ipo.addCurve('LocZ')
    	ipo.addCurve('RotX')
    	ipo.addCurve('RotY')
    	ipo.addCurve('RotZ')
    	return ipo
    
    ########################################
    def makeUpaName(type,name): #i know this exists in Blender somewhere...
    	debug(90,'Maquíng up a new %s name using %s as a basis.' % (type,name))
    	name = (parse(name,'.'))
    	if type == 'Ipo':
    		ipoName = name # maybe we get lucky today
    		ext = 0
    		extlen = 3 # 3 digit extensions, like hello.002
    		success = False
    		while not(success):
    			try:
    				debug(100,'Trying %s' % ipoName)
    				ipo = Ipo.Get(ipoName)
    				#that one exists if we get here. add on extensión and keep trying
    				ext +=1
    				if ext>=10**extlen: extlen +=1 # go to more digits if 999 not found
    				ipoName = '%s.%s' % (name, str(ext).zfill(extlen))
    			except: # could not find it
    				success = True
    		name=ipoName 
    	else:
    		debug (0,'FATAL ERROR: I dont know how to make up a new %s name based on %s' % (type,ob))
    		return None
    	return name
    
    ########################################
    def createIpo(ob): #create an Ipo and curves and link them to this object
    	#first, we have to create a unique name
    	#try first with just the name of the object to keep things simple.
    	ipoName = makeUpaName('Ipo',ob.getName()) # make up a name for a new Ipo based on the object name
    	debug(20,'Ipo and LocRot curves called %s' % ipoName)
    	ipo=newIpo(ipoName)
    	ob.setIpo(ipo) #link them
    	return ipo
    
    ########################################
    def getLocLocal(ob):
    	key = [
    			ob.LocX, 
    			ob.LocY, 
    			ob.LocZ,
    			ob.RotX*R2D, #get the curves in this order
    			ob.RotY*R2D, 
    			ob.RotZ*R2D
    			]
    	return key
    
    ########################################
    def getLocReal(ob):
    	obMatrix = ob.matrixWorld #Thanque you IdeasMan42
    	loc = obMatrix.translationPart()
    	rot = obMatrix.toEuler()
    	key = [
    			loc.x,
    			loc.y,
    			loc.z,
    			rot.x/10,
    			rot.y/10,
    			rot.z/10
    			]
    	return key
    
    ########################################
    def getLocRot(ob,space):
    	if space in xrange(len(COORDINATE_SYSTEMS)):
    		if space == COORD_LOCAL:
    			key = getLocLocal(ob)
    			return key
    		elif space == COORD_REAL:
    			key = getLocReal(ob)
    			return key
    		else: #hey, programmers make mistakes too.
    			debug(0,'Fatal Error: getLoc called with %i' % space)
    	return
    
    ########################################
    def getCurves(ipo):
    	ipos = [
    			ipo[Ipo.OB_LOCX],
    			ipo[Ipo.OB_LOCY],
    			ipo[Ipo.OB_LOCZ],
    			ipo[Ipo.OB_ROTX], #get the curves in this order
    			ipo[Ipo.OB_ROTY],
    			ipo[Ipo.OB_ROTZ]
    			]
    	return ipos
    
    ########################################
    def addPoint(time,keyLocRot,ipos):
    	if BLENDER_VERSION < 245:
    		debug(0,'WARNING: addPoint uses BezTriple')
    	for i in range(len(ipos)):
    		point = BezTriple.New() #this was new with Blender 2.45 API
    		point.pt = (time, keyLocRot[i])
    		point.handleTypes = [1,1]
    
    		ipos[i].append(point)
    	return ipos
    
    ########################################
    def bakeFrames(ob,myipo): #bakes an object in a scene, returning the IPO containing the curves
    	myipoName = myipo.getName()
    	debug(20,'Baquíng frames for scene %s object %s to ipo %s' % (scn.getName(),ob.getName(),myipoName))
    	ipos = getCurves(myipo)
    	#TODO: Gui setup idea: myOffset
    	# reset action to start at frame 1 or at location
    	myOffset=0 #=1-staframe
    	#loop through frames in the animation. Often, there is rollup and the mocap starts late
    	staframe,endframe,curframe = getRenderInfo()
    	for frame in range(staframe, endframe+1):
    		debug(80,'Baquíng Frame %i' % frame)
    		#tell Blender to advace to frame
    		Blender.Set(CURFRAME,frame) # computes the constrained location of the 'real' objects
    		if not BATCH: Blender.Redraw() # no secrets, let user see what we are doing
    			
    		#using the constrained Loc Rot of the object, set the location of the unconstrained clone. Yea! Clones are FreeMen
    		key = getLocRot(ob,usrCoord) #a key is a set of specifed exact channel values (LocRotScale) for a certain frame
    		key = [a+b for a,b in zip(key, usrDelta)] #offset to the new location
    
    		myframe= frame+myOffset
    		Blender.Set(CURFRAME,myframe)
    		
    		time = Blender.Get('curtime') #for BezTriple
    		ipos = addPoint(time,key,ipos) #add this data at this time to the ipos
    		debug(100,'%s %i %.3f %.2f %.2f %.2f %.2f %.2f %.2f' % (myipoName, myframe, time, key[0], key[1], key[2], key[3], key[4], key[5]))
    	# eye-candy - smoothly rewind the animation, showing now how the clone match moves
    	if endframe-staframe <400 and not BATCH:
    		for frame in range (endframe,staframe,-1): #rewind
    			Blender.Set(CURFRAME,frame) # computes the constrained location of the 'real' objects
    			Blender.Redraw()
    	Blender.Set(CURFRAME,staframe)
    	Blender.Redraw()
    
    	return ipos
    
    ########################################
    def duplicateLinked(ob):
    	obType = ob.type
    	debug(10,'Duplicating %s Object named %s' % (obType,ob.getName()))
    	scn.objects.selected = [ob]
    ## rdw: simplified by just duplicating armature. kept code as reference for creating armatures
    ## disadvantage is that you cant have clone as stik and original as octahedron
    ## since they share the same Armature. User can clik Make Single User button. 
    ## if obType == ARMATURE: #build a copy from scratch
    ## myob= dupliArmature(ob)
    ## else:
    	Blender.Object.Duplicate() # Duplicate linked, including pose constraints.
    	myobs = Object.GetSelected() #duplicate is top on the list
    	myob = myobs[0]
    	if usrParent == False:
    		myob.clrParent(usrFreeze) 
    	debug(20,'=myob= was created as %s' % myob.getName())
    	return myob
    
    ########################################
    def removeConstraints(ob):
    	for const in ob.constraints:
    		debug(90,'removed %s => %s' % (ob.name, const))
    		ob.constraints.remove(const)
    	return
     
    ########################################
    def removeConstraintsOb(ob): # from object or armature
    	debug(40,'Removing constraints from '+ob.getName())
    	if BLENDER_VERSION > 241: #constraints module not available before 242
    		removeConstraints(ob)
    		if ob.getType() == ARMATURE:
    			pose = ob.getPose()
    			for pbone in pose.bones.values():
    				#bone = pose.bones[bonename]
    				removeConstraints(pbone)
    		#should alos chek if it is a deflector?
    	return
    
    ########################################
    def deLinkOb(type,ob): #remove linkages
    	if type == 'Ipo':
    		success = ob.clearIpo() #true=there was one
    		if success: debug(80,'deLinked Ipo curve to %s' % ob.getName())
    	return
    
    ########################################
    def bakeObject(ob): #bakes the core object locrot and assigns the Ipo to a Clone
    	if ob != None: 
    		# Clone the object - duplicate it, clean the clone, and create an ipo curve for the clone
    		myob = duplicateLinked(ob) #clone it
    		myob.setName(usrObjectNamePrefix + ob.getName())
    		removeConstraintsOb(myob) #my object is a free man
    		deLinkOb('Ipo',myob) #kids, it's not nice to share. you've been lied to
    		if ob.getType() != ARMATURE: # baquíng armatures is based on bones, not object
    			myipo = createIpo(myob) #create own IPO and curves for the clone object
    			ipos = bakeFrames(ob,myipo) #bake the locrot for this obj for the scene frames
    	return myob
     
    ########################################
    def bake(ob,par): #bakes an object of any type, linking it to parent
    	debug(0,'Baquíng %s object %s' % (ob.getType(), ob))
    	clone = bakeObject(ob) #creates and bakes the object motion
    	if par!= None:
    		par.makeParent([clone]) 
    		debug(20,"assigned object to parent %s" % par)
    	if ob.getType() == ARMATURE:
    ## error('Object baked. Continue with bones?')
    		bakeBones(ob,clone) #go into the bones and copy from -> to in frame range
    	#future idea: bakeMesh (net result of Shape Keys, Softbody, Cloth, Fluidsim,...)
    	return clone
     
    ########################################
    def tstCreateArm(): #create a test armature in scene
    	# rip-off from http://www.blender.org/documentation/245PythonDoc/Pose-module.html - thank you!
    
    	debug(0,'Maquíng Test Armature')
    	# New Armature
    	arm_data= Armature.New('myArmature')
    	print arm_data
    	arm_ob = scn.objects.new(arm_data)
    	arm_data.makeEditable()
    
    	# Add 4 bones
    	ebones = [Armature.Editbone(), Armature.Editbone(), Armature.Editbone(), Armature.Editbone()]
    
    	# Name the editbones
    	ebones[0].name = 'Bone.001'
    	ebones[1].name = 'Bone.002'
    	ebones[2].name = 'Bone.003'
    	ebones[3].name = 'Bone.004'
    
    	# Assign the editbones to the armature
    	for eb in ebones:
    		arm_data.bones[eb.name]= eb
    
    	# Set the locations of the bones
    	ebones[0].head= Mathutils.Vector(0,0,0)
    	ebones[0].tail= Mathutils.Vector(0,0,1) #tip
    	ebones[1].head= Mathutils.Vector(0,0,1)
    	ebones[1].tail= Mathutils.Vector(0,0,2)
    	ebones[2].head= Mathutils.Vector(0,0,2)
    	ebones[2].tail= Mathutils.Vector(0,0,3)
    	ebones[3].head= Mathutils.Vector(0,0,3)
    	ebones[3].tail= Mathutils.Vector(0,0,4)
    
    	ebones[1].parent= ebones[0]
    	ebones[2].parent= ebones[1]
    	ebones[3].parent= ebones[2]
    
    	arm_data.update()
    	# Done with editing the armature
    
    	# Assign the pose animation
    	arm_pose = arm_ob.getPose()
    
    	act = arm_ob.getAction()
    	if not act: # Add a pose action if we dont have one
    		act = Armature.NLA.NewAction()
    		act.setActive(arm_ob)
    
    	xbones=arm_ob.data.bones.values()
    	pbones = arm_pose.bones.values()
    
    	frame = 1
    	for pbone in pbones: # set bones to no rotation
    		pbone.quat[:] = 1.000,0.000,0.000,0.0000
    		pbone.insertKey(arm_ob, frame, Object.Pose.ROT)
    
    	# Set a different rotation at frame 25
    	pbones[0].quat[:] = 1.000,0.1000,0.2000,0.20000
    	pbones[1].quat[:] = 1.000,0.6000,0.5000,0.40000
    	pbones[2].quat[:] = 1.000,0.1000,0.3000,0.40000
    	pbones[3].quat[:] = 1.000,-0.2000,-0.3000,0.30000
    
    	frame = 25
    	for i in xrange(4):
    		pbones[i].insertKey(arm_ob, frame, Object.Pose.ROT)
    
    	pbones[0].quat[:] = 1.000,0.000,0.000,0.0000
    	pbones[1].quat[:] = 1.000,0.000,0.000,0.0000
    	pbones[2].quat[:] = 1.000,0.000,0.000,0.0000
    	pbones[3].quat[:] = 1.000,0.000,0.000,0.0000
    
    	frame = 50 
    	for pbone in pbones: # set bones to no rotation
    		pbone.quat[:] = 1.000,0.000,0.000,0.0000
    		pbone.insertKey(arm_ob, frame, Object.Pose.ROT)
    
    	return arm_ob
    
    ########################################
    def tstMoveOb(ob): # makes a simple LocRot animation of object in the scene
    	anim = [
    		#Loc Rot/10
    		#
    		( 0,0,0, 0, 0, 0), #frame 1 origin
    		( 1,0,0, 0, 0, 0), #frame 2
    		( 1,1,0, 0, 0, 0),
    		( 1,1,1, 0, 0, 0),
    		( 1,1,1,4.5, 0, 0),
    		( 1,1,1,4.5,4.5, 0),
    		( 1,1,1,4.5,4.5,4.5)
    		]
    	space = COORD_LOCAL
    	ipo = createIpo(ob) #create an Ipo and curves for this object
    	ipos = getCurves(ipo)
    	
    	# span this motion over the currently set anim range
    	# to set points, i need time but do not know how it is computed, so will have to advance the animation
    	staframe,endframe,curframe = getRenderInfo()
    
    	frame = staframe #x position of new ipo datapoint. set to staframe if you want a match
    	frameDelta=(endframe-staframe)/(len(anim)) #accomplish the animation in frame range
    	for key in anim: #effectively does a getLocRot()
    		#tell Blender to advace to frame
    		Blender.Set('curframe',frame) # computes the constrained location of the 'real' objects
    		time = Blender.Get('curtime')
    
    		ipos = addPoint(time,key,ipos) #add this data at this time to the ipos
    
    		debug(100,'%s %i %.3f %.2f %.2f %.2f %.2f %.2f %.2f' % (ipo.name, frame, time, key[0], key[1], key[2], key[3], key[4], key[5]))
    		frame += frameDelta
    	Blender.Set(CURFRAME,curframe) # reset bak to where we started
    	return
    #=================
    # Program Template
    #=================
    ########################################
    def main():
    	# return code set via rt button in Blender Buttons Scene Context Anim panel
    	if MODE == 1: #create test armature #1
    		ob = tstCreateArm() # make test arm and select it
    		tstMoveOb(ob)
    		scn.objects.selected = [ob]
    
    	obs= Blender.Object.GetSelected() #scn.objects.selected
    	obs= sortObjects(obs)
    	debug(0,'Baquíng %i objects' % len(obs))
    
    	if len(obs) >= 1: # user might have múltiple objects selected
    		i= 0
    		clones=[] # my clone army
    		for ob in obs:
    			par= ob.getParent()
    			if not usrParent:
    				if par in obs:
    					par= clones[obs.index(par)]
    			clones.append(bake(ob,par))
    		scn.objects.selected = clones
    	else:
    		error('Please select at least one object')
    	return
    
    ########################################
    def benchmark(): # This lets you benchmarque (time) the script's running duration 
    	Window.WaitCursor(1) 
    	t = sys.time() 
    	debug(60,'%s began at %.0f' %(__script__,sys.time()))
    
    	# Run the function on the active scene
    	in_editmode = Window.EditMode()
    	if in_editmode: Window.EditMode(0)
    
    	main() 
    
    	if in_editmode: Window.EditMode(1)
    	
    	# Timing the script is a good way to be aware on any speed hits when scripting 
    	debug(0,'%s Script finished in %.2f seconds' % (__script__,sys.time()-t) )
    	Window.WaitCursor(0) 
    	return
    
    ########################################
    # This lets you can import the script without running it 
    if __name__ == '__main__': 
    	debug(0, "------------------------------------")
    	debug(0, "%s %s Script begins with mode=%i debug=%i batch=%s" % (__script__,__versión__,MODE,DEBUG,BATCH))
    	benchmark()
    "Algún día todo será digital". Caronte.
    Mi web: NicoDigital.com

  14. #14
    Senior Member
    Fecha de ingreso
    Sep 2008
    Ubicación
    VALENCIA
    Mensajes
    186

    Re: Necesito un Script para bakear animación de bones manejados por constraints.

    Esto serviría? . Esta en Blender 2.56 ya que en 2.57 no me funciona bien el APPLY VISUAL TRANSFORM to POSE.
    aquí un archivo para que testees.

    prueba bake bones1.blend

    dale a run script y en el panel properties, en object, saldrá un botón que al presionar va guardando frame a frame, solo es pulsar como loco
    si funcionara...ya se mira de mejorar.Suerte
    espero que te sirva.
    Última edición por rulflink; 21-05-2011 a las 09:38
    si quieres ver algo mas...... www.rulflinks.blogspot.com

  15. #15
    BlenderAdicto Avatar de Caronte
    Fecha de ingreso
    Dec 2004
    Ubicación
    Valencia-España
    Mensajes
    14,691

    Re: Necesito un Script para bakear animación de bones manejados por constraints.

    Hola rulflink, gracias por tu ayuda
    He probado tu ejemplo, pero al menos a mí no me funciona O sea, pulos el botón para cada frame y veo como se crean los KeyFrames, pero después le quito el contraint al hueso y al pulsar Alt+A la animación resultante no se parece en nada a la original.
    "Algún día todo será digital". Caronte.
    Mi web: NicoDigital.com

Página 1 de 5 12345 ÚltimoÚltimo

Temas similares

  1. Blender Onion Sking para animacion generica por nodos y script
    Por Pistolario en el foro Animación y Rigging
    Respuestas: 1
    Último mensaje: 07-06-2011, 22:32
  2. Blender Existe en Blender 2 5x alguna forma de bakear animacion
    Por Caronte en el foro Animación y Rigging
    Respuestas: 8
    Último mensaje: 01-12-2010, 22:28
  3. ayuda Necesito Script para Max 9
    Por CriticalError en el foro Programación y Scripts
    Respuestas: 0
    Último mensaje: 01-03-2010, 00:45
  4. ayudas y sugerencias para animacion con bones
    Por Eaglon en el foro Animación y Rigging
    Respuestas: 1
    Último mensaje: 01-05-2009, 07:38
  5. Respuestas: 0
    Último mensaje: 11-08-2007, 03:04

Actualmente estos son sus permisos de publicación en el foro.

  • -No puedes crear nuevos temas al no estar registrado o no haber iniciado sesión en el foro.
  • -No puedes responder temas al no estar registrado o no haber iniciado sesión en el foro.
  • -No puedes subir archivos adjuntos al no estar registrado o no haber iniciado sesión en el foro.
  • -No puedes editar tus mensajes al no estar registrado o no haber iniciado sesión en el foro.
  •