BL_ShapeActionActuator.cpp

Go to the documentation of this file.

/*
* $Id: BL_ShapeActionActuator.cpp 35167 2011-02-25 13:30:41Z jesterking $
*
 * ***** BEGIN GPL 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.
 *
 * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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 LICENSE BLOCK *****
*/

#if defined (__sgi)
#include <math.h>
#else
#include <cmath>
#endif

#include "SCA_LogicManager.h"
#include "BL_ShapeActionActuator.h"
#include "BL_ShapeDeformer.h"
#include "KX_GameObject.h"
#include "STR_HashedString.h"
#include "DNA_nla_types.h"
#include "DNA_action_types.h"
#include "DNA_anim_types.h"
#include "DNA_scene_types.h"
#include "BKE_action.h"
#include "DNA_armature_types.h"
#include "MEM_guardedalloc.h"
#include "BLI_blenlib.h"
#include "BLI_math.h"
#include "MT_Matrix4x4.h"

#include "FloatValue.h"
#include "PyObjectPlus.h"

extern "C" {
        #include "BKE_animsys.h"
}

BL_ShapeActionActuator::~BL_ShapeActionActuator()
{
}

void BL_ShapeActionActuator::ProcessReplica()
{
        SCA_IActuator::ProcessReplica();
        m_localtime=m_startframe;
        m_lastUpdate=-1;
}

void BL_ShapeActionActuator::SetBlendTime (float newtime)
{
        m_blendframe = newtime;
}

CValue* BL_ShapeActionActuator::GetReplica() 
{
        BL_ShapeActionActuator* replica = new BL_ShapeActionActuator(*this);//m_float,GetName());
        replica->ProcessReplica();
        return replica;
}

bool BL_ShapeActionActuator::ClampLocalTime()
{
        if (m_startframe < m_endframe)  {
                if (m_localtime < m_startframe)
                {
                        m_localtime = m_startframe;
                        return true;
                } 
                else if (m_localtime > m_endframe)
                {
                        m_localtime = m_endframe;
                        return true;
                }
        } else {
                if (m_localtime > m_startframe)
                {
                        m_localtime = m_startframe;
                        return true;
                }
                else if (m_localtime < m_endframe)
                {
                        m_localtime = m_endframe;
                        return true;
                }
        }
        return false;
}

void BL_ShapeActionActuator::SetStartTime(float curtime)
{
        float direction = m_startframe < m_endframe ? 1.0 : -1.0;
        
        if (!(m_flag & ACT_FLAG_REVERSE))
                m_starttime = curtime - direction*(m_localtime - m_startframe)/KX_KetsjiEngine::GetAnimFrameRate();
        else
                m_starttime = curtime - direction*(m_endframe - m_localtime)/KX_KetsjiEngine::GetAnimFrameRate();
}

void BL_ShapeActionActuator::SetLocalTime(float curtime)
{
        float delta_time = (curtime - m_starttime)*KX_KetsjiEngine::GetAnimFrameRate();
        
        if (m_endframe < m_startframe)
                delta_time = -delta_time;

        if (!(m_flag & ACT_FLAG_REVERSE))
                m_localtime = m_startframe + delta_time;
        else
                m_localtime = m_endframe - delta_time;
}

void BL_ShapeActionActuator::BlendShape(Key* key, float srcweight)
{
        vector<float>::const_iterator it;
        float dstweight;
        KeyBlock *kb;
        
        dstweight = 1.0F - srcweight;

        for (it=m_blendshape.begin(), kb = (KeyBlock*)key->block.first; 
                 kb && it != m_blendshape.end(); 
                 kb = (KeyBlock*)kb->next, it++) {
                kb->curval = kb->curval * dstweight + (*it) * srcweight;
        }
}

