KIN/KIN_Chain.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      ramin
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        KIN_Chain.h ( Kinematics Library, C++)
 *
 * COMMENTS:
 *              This class holds the specification of a kinematic
 *              chain. The chain is specified as a string of the
 *              form: "length rx ry rz, ..., length rx ry rz;"
 */

#ifndef __KIN_Chain__
#define __KIN_Chain__

#include "KIN_API.h"
#include <UT/UT_PtrArray.h>
#include <UT/UT_Matrix4.h>
#include <UT/UT_Vector3.h>
#include <UT/UT_Vector3Array.h>
#include <UT/UT_XformOrder.h>

class KIN_Bone;
class KIN_Solver;

typedef enum {
    CHAIN_NUMBER_OF_BONES = 0,
    BONE_LENGTH,
    BONE_DAMPENING,
    BONE_ROTATE,
    BONE_DATA
} KIN_ChangeType;

class KIN_API KIN_CurveParm
{
public:
    bool                                 myClosedFlag;
    bool                                 myOrientToNormalsFlag;
    UT_Vector3                           myTangent;
    UT_Vector3Array                      myPoints;
    UT_Vector3Array                      myNormals;
};

class KIN_API KIN_SpineParm : public KIN_CurveParm
{
public:
    float                                myTolerance; // tolerance on solution
};

class KIN_API KIN_IKSolverParm
{
public:
    UT_Vector3                           myEndAffectorPos;      
    UT_Vector3                           myTwistAffectorPos;
    int                                  myTwistAffectorFlag;
    float                                myTwist;       
    float                                myDampen;      
};

class KIN_API KIN_ConstraintParm : public KIN_IKSolverParm
{
public:
    float                                myTolerance; // tolerance on solution
};

class KIN_API KIN_InverseParm : public KIN_IKSolverParm
{
public:
    KIN_InverseParm()
    {
        myResistStraight = true;
        myTrackingThresholdFactor = 1e-03f;
    }

    float                                myTrackingThresholdFactor;
    int                                  myResistStraight;
};

class KIN_API KIN_Chain
{
public:

                         KIN_Chain();
                         KIN_Chain(const KIN_Chain &copy_from);
                        ~KIN_Chain();

    static const UT_XformOrder &getXformOrder() { return myXformOrder; }

    // These functions are for getting and setting bone information.
    // All access to a chains bones must go through the chain so that we
    // can make sure our solver is up to date. The separate updateBone,
    // setBoneRotate, and setBoneRotates functions are only provided
    // for convenience. Also notice that the Chain creator no longer
    // has to actually create or remove any bones from the chain,
    // only to set the number of bones.
    int                  getNbones() const;
    void                 setNbones(int bones);
    const KIN_Bone      *getBone(int index) const;
    void                 updateBone(int index, float length, float *rot,
                                    float damp, const UT_Matrix4 &xform,
                                    const void *data);
    void                 setBoneRotate(int index, int axis, float r);
    void                 setBoneRotates(int index, float *r);

    // Currently we are limited to one constraint per bone, so the
    // interface to the bone constraints can be very simple. Any constraint
    // that gets passed in here will be deleted by the bone.
    void                 setConstraint( int index, float rest[3],
                                        float xrange[2], float yrange[2],
                                        float zrange[2], float damp[3],
                                        float roll[3] );
    float                constrain( int index, int axis,
                                    float angle, float step ) const;

    // Utility functions for getting transform information for each bone
    // or for just the chain end position.
    void                 getEndPosition(UT_Vector3 &result) const;
    void                 getBoneStates(UT_Matrix4 *xforms) const;
    float                getLength() const;

    // Functions for setting solver information for the chain
    int                  solve(const char *type, const void *parms,
                               KIN_Chain &solution);

    // Essentially a copy operator
    void                 copyFrom(const KIN_Chain &src);
    void                 copySubChain(const KIN_Chain &src, int from, int to);

private:
    void                 deleteBones();
    void                 initializeSolver();
    void                 chainChanged(KIN_ChangeType type);

    UT_PtrArray<KIN_Bone *>                      myBones;
    KIN_Solver                                  *mySolver;
    char                                        *mySolverType;
    const void                                  *mySolverParms;
    static const UT_XformOrder                   myXformOrder;
};

#endif

---