KX_ArmatureSensor.cpp

Go to the documentation of this file.

/*
 * Armature sensor
 *
 * $Id: KX_ArmatureSensor.cpp 35171 2011-02-25 13:35:59Z 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 *****
 */

#include "DNA_action_types.h"
#include "DNA_constraint_types.h"
#include "BKE_constraint.h"
#include "DNA_sensor_types.h"

#include "BL_ArmatureObject.h"
#include "KX_ArmatureSensor.h"
#include "SCA_EventManager.h"
#include "SCA_LogicManager.h"

KX_ArmatureSensor::KX_ArmatureSensor(class SCA_EventManager* eventmgr,
                                        SCA_IObject* gameobj,
                                        const char *posechannel,
                                        const char *constraintname,
                                        int type,
                                        float value)
        : SCA_ISensor(gameobj,eventmgr),
        m_constraint(NULL),
        m_posechannel(posechannel),
        m_constraintname(constraintname),
        m_type(type),
        m_value(value)
{
        FindConstraint();
}

void KX_ArmatureSensor::Init()
{
        m_lastresult = m_invert?true:false;
        m_result = false;
        m_reset = true;
}

void KX_ArmatureSensor::FindConstraint()
{
        m_constraint = NULL;

        if (m_gameobj->GetGameObjectType() == SCA_IObject::OBJ_ARMATURE) {
                BL_ArmatureObject* armobj = (BL_ArmatureObject*)m_gameobj;
                // get the persistent pose structure
                bPose* pose = armobj->GetOrigPose();
                bPoseChannel* pchan;
                bConstraint* pcon;
                // and locate the constraint
                for (pchan = (bPoseChannel*)pose->chanbase.first; pchan; pchan=(bPoseChannel*)pchan->next) {
                        if (!strcmp(pchan->name, m_posechannel)) {
                                // now locate the constraint
                                for (pcon = (bConstraint*)pchan->constraints.first; pcon; pcon=(bConstraint*)pcon->next) {
                                        if (!strcmp(pcon->name, m_constraintname)) {
                                                if (pcon->flag & CONSTRAINT_DISABLE)
                                                        /* this constraint is not valid, can't use it */
                                                        break;
                                                m_constraint = pcon;
                                                break;  
                                        }
                                }
                                break;
                        }
                }
        }
}


CValue* KX_ArmatureSensor::GetReplica()
{
        KX_ArmatureSensor* replica = new KX_ArmatureSensor(*this);
        // m_range_expr must be recalculated on replica!
        replica->ProcessReplica();
        return replica;
}

void KX_ArmatureSensor::ReParent(SCA_IObject* parent)
{
        SCA_ISensor::ReParent(parent);
        // must remap the constraint
        FindConstraint();
}

bool KX_ArmatureSensor::IsPositiveTrigger()
{
        return (m_invert) ? !m_result : m_result;
}


KX_ArmatureSensor::~KX_ArmatureSensor()
{
}

bool KX_ArmatureSensor::Evaluate()
{
        bool reset = m_reset && m_level;

        m_reset = false;
        if (!m_constraint)
                return false;
        switch (m_type) {
        case SENS_ARM_STATE_CHANGED:
                m_result = !(m_constraint->flag & CONSTRAINT_OFF);
                break;
        case SENS_ARM_LIN_ERROR_BELOW:
                m_result = (m_constraint->lin_error < m_value);
                break;
        case SENS_ARM_LIN_ERROR_ABOVE:
                m_result = (m_constraint->lin_error > m_value);
                break;
        case SENS_ARM_ROT_ERROR_BELOW:
                m_result = (m_constraint->rot_error < m_value);
                break;
        case SENS_ARM_ROT_ERROR_ABOVE:
                m_result = (m_constraint->rot_error > m_value);
                break;
        }
        if (m_lastresult!=m_result)
        {
                m_lastresult = m_result;
                return true;
        }
        return (reset) ? true : false;
}

#ifdef WITH_PYTHON

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

/* Integration hooks ------------------------------------------------------- */
PyTypeObject KX_ArmatureSensor::Type = {
        PyVarObject_HEAD_INIT(NULL, 0)
        "KX_ArmatureSensor",
        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_ISensor::Type,
        0,0,0,0,0,0,
        py_base_new
};

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

PyAttributeDef KX_ArmatureSensor::Attributes[] = {
        KX_PYATTRIBUTE_RO_FUNCTION("constraint", KX_ArmatureSensor, pyattr_get_constraint),
        KX_PYATTRIBUTE_FLOAT_RW("value",-FLT_MAX,FLT_MAX,KX_ArmatureSensor,m_value),
        KX_PYATTRIBUTE_INT_RW("type",0,SENS_ARM_MAXTYPE,false,KX_ArmatureSensor,m_type),
        { NULL }        //Sentinel
};

PyObject* KX_ArmatureSensor::pyattr_get_constraint(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef)
{
        KX_ArmatureSensor* sensor = static_cast<KX_ArmatureSensor*>(self);
        if (sensor->m_gameobj->GetGameObjectType() == SCA_IObject::OBJ_ARMATURE) {
                BL_ArmatureObject* armobj = (BL_ArmatureObject*)sensor->m_gameobj;
                BL_ArmatureConstraint* constraint = armobj->GetConstraint(sensor->m_posechannel, sensor->m_constraintname);
                if (constraint) 
                        return constraint->GetProxy();
        }
        Py_RETURN_NONE;
}

#endif // WITH_PYTHON