bool BL_ShapeActionActuator::Update(double curtime, bool frame)
{
        bool bNegativeEvent = false;
        bool bPositiveEvent = false;
        bool keepgoing = true;
        bool wrap = false;
        bool apply=true;
        int     priority;
        float newweight;

        curtime -= KX_KetsjiEngine::GetSuspendedDelta();
        
        // result = true if animation has to be continued, false if animation stops
        // maybe there are events for us in the queue !
        if (frame)
        {
                bNegativeEvent = m_negevent;
                bPositiveEvent = m_posevent;
                RemoveAllEvents();
                
                if (bPositiveEvent)
                        m_flag |= ACT_FLAG_ACTIVE;
                
                if (bNegativeEvent)
                {
                        if (!(m_flag & ACT_FLAG_ACTIVE))
                                return false;
                        m_flag &= ~ACT_FLAG_ACTIVE;
                }
        }
        
        /*      This action can only be attached to a deform object */
        BL_DeformableGameObject *obj = (BL_DeformableGameObject*)GetParent();
        float length = m_endframe - m_startframe;
        
        priority = m_priority;
        
        /* Determine pre-incrementation behaviour and set appropriate flags */
        switch (m_playtype){
        case ACT_ACTION_MOTION:
                if (bNegativeEvent){
                        keepgoing=false;
                        apply=false;
                };
                break;
        case ACT_ACTION_FROM_PROP:
                if (bNegativeEvent){
                        apply=false;
                        keepgoing=false;
                }
                break;
        case ACT_ACTION_LOOP_END:
                if (bPositiveEvent){
                        if (!(m_flag & ACT_FLAG_LOCKINPUT)){
                                m_flag &= ~ACT_FLAG_KEYUP;
                                m_flag &= ~ACT_FLAG_REVERSE;
                                m_flag |= ACT_FLAG_LOCKINPUT;
                                m_localtime = m_startframe;
                                m_starttime = curtime;
                        }
                }
                if (bNegativeEvent){
                        m_flag |= ACT_FLAG_KEYUP;
                }
                break;
        case ACT_ACTION_LOOP_STOP:
                if (bPositiveEvent){
                        if (!(m_flag & ACT_FLAG_LOCKINPUT)){
                                m_flag &= ~ACT_FLAG_REVERSE;
                                m_flag &= ~ACT_FLAG_KEYUP;
                                m_flag |= ACT_FLAG_LOCKINPUT;
                                SetStartTime(curtime);
                        }
                }
                if (bNegativeEvent){
                        m_flag |= ACT_FLAG_KEYUP;
                        m_flag &= ~ACT_FLAG_LOCKINPUT;
                        keepgoing=false;
                        apply=false;
                }
                break;
        case ACT_ACTION_PINGPONG:
                if (bPositiveEvent){
                        if (!(m_flag & ACT_FLAG_LOCKINPUT)){
                                m_flag &= ~ACT_FLAG_KEYUP;
                                m_localtime = m_starttime;
                                m_starttime = curtime;
                                m_flag |= ACT_FLAG_LOCKINPUT;
                        }
                }
                break;
        case ACT_ACTION_FLIPPER:
                if (bPositiveEvent){
                        if (!(m_flag & ACT_FLAG_LOCKINPUT)){
                                m_flag &= ~ACT_FLAG_REVERSE;
                                m_flag |= ACT_FLAG_LOCKINPUT;
                                SetStartTime(curtime);
                        }
                }
                else if (bNegativeEvent){
                        m_flag |= ACT_FLAG_REVERSE;
                        m_flag &= ~ACT_FLAG_LOCKINPUT;
                        SetStartTime(curtime);
                }
                break;
        case ACT_ACTION_PLAY:
                if (bPositiveEvent){
                        if (!(m_flag & ACT_FLAG_LOCKINPUT)){
                                m_flag &= ~ACT_FLAG_REVERSE;
                                m_localtime = m_starttime;
                                m_starttime = curtime;
                                m_flag |= ACT_FLAG_LOCKINPUT;
                        }
                }
                break;
        default:
                break;
        }
        
        /* Perform increment */
        if (keepgoing){
                if (m_playtype == ACT_ACTION_MOTION){
                        MT_Point3       newpos;
                        MT_Point3       deltapos;
                        
                        newpos = obj->NodeGetWorldPosition();
                        
                        /* Find displacement */
                        deltapos = newpos-m_lastpos;
                        m_localtime += (length/m_stridelength) * deltapos.length();
                        m_lastpos = newpos;
                }
                else{
                        SetLocalTime(curtime);
                }
        }
        
        /* Check if a wrapping response is needed */
        if (length){
                if (m_localtime < m_startframe || m_localtime > m_endframe)
                {
                        m_localtime = m_startframe + fmod(m_localtime, length);
                        wrap = true;
                }
        }
        else
                m_localtime = m_startframe;
        
        /* Perform post-increment tasks */
        switch (m_playtype){
        case ACT_ACTION_FROM_PROP:
                {
                        CValue* propval = GetParent()->GetProperty(m_propname);
                        if (propval)
                                m_localtime = propval->GetNumber();
                        
                        if (bNegativeEvent){
                                keepgoing=false;
                        }
                }
                break;
        case ACT_ACTION_MOTION:
                break;
        case ACT_ACTION_LOOP_STOP:
                break;
        case ACT_ACTION_PINGPONG:
                if (wrap){
                        if (!(m_flag & ACT_FLAG_REVERSE))
                                m_localtime = m_endframe;
                        else 
                                m_localtime = m_startframe;

                        m_flag &= ~ACT_FLAG_LOCKINPUT;
                        m_flag ^= ACT_FLAG_REVERSE; //flip direction
                        keepgoing = false;
                }
                break;
        case ACT_ACTION_FLIPPER:
                if (wrap){
                        if (!(m_flag & ACT_FLAG_REVERSE)){
                                m_localtime=m_endframe;
                                //keepgoing = false;
                        }
                        else {
                                m_localtime=m_startframe;
                                keepgoing = false;
                        }
                }
                break;
        case ACT_ACTION_LOOP_END:
                if (wrap){
                        if (m_flag & ACT_FLAG_KEYUP){
                                keepgoing = false;
                                m_localtime = m_endframe;
                                m_flag &= ~ACT_FLAG_LOCKINPUT;
                        }
                        SetStartTime(curtime);
                }
                break;
        case ACT_ACTION_PLAY:
                if (wrap){
                        m_localtime = m_endframe;
                        keepgoing = false;
                        m_flag &= ~ACT_FLAG_LOCKINPUT;
                }
                break;
        default:
                keepgoing = false;
                break;
        }
        
        /* Set the property if its defined */
        if (m_framepropname[0] != '\0') {
                CValue* propowner = GetParent();
                CValue* oldprop = propowner->GetProperty(m_framepropname);
                CValue* newval = new CFloatValue(m_localtime);
                if (oldprop) {
                        oldprop->SetValue(newval);
                } else {
                        propowner->SetProperty(m_framepropname, newval);
                }
                newval->Release();
        }
        
        if (bNegativeEvent)
                m_blendframe=0.0f;
        
        /* Apply the pose if necessary*/
        if (apply) {

                /* Priority test */
                if (obj->SetActiveAction(this, priority, curtime)){
                        Key *key = obj->GetKey();

                        if (!key) {
                                // this could happen if the mesh was changed in the middle of an action
                                // and the new mesh has no key, stop the action
                                keepgoing = false;
                        }
                        else {
                                ListBase tchanbase= {NULL, NULL};
                        
                                if (m_blendin && m_blendframe==0.0f){
                                        // this is the start of the blending, remember the startup shape
                                        obj->GetShape(m_blendshape);
                                        m_blendstart = curtime;
                                }
                                // only interested in shape channel

                                // in 2.4x was // extract_ipochannels_from_action(&tchanbase, &key->id, m_action, "Shape", m_localtime);
                                BKE_animsys_evaluate_animdata(&key->id, key->adt, m_localtime, ADT_RECALC_ANIM);

                                // XXX - in 2.5 theres no way to do this. possibly not that important to support - Campbell
                                if (0) { // XXX !execute_ipochannels(&tchanbase)) {
                                        // no update, this is possible if action does not match the keys, stop the action
                                        keepgoing = false;
                                } 
                                else {
                                        // the key have changed, apply blending if needed
                                        if (m_blendin && (m_blendframe<m_blendin)){
                                                newweight = (m_blendframe/(float)m_blendin);

                                                BlendShape(key, 1.0f - newweight);

                                                /* Increment current blending percentage */
                                                m_blendframe = (curtime - m_blendstart)*KX_KetsjiEngine::GetAnimFrameRate();
                                                if (m_blendframe>m_blendin)
                                                        m_blendframe = m_blendin;
                                        }
                                        m_lastUpdate = m_localtime;
                                }
                                BLI_freelistN(&tchanbase);
                        }
                }
                else{
                        m_blendframe = 0.0f;
                }
        }
        
        if (!keepgoing){
                m_blendframe = 0.0f;
        }
        return keepgoing;
};

