KIN/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.
 *
 * Produced by:
 *      ramin
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        KIN_Bone.h ( Kinematics Library, C++)
 *
 * COMMENTS:
 *              class for storing bone specification
 */

#ifndef __KIN_Bone__
#define __KIN_Bone__

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

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

    float                getRotate( int axis ) const    { return myRot[axis]; }
    void                 getRotates( float *r ) const
                         { memcpy( r, myRot, sizeof(myRot) ); }
    const UT_Matrix4    &getExtraXform() const  { return myExtraXform; }
    
    float                getLength()  const     { return myLength; }
    float                getDampening() const   { return myDampening; }
    const void          *getData() const        { return myData; }
    float                constrain(int axis, float angle, float step) const
                         { return myConstraint.constrain(axis, angle, step); }
    
    void                 setRotate( int axis, float r )
                         { myRot[axis] = r; }
    void                 setRotates( const float *r )
                         { memcpy( myRot, r, sizeof(myRot) ); }
    void                 setExtraXform(const UT_Matrix4 &xform)
                         { myExtraXform = xform; }
    
    void                 setLength( float l )   { myLength = l; }
    void                 setDampening( float d ){ myDampening = d; }
    void                 setData( const void *d ){ myData = d; }
    void                 setConstraint( float rest[3], float xrange[2],
                                float yrange[2], float zrange[2],
                                float damp[3], float roll[3] )
                         {
                             myConstraint.setConstraint(rest, xrange, yrange,
                                                        zrange, damp, roll);
                         }

    void                 operator=(const KIN_Bone &src)
                         {
                             memcpy( myRot, src.myRot, sizeof(myRot) );
                             myLength = src.myLength;
                             myDampening = src.myDampening;
                             myExtraXform = src.myExtraXform;
                             myData = src.myData;
                             myConstraint = src.myConstraint;
                         }

private:
    float                        myRot[3];
    float                        myLength;
    float                        myDampening;
    UT_Matrix4                   myExtraXform;
    const void                  *myData;
    KIN_AngleConstraint          myConstraint;
};

#endif

---