KIN_Bone.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.
 *
 * NAME:        KIN_Bone.h ( Kinematics Library, C++)
 *
 * COMMENTS:
 *              class for storing bone specification
 */

#ifndef __KIN_Bone__
#define __KIN_Bone__

#include "KIN_API.h"
#include "KIN_AngleConstraint.h"
#include <UT/UT_Matrix4.h>
#include <SYS/SYS_Types.h>
#include <string.h>

class KIN_API KIN_Bone
{
public:
                         KIN_Bone()
                         {
                             myRot[0] = myRot[1] = myRot[2] = 0.0;
                             myRad[0] = myRad[1] = myRad[2] = 0.0;
                             myLength = 0.0;
                             myDampening = 0.0;
                             myExtraXform.identity();
                             myData = 0;
                             myDirtyRadians = true;
                         }

                         ~KIN_Bone()
                         {
                         }

    fpreal               getRotate( int axis ) const    { return myRot[axis]; }
    void                 getRotates( fpreal *r ) const
                         { memcpy( r, myRot, sizeof(myRot) ); }


    fpreal               getRadians( int axis ) const
                         {
                            if( myDirtyRadians )
                            {
                                myRad[0] = SYSdegToRad(myRot[0]);
                                myRad[1] = SYSdegToRad(myRot[1]);
                                myRad[2] = SYSdegToRad(myRot[2]);
                                myDirtyRadians = false;
                            }
                            return myRad[axis];
                         }

    void                 getRadians( fpreal *r ) const
                         {
                            if( myDirtyRadians )
                            {
                                myRad[0] = SYSdegToRad(myRot[0]);
                                myRad[1] = SYSdegToRad(myRot[1]);
                                myRad[2] = SYSdegToRad(myRot[2]);
                                myDirtyRadians = false;
                            }
                            memcpy( r, myRad, sizeof(myRad) );
                         }

    const UT_Matrix4R   &getExtraXform() const  { return myExtraXform; }
    
    fpreal               getLength()  const     { return myLength; }
    fpreal               getDampening() const   { return myDampening; }
    const void          *getData() const        { return myData; }
    fpreal               constrain(int axis, fpreal angle, fpreal step) const
                         { return myConstraint.constrain(axis, angle, step); }
    
    void                 setRotate( int axis, fpreal r )
                         { myRot[axis] = r; myDirtyRadians = true; }
    void                 setRotates( const fpreal *r )
                         {
                            memcpy( myRot, r, sizeof(myRot) );
                            myDirtyRadians = true;
                         }
    void                 setRotates( const fpreal *deg, const fpreal *rad)
                         {
                            memcpy( myRot, deg, sizeof(myRot) );
                            memcpy( myRad, rad, sizeof(myRad) );
                            myDirtyRadians = false;
                         }

    void                 setExtraXform(const UT_Matrix4R &xform)
                         { myExtraXform = xform; }
    
    void                 setLength( fpreal l )  { myLength = l; }
    void                 setDampening( fpreal d ){ myDampening = d; }
    void                 setData( const void *d ){ myData = d; }
    void                 setConstraint( fpreal rest[3], fpreal xrange[2],
                                fpreal yrange[2], fpreal zrange[2],
                                fpreal damp[3], fpreal roll[3] )
                         {
                             myConstraint.setConstraint(rest, xrange, yrange,
                                                        zrange, damp, roll);
                         }

    // The Curve Solver can output rotation matrices directly without conversion.
    // This isn't used by the other solvers, as they are solving in rotation space.
    const UT_Matrix3R   &getRotateMatrix() const
                         { return myRotMat; }
    void                 setRotateMatrix( const UT_Matrix3R &m)
                         {
                            myRotMat = m;
                         }

    int64                getMemoryUsage(bool inclusive) const
                         {
                             return inclusive ? sizeof(*this) : 0;
                         }

private:
    fpreal                       myRot[3];
    UT_Matrix3R                  myRotMat;
    fpreal                       myLength;
    fpreal                       myDampening;
    UT_Matrix4R                  myExtraXform;
    const void                  *myData;
    KIN_AngleConstraint          myConstraint;

    mutable fpreal               myRad[3];
    mutable bool                 myDirtyRadians;
};

#endif