#ifdef WITH_PYTHON

/* ------------------------------------------------------------------------- */
/* Python functions                                                          */
/* ------------------------------------------------------------------------- */

/* Integration hooks ------------------------------------------------------- */

PyTypeObject BL_ShapeActionActuator::Type = {
        PyVarObject_HEAD_INIT(NULL, 0)
        "BL_ShapeActionActuator",
        sizeof(PyObjectPlus_Proxy),
        0,
        py_base_dealloc,
        0,
        0,
        0,
        0,
        py_base_repr,
        0,0,0,0,0,0,0,0,0,
        Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
        0,0,0,0,0,0,0,
        Methods,
        0,
        0,
        &SCA_IActuator::Type,
        0,0,0,0,0,0,
        py_base_new
};


PyMethodDef BL_ShapeActionActuator::Methods[] = {
        {NULL,NULL} //Sentinel
};

PyAttributeDef BL_ShapeActionActuator::Attributes[] = {
        KX_PYATTRIBUTE_FLOAT_RW("frameStart", 0, MAXFRAMEF, BL_ShapeActionActuator, m_startframe),
        KX_PYATTRIBUTE_FLOAT_RW("frameEnd", 0, MAXFRAMEF, BL_ShapeActionActuator, m_endframe),
        KX_PYATTRIBUTE_FLOAT_RW("blendIn", 0, MAXFRAMEF, BL_ShapeActionActuator, m_blendin),
        KX_PYATTRIBUTE_RW_FUNCTION("action", BL_ShapeActionActuator, pyattr_get_action, pyattr_set_action),
        KX_PYATTRIBUTE_SHORT_RW("priority", 0, 100, false, BL_ShapeActionActuator, m_priority),
        KX_PYATTRIBUTE_FLOAT_RW_CHECK("frame", 0, MAXFRAMEF, BL_ShapeActionActuator, m_localtime, CheckFrame),
        KX_PYATTRIBUTE_STRING_RW("propName", 0, 31, false, BL_ShapeActionActuator, m_propname),
        KX_PYATTRIBUTE_STRING_RW("framePropName", 0, 31, false, BL_ShapeActionActuator, m_framepropname),
        KX_PYATTRIBUTE_FLOAT_RW_CHECK("blendTime", 0, MAXFRAMEF, BL_ShapeActionActuator, m_blendframe, CheckBlendTime),
        KX_PYATTRIBUTE_SHORT_RW_CHECK("mode",0,100,false,BL_ShapeActionActuator,m_playtype,CheckType),
        { NULL }        //Sentinel
};

