Ton Roosendaal
35d6c6e695
- FORWARD CYCLING & MATCHING Up to no now, adding multiple actions in NLA with walkcycles required to animate them standing still, as if walking on a conveyor belt. The stride option then makes the object itself move forward, trying to keep the foot stuck on the floor (with poor results!). This option now allows to make walk cycles moving forward. By indicating a reference Offset Bone, the NLA system will use that bone to detect the correct offset for the Armature Pose to make it seamlessly going forward. Best of all, this option works as for cyclic Action Strips as well as for individual Action Strips. Note that for individual strips, you have to set the strip on "Hold". (Might become automatic detected later). Here's an example edit image for NLA: http://www.blender.org/bf/nla_match-cycle.jpg And the animation for it: http://download.blender.org/demo/test/2.43/0001_0150_match.avi Blender file: http://download.blender.org/demo/test/2.43/mancandy_matching.blend Using this kind of cycling works pretty straightforward, and is a lot easier to setup than Stride Bones. To be further tested: - Blending cycles - matching rotation for the bones as well. - ACTION MODIFIERS (motion deformors) The above option was actually required for this feature. Typically walk cycles are constructed with certain Bones to be the handles, controlling for example the torso or feet. An Action Modifier allows you to use a Curve Path to deform the motion of these controlling bones. This uses the existing Curve Deformation option. Modifiers can be added per Action Strip, each controlling a channel (bone) by choice, and even allows to layer multiple modifiers on top of each other (several paths deforming motion). This option is using the dependency graph, so editing the Curve will give realtime changes in the Armature. The previous walkcycle, controlled by two curves: http://download.blender.org/demo/test/2.43/0001_0150_deform.avi Blender file: http://download.blender.org/demo/test/2.43/mancandy_actiondeform.blend Action Modifiers can be added in the NLA Properties Panel. Per Modifier you have to indicate the channel and a Curve Object. You can copy modifiers from one strip to another using CTRL+C (only copies to active Object strips). Setting up a correct Curve Path has to be carefully done: - Use SHIFT+A "Curve Path" in top view, or ensure the path is not rotated. - make sure the center point of the Curve Object is at the center of the Armature (or above) - move the first point of the curve to the center point as well. - check if the path starts from this first point, you can change it using (in Curve EditMode) the option Wkey -> "Switch Direction" - Make sure alignment uses the correct axis; if the Armature walks into the negative Y direction, you have to set in Object Buttons, "Anim settings" Panel, the correct Track option. (Note; option will probably move to the Modifier later). This is a good reason to make such paths automatic (on a command). Is on the todo list. Also note this: - the Curve Path extends in beginning and ending, that's (for now) the default, and allows to use multiple paths. Make sure paths begin and end horizontal. - Moving the Curve in Object Mode will change the "mapping" (as if the landscape a character walks over moves). Moving the Curve in Edit Mode will change the actual position of the deformation. - Speed (Ipos) on paths is not supported yet, will be done. - The Curve "Stretch" deform option doesn't work. - Modifiers are executed *after* all actions in NLA are evaluated, there's no support yet for blending multiple strips with Modifiers. - This doesn't work yet for time-mapping... This commit is mostly for review by character animators... some details or working methods might change. This feature can also be used for other modifiers, such as noise (Perlin) or the mythical "Oomph" (frequency control) and of course Python. Special thanks to Bassam & Matt for research & design help. Have fun!
188 lines
4.4 KiB
C
188 lines
4.4 KiB
C
/**
|
|
* $Id$
|
|
*
|
|
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version. The Blender
|
|
* Foundation also sells licenses for use in proprietary software under
|
|
* the Blender License. See http://www.blender.org/BL/ for information
|
|
* about this.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*
|
|
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
|
* All rights reserved.
|
|
*
|
|
* The Original Code is: all of this file.
|
|
*
|
|
* Contributor(s): none yet.
|
|
*
|
|
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include "MEM_guardedalloc.h"
|
|
|
|
#include "BLI_blenlib.h"
|
|
|
|
#include "DNA_space_types.h"
|
|
#include "DNA_nla_types.h"
|
|
#include "DNA_action_types.h"
|
|
#include "DNA_ID.h"
|
|
#include "DNA_ipo_types.h"
|
|
#include "DNA_object_types.h"
|
|
|
|
#include "BKE_nla.h"
|
|
#include "BKE_action.h"
|
|
#include "BKE_blender.h"
|
|
#include "BKE_library.h"
|
|
#include "BKE_object.h" /* for convert_action_to_strip(ob) */
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
|
|
/* NOTE: in group.c the strips get copied for group-nla override, this assumes
|
|
that strips are one single block, without additional data to be copied */
|
|
|
|
void copy_actionstrip (bActionStrip **dst, bActionStrip **src){
|
|
bActionStrip *dstrip;
|
|
bActionStrip *sstrip = *src;
|
|
|
|
if (!*src){
|
|
*dst=NULL;
|
|
return;
|
|
}
|
|
|
|
*dst = MEM_dupallocN(sstrip);
|
|
|
|
dstrip = *dst;
|
|
if (dstrip->act)
|
|
dstrip->act->id.us++;
|
|
|
|
if (dstrip->ipo)
|
|
dstrip->ipo->id.us++;
|
|
|
|
if (dstrip->modifiers.first) {
|
|
duplicatelist (&dstrip->modifiers, &sstrip->modifiers);
|
|
}
|
|
|
|
}
|
|
|
|
void copy_nlastrips (ListBase *dst, ListBase *src)
|
|
{
|
|
bActionStrip *strip;
|
|
|
|
dst->first=dst->last=NULL;
|
|
|
|
duplicatelist (dst, src);
|
|
|
|
/* Update specific data */
|
|
if (!dst->first)
|
|
return;
|
|
|
|
for (strip = dst->first; strip; strip=strip->next){
|
|
if (strip->act)
|
|
strip->act->id.us++;
|
|
if (strip->ipo)
|
|
strip->ipo->id.us++;
|
|
if (strip->modifiers.first) {
|
|
ListBase listb;
|
|
duplicatelist (&listb, &strip->modifiers);
|
|
strip->modifiers= listb;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* from editnla, for convert_action_to_strip -- no UI code so should be ok here.. */
|
|
void find_stridechannel(Object *ob, bActionStrip *strip)
|
|
{
|
|
if(ob && ob->pose) {
|
|
bPoseChannel *pchan;
|
|
for(pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next)
|
|
if(pchan->flag & POSE_STRIDE)
|
|
break;
|
|
if(pchan)
|
|
BLI_strncpy(strip->stridechannel, pchan->name, 32);
|
|
else
|
|
strip->stridechannel[0]= 0;
|
|
}
|
|
}
|
|
|
|
//called by convert_nla / bpy api with an object with the action to be converted to a new strip
|
|
bActionStrip *convert_action_to_strip (Object *ob)
|
|
{
|
|
bActionStrip *nstrip;
|
|
|
|
/* Make new actionstrip */
|
|
nstrip = MEM_callocN(sizeof(bActionStrip), "bActionStrip");
|
|
|
|
/* Link the action to the nstrip */
|
|
nstrip->act = ob->action;
|
|
id_us_plus(&nstrip->act->id);
|
|
calc_action_range(nstrip->act, &nstrip->actstart, &nstrip->actend, 1);
|
|
nstrip->start = nstrip->actstart;
|
|
nstrip->end = nstrip->actend;
|
|
nstrip->flag = ACTSTRIP_SELECT|ACTSTRIP_LOCK_ACTION;
|
|
|
|
find_stridechannel(ob, nstrip);
|
|
//set_active_strip(ob, nstrip); /* is in editnla as does UI calls */
|
|
|
|
nstrip->repeat = 1.0;
|
|
|
|
BLI_addtail(&ob->nlastrips, nstrip);
|
|
return nstrip; /* is created, malloced etc. here so is safe to just return the pointer?
|
|
this is needed for setting this active in UI, and probably useful for API too */
|
|
|
|
}
|
|
|
|
|
|
/* not strip itself! */
|
|
void free_actionstrip(bActionStrip* strip)
|
|
{
|
|
if (!strip)
|
|
return;
|
|
|
|
if (strip->act){
|
|
strip->act->id.us--;
|
|
strip->act = NULL;
|
|
}
|
|
if (strip->ipo){
|
|
strip->ipo->id.us--;
|
|
strip->ipo = NULL;
|
|
}
|
|
if (strip->modifiers.first) {
|
|
BLI_freelistN(&strip->modifiers);
|
|
}
|
|
|
|
}
|
|
|
|
void free_nlastrips (ListBase *nlalist)
|
|
{
|
|
bActionStrip *strip;
|
|
|
|
if (!nlalist->first)
|
|
return;
|
|
|
|
/* Do any specific freeing */
|
|
for (strip=nlalist->first; strip; strip=strip->next)
|
|
{
|
|
free_actionstrip (strip);
|
|
};
|
|
|
|
/* Free the whole list */
|
|
BLI_freelistN(nlalist);
|
|
}
|