PyObject* BL_ShapeActionActuator::pyattr_get_action(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
{
        BL_ShapeActionActuator* self= static_cast<BL_ShapeActionActuator*>(self_v);
        return PyUnicode_FromString(self->GetAction() ? self->GetAction()->id.name+2 : "");
}

int BL_ShapeActionActuator::pyattr_set_action(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
{
        BL_ShapeActionActuator* self= static_cast<BL_ShapeActionActuator*>(self_v);
        /* exact copy of BL_ActionActuator's function from here down */
        if (!PyUnicode_Check(value))
        {
                PyErr_SetString(PyExc_ValueError, "actuator.action = val: Shape Action Actuator, expected the string name of the action");
                return PY_SET_ATTR_FAIL;
        }

        bAction *action= NULL;
        STR_String val = _PyUnicode_AsString(value);
        
        if (val != "")
        {
                action= (bAction*)SCA_ILogicBrick::m_sCurrentLogicManager->GetActionByName(val);
                if (action==NULL)
                {
                        PyErr_SetString(PyExc_ValueError, "actuator.action = val: Shape Action Actuator, action not found!");
                        return PY_SET_ATTR_FAIL;
                }
        }
        
        self->SetAction(action);
        return PY_SET_ATTR_SUCCESS;

}

#endif // WITH_PYTHON