OBJ/OBJ_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:        OBJ_Bone.h ( Object Library, C++)
 *
 * COMMENTS:
 *              Object that implements bones
 */

#ifndef __OBJ_Bone__
#define __OBJ_Bone__

#include "OBJ_API.h"
class UT_String;
class UT_DMatrix4;
class SOP_CaptureRegion;

#include <UT/UT_XformOrder.h>
#include <UT/UT_PtrArray.h>
#include "OBJ_Geometry.h"

#define BONESTATE_CHOPNET "KIN_Chops"

// NOTE: IF YOU ADD ANYTHING HERE, YOU MUST UPDATE
//       THE switcher[] INSIDE OBJ_Bone.C
enum OBJ_BoneIndex
{
    // Bone
    I_LINK = I_N_GEO_INDICES,
    I_REST_ANGLE,
    I_LENGTH,
    I_SOLVER,
    I_DAMPEN,
    I_XRANGE,
    I_XDAMP,
    I_XROLLOFF,
    I_YRANGE,
    I_YDAMP,
    I_YROLLOFF,
    I_ZRANGE,
    I_ZDAMP,
    I_ZROLLOFF,

    // Capture
    I_CAPTURE,

    // Capture-Deform SOPs
    I_CRSWITCHER,
    I_CCRCENTER,
    I_CCRROTATE,
    I_CCRSCALE,
    I_CCRTOPHEIGHT,
    I_CCRTOPCAP,
    I_CCRBOTHEIGHT,
    I_CCRBOTCAP,
    I_CRCENTER,
    I_CRROTATE,
    I_CRSCALE,
    I_CRTOPHEIGHT,
    I_CRTOPCAP,
    I_CRBOTHEIGHT,
    I_CRBOTCAP,
    // Capture Bone Pose Xform (translate, rotate, scale)
    I_LABEL_1,
    I_CAPTPOSE_LENGTH,
    I_CAPTPOSE_T,
    I_CAPTPOSE_R,
    I_CAPTPOSE_S,
    
    I_N_BONE_INDICES            // should always be last in the list
};

#define EVAL_FLOAT(name, idx, vi, t)    \
                return evalFloat(name, &getIndirect()[idx], vi, t);
#define EVAL_FLOATS(name, idx, v, t)    \
                evalFloats(name, &getIndirect()[idx], v, t);
#define EVAL_INT(name, idx, vi, t)      \
                return evalInt(name, &getIndirect()[idx], vi, t);
#define EVAL_STR(name, idx, vi, t)      \
                evalString(str, name, &getIndirect()[idx], vi, (float)t);

#define SET_FLOAT(name, parm_index, vector_index, t, val) \
            setFloat(name, getIndirect()[parm_index], vector_index, t, val)
#define SET_FLOATREF(name, vector_index, t, val) \
            setChRefFloat(getParmList()->getParmIndex(name), vector_index, t, val)
#define SET_INT(name, parm_index, vector_index, t, val) \
            setInt(name, getIndirect()[parm_index], vector_index, t, val)
#define SET_STRING(val, meaning, name, parm_index, vector_index, t) \
            setString(val, meaning, name, getIndirect()[parm_index], \
                      vector_index, t)

class SOP_Node;
class CHOP_Node;

class OBJ_API OBJ_Bone : public OBJ_Geometry
{
public:
    static UT_XformOrder         XFORM_ORDER;
    enum KinOverride {
        KIN_OVERRIDE_NONE,
        KIN_OVERRIDE_REST,
        KIN_OVERRIDE_CAPTURE,
        NUM_KIN_OVERRIDES
    };

                                 OBJ_Bone(OP_Network *, const char *,
                                          OP_Operator *);
    virtual                      ~OBJ_Bone();

    virtual unsigned             disableParms();

    virtual int                  isObjectRenderable() const;
    void                         setIsObjectRenderable(bool val);

#if 0
    virtual void                 stashCaptureAngles(float t);
#endif

    virtual void                 getNodeSpecificInfoText(
                                                OP_Context &context,
                                                int verbose,
                                                UT_WorkBuffer &text);

    CHOP_Node *                  getKinChop();
    void                         cleanBoneTransform( OP_Context &context );

    SOP_Node *                   getBoneSOP() const;

    virtual void        getParmTransform(OP_Context &context,
                                          UT_DMatrix4 &xform);
    virtual void        getParmTransformRotates(OP_Context &context,
                                            UT_DMatrix4 &xform );
    virtual void        getParmTransformTranslates(OP_Context &context,
                                            UT_DMatrix4 &xform );
    virtual void        getParmTransformScales(OP_Context &context,
                                            UT_DMatrix4 &xform );
    
    // capture transform relative to "to" node (float and double versions)
    virtual int         getRelativeCaptureTransform( OP_Node &to,
                                                     UT_Matrix4 &xform,
                                                     OP_Context &context );
    virtual int         getRelativeCaptureTransform( OP_Node &to,
                                                     UT_DMatrix4 &xform,
                                                     OP_Context &context );

    // get the transform such that bone is transformed to capture position
    // NB: this is a local to world transform (but for the capture pose)
    virtual void        getCaptureParmTransform( OP_Context &context,
                                                 UT_DMatrix4 &mat );
    // sets the capture trs parameters so that they represent the given xform
    // NB: this is a local to world transform (but for the capture pose)
    virtual void        setCaptureParmTransform( OP_Context &context, 
                                                 const UT_DMatrix4& xform );
    // next two methods obtain local to world transform of the animation
    // bone pose (independently of the current override: that is
    // they return what getLocalToWorldTransform would in the OVERRIDE_NONE)
    void                getAnimLocalToWorldTransform( OP_Context &context,
                                                      UT_DMatrix4 &mat );
    void                getAnimInverseLocalToWorldTransform(OP_Context &context,
                                                            UT_DMatrix4 &mat );


    // set the given world position by only modifying the pre-transform
    virtual int         keepWorldTransform( 
                                    OP_Context &context, 
                                    const UT_DMatrix4 &world_xform );

    // obtains the transformation from the reference frame associated with
    // the rest position, to the world
    int                 getChildToWorldRestTransform(const char *frame, 
                                    UT_DMatrix4 &xform, float t)
                        {
                            return getCustomChildToWorldTransform( frame, t,
                                                                    xform);
                        }   
    bool                getObjectToChainParentTransform( 
                                                OBJ_Bone *start_bone,
                                                UT_DMatrix4 &xform, float t );
            
    // methods to set the bone-specific parm values

    void                 setUseSolver( int onoff )
                             { myUseSolverFlag = onoff ? 1 : 0; }
    int                  getUseSolver() const
                             { return myUseSolverFlag; }
    int                  isUsingSolver() const
                             { return myIsUsingSolverFlag; }

    // sets the capture parameters for the bone.
    // Capture parameters "freeze" the current parameters by storing them
    // (or accumulation of them) in the capture parameters. The capture
    // parameters are used for capturing geometry by bone's capture regions.
    // They are also used for displaying the capture pose when
    // kinematic override is set to "CAPTURE"
    void                 setCaptureParameters(OP_Context &context,
                                              UT_String &errors);

    // sets the capture parameters so that bone capture position
    // is the same as the animation position. Also aligns the
    // capture and deform pills (ie capture and animate regions) of each
    // capture region contained by the bone.
    // NB: both bone and capture region capture parameters are changed
    //     to aligh capture region to deform region.
    void                 alignRegionCaptureWithDeform(OP_Context &context,
                                                      UT_String &errors);

    // adjust the cregions within the bone so that their animation
    // region is aligned with capture region in the world space (through
    // the use of the SOP rig adjustment xform)
    // NB: only rig adjustment paramters are changed to aligh animation
    //     (deform) region with capture region. Bone parameters do not
    //     change at all.
    void                 alignRegionDeformWithCapture(OP_Context &context,
                                                      UT_String &errors);
    
    // set the parameters
    void                 setLinkDisplay(int onOff)
                             { SET_INT("displaylink", I_LINK, 0, 0, onOff); }
    void                 setLength(float t, float v)
                             { SET_FLOAT("length", I_LENGTH, 0, t, v); }
    void                 setRestX(float t, float v)
                             { SET_FLOAT("R", I_REST_ANGLE, 0, t, v); }
    void                 setRestY(float t, float v)
                             { SET_FLOAT("R", I_REST_ANGLE, 1, t, v); }
    void                 setRestZ(float t, float v)
                             { SET_FLOAT("R", I_REST_ANGLE, 2, t, v); }

    void                 setSOLVER( const char *solver,
                                    CH_StringMeaning meaning )
                             {SET_STRING(solver, meaning, "solver",
                                         I_SOLVER, 0, 0.0f);}

    void                 setXMIN(float t, float v)
                             { SET_FLOAT("xrange", I_XRANGE, 0, t, v); }
    void                 setXMAX(float t, float v)
                             { SET_FLOAT("xrange", I_XRANGE, 1, t, v); }
    void                 setYMIN(float t, float v)
                             { SET_FLOAT("yrange", I_YRANGE, 0, t, v); }
    void                 setYMAX(float t, float v)
                             { SET_FLOAT("yrange", I_YRANGE, 1, t, v); }
    void                 setZMIN(float t, float v)
                             { SET_FLOAT("zrange", I_ZRANGE, 0, t, v); }
    void                 setZMAX(float t, float v)
                             { SET_FLOAT("zrange", I_ZRANGE, 1, t, v); }

    // 0 is skeleton SOP type, 1 is Capture/Deform type
    void                 setCaptureDisplay(int onOff)
                         { SET_INT("displaycapture", I_CAPTURE, 0, 0, onOff); }

#if 0   // no longer used
    void                 setPos1(float t, float v)
                             { SET_FLOAT("ellipse1tz",  I_ELLIPSE1P, 0, t, v); }
    void                 setRad1X(float t, float v)
                             { SET_FLOAT("ellipse1rad", I_ELLIPSE1R, 0, t, v); }
    void                 setRad1Y(float t, float v)
                             { SET_FLOAT("ellipse1rad", I_ELLIPSE1R, 1, t, v); }
    void                 setPos2(float t, float v)
                             { SET_FLOAT("ellipse2tz",  I_ELLIPSE2P, 0, t, v); }
    void                 setRad2X(float t, float v)
                             { SET_FLOAT("ellipse2rad", I_ELLIPSE2R, 0, t, v); }
    void                 setRad2Y(float t, float v)
                             { SET_FLOAT("ellipse2rad", I_ELLIPSE2R, 1, t, v); }
    void                 setJointDivs(float t, int v)
                             { SET_INT("jointdivs",     I_JOINT_DIVS,0, t, v);}
#endif
    void                 setCRcenter(float t, float x, float y, float z)
                             { SET_FLOAT("crcenter",    I_CRCENTER,  0, t, x);
                               SET_FLOAT("crcenter",    I_CRCENTER,  1, t, y); 
                               SET_FLOAT("crcenter",    I_CRCENTER,  2, t, z); 
                             }
    void                 setCRotate(float t, float x, float y, float z)
                             { SET_FLOAT("crrotate",    I_CRROTATE,  0, t, x);
                               SET_FLOAT("crrotate",    I_CRROTATE,  1, t, y); 
                               SET_FLOAT("crrotate",    I_CRROTATE,  2, t, z); 
                             }
    void                 setCRscale(float t, float x, float y, float z)
                             { SET_FLOAT("crscale",     I_CRSCALE,  0, t, x);
                               SET_FLOAT("crscale",     I_CRSCALE,  1, t, y);
                               SET_FLOAT("crscale",     I_CRSCALE,  2, t, z);
                             }
    void                 setCRtopHeight(float t, float v)
                             { SET_FLOAT("crtopheight", I_CRTOPHEIGHT,0,t, v); }
    void                 setCRtopCap(float t, float x, float y, float z)
                             { SET_FLOAT("crtopcap",    I_CRTOPCAP,  0, t, x);
                               SET_FLOAT("crtopcap",    I_CRTOPCAP,  1, t, y); 
                               SET_FLOAT("crtopcap",    I_CRTOPCAP,  2, t, z); 
                             }
    void                 setCRbotHeight(float t, float v)
                             { SET_FLOAT("crbotheight", I_CRBOTHEIGHT,0,t, v); }
    void                 setCRbotCap(float t, float x, float y, float z)
                             { SET_FLOAT("crbotcap",    I_CRBOTCAP,  0, t, x);
                               SET_FLOAT("crbotcap",    I_CRBOTCAP,  1, t, y); 
                               SET_FLOAT("crbotcap",    I_CRBOTCAP,  2, t, z); 
                             }

    // the three following methods change the capture length capture pose
    // of the bone, and propagate the change to the descentent bones,
    // chaning their capture pose (as if they were "parented" to this bone)
    void                 setCaptLengthAndTranslateDescendents( float t, 
                                                               float length );
    void                 setCaptTransformAndDescendents( float t,
                                                    const UT_DMatrix4 &xform );
    virtual void         applyToCaptTransformAndDescendents( 
                                                    OP_Context &context,
                                                    const UT_DMatrix4 &xform);
            
    // set the capture parameters
    void                 setCaptPoseBoneLength( float t, float l )
                             { SET_FLOATREF("captposelen", 0, t, l);
                             }
    void                 setCaptPoseT(float t, float x, float y, float z)
                             { SET_FLOATREF("captposet", 0, t, x);
                               SET_FLOATREF("captposet", 1, t, y);
                               SET_FLOATREF("captposet", 2, t, z);
                             }
    void                 setCaptPoseR(float t, float x, float y, float z)
                             { SET_FLOATREF("captposer", 0, t, x);
                               SET_FLOATREF("captposer", 1, t, y);
                               SET_FLOATREF("captposer", 2, t, z);
                             }
    void                 setCaptPoseS(float t, float x, float y, float z)
                             { SET_FLOATREF("captposes", 0, t, x);
                               SET_FLOATREF("captposes", 1, t, y);
                               SET_FLOATREF("captposes", 2, t, z);
                             }

    // depending on the kinematic override mode get/set either the current
    // or capture bone length
    float                getOverrideDependentBoneLength( float t );
    void                 setOverrideDependentBoneLength( float t, float l );

#if 0
    void                 setCaptAngleX(float t, float v)
                             { SET_FLOAT("CA", I_CAPTURE_ANGLE, 0, t, v); }
    void                 setCaptAngleY(float t, float v)
                             { SET_FLOAT("CA", I_CAPTURE_ANGLE, 1, t, v); }
    void                 setCaptAngleZ(float t, float v)
                             { SET_FLOAT("CA", I_CAPTURE_ANGLE, 2, t, v); }
#endif

    // methods to retrieve the bone-specific parm values

    int   DISPLAYLINK()         { EVAL_INT("displaylink",    I_LINK, 0, 0) }
    float BONELENGTH(float t)   { EVAL_FLOAT("length",     I_LENGTH, 0, t) }
    void  SOLVER(UT_String &str){ EVAL_STR("solver", I_SOLVER, 0, 0) }
    CH_StringMeaning SOLVERmeaning()
                                { return getStringMeaning("solver", 0, 0.0f); }
    void  REST(float *v, float t) { EVAL_FLOATS("R",      I_REST_ANGLE, v, t) }
    float IKDAMPENING(float t)  { EVAL_FLOAT("ikdamp",         I_DAMPEN, 0, t) }
    float XMIN(float t)         { EVAL_FLOAT("xrange",  I_XRANGE, 0, t) }
    float XMAX(float t)         { EVAL_FLOAT("xrange",  I_XRANGE, 1, t) }
    float XDAMP(float t)        { EVAL_FLOAT("xdamp",   I_XDAMP, 0, t) }
    float XROLLOFF(float t)     { EVAL_FLOAT("xrolloff",I_XROLLOFF, 0, t) }
    float YMIN(float t)         { EVAL_FLOAT("yrange",  I_YRANGE, 0, t) }
    float YMAX(float t)         { EVAL_FLOAT("yrange",  I_YRANGE, 1, t) }
    float YDAMP(float t)        { EVAL_FLOAT("ydamp",   I_YDAMP, 0, t) }
    float YROLLOFF(float t)     { EVAL_FLOAT("yrolloff",I_YROLLOFF, 0, t) }
    float ZMIN(float t)         { EVAL_FLOAT("zrange",  I_ZRANGE, 0, t) }
    float ZMAX(float t)         { EVAL_FLOAT("zrange",  I_ZRANGE, 1, t) }
    float ZDAMP(float t)        { EVAL_FLOAT("zdamp",   I_ZDAMP, 0, t) }
    float ZROLLOFF(float t)     { EVAL_FLOAT("zrolloff",I_ZROLLOFF, 0, t) }
    int   CAPTURE()             { EVAL_INT  ("displaycapture",I_CAPTURE, 0, 0) }
#if 0
    float POS1(float t)         { EVAL_FLOAT("ellipse1tz",  I_ELLIPSE1P, 0, t) }
    float RAD1X(float t)        { EVAL_FLOAT("ellipse1rad", I_ELLIPSE1R, 0, t) }
    float RAD1Y(float t)        { EVAL_FLOAT("ellipse1rad", I_ELLIPSE1R, 1, t) }
    float POS2(float t)         { EVAL_FLOAT("ellipse2tz",  I_ELLIPSE2P, 0, t) }
    float RAD2X(float t)        { EVAL_FLOAT("ellipse2rad", I_ELLIPSE2R, 0, t) }
    float RAD2Y(float t)        { EVAL_FLOAT("ellipse2rad", I_ELLIPSE2R, 1, t) }
    int   JOINTDIVS(float t)    { EVAL_INT  ("jointdivs", I_JOINT_DIVS, 0, t) }
    float JOINTSCALE(float t)   { EVAL_FLOAT("joints", I_JOINT_SCALE, 0, t) }
    float CAPT_ANGLEX(float t)  { EVAL_FLOAT("CA",     I_CAPTURE_ANGLE, 0, t) }
    float CAPT_ANGLEY(float t)  { EVAL_FLOAT("CA",     I_CAPTURE_ANGLE, 1, t) }
    float CAPT_ANGLEZ(float t)  { EVAL_FLOAT("CA",     I_CAPTURE_ANGLE, 2, t) }
#endif

    float CRCEN(float t, int i) { EVAL_FLOAT("crcenter",I_CRCENTER, i,t); }
    float CRROTATE(float t, int i){ EVAL_FLOAT("crrotate",I_CRROTATE, i,t);}
    float CRSCALE(float t, int i){ EVAL_FLOAT("crscale",I_CRSCALE, i,t);}
    float CRTOPH(float t)       { EVAL_FLOAT("crtopheight", I_CRTOPHEIGHT,0,t);}
    float CRTOPC(float t, int i){ EVAL_FLOAT("crtopcap",I_CRTOPCAP, i,t);}
    float CRBOTH(float t)       { EVAL_FLOAT("crbotheight", I_CRBOTHEIGHT,0,t);}
    float CRBOTC(float t, int i){ EVAL_FLOAT("crbotcap",I_CRBOTCAP, i,t);}
    

    float getCaptPoseBoneLength(float t)
                            { EVAL_FLOAT("captposelen",I_CAPTPOSE_LENGTH,0,t); }
    float getCaptPoseTx(float t){ EVAL_FLOAT("captposet",I_CAPTPOSE_T, 0, t);}
    float getCaptPoseTy(float t){ EVAL_FLOAT("captposet",I_CAPTPOSE_T, 1, t);}
    float getCaptPoseTz(float t){ EVAL_FLOAT("captposet",I_CAPTPOSE_T, 2, t);}
    float getCaptPoseRx(float t){ EVAL_FLOAT("captposer",I_CAPTPOSE_R, 0, t);}
    float getCaptPoseRy(float t){ EVAL_FLOAT("captposer",I_CAPTPOSE_R, 1, t);}
    float getCaptPoseRz(float t){ EVAL_FLOAT("captposer",I_CAPTPOSE_R, 2, t);}
    float getCaptPoseSx(float t){ EVAL_FLOAT("captposes",I_CAPTPOSE_S, 0, t);}
    float getCaptPoseSy(float t){ EVAL_FLOAT("captposes",I_CAPTPOSE_S, 1, t);}
    float getCaptPoseSz(float t){ EVAL_FLOAT("captposes",I_CAPTPOSE_S, 2, t);}
        
    static OP_Node      *myConstructor(OP_Network *net,
                                        const char *name, OP_Operator *entry);

    // sets the kinematic override and if the mode is changed and recook_bones
    // is true, then the all bones are forced to recook
    // NB: if bones are not forced to cook, they may return invalid
    //     world transform since it is cached and only recomputed at cook time
    static void          setGlobalKinOverride( KinOverride val, 
                                               bool recook_bones = true );
    static KinOverride   getGlobalKinOverride() { return theGlobalKinOverride; }

    // traverses all existing bones and invoke function on each of them
    // If function returns nonzero the traversal continues, otherwise it stops.
    // The void pointer is passed to the call of the function.
    typedef int (*OBJ_BoneCallbackFunction)( const OBJ_Bone *, void *);

    static void          traverseAllBones( OBJ_BoneCallbackFunction fnct,
                                           void *data );
    
    static const char          **getReferenceFrames()
                                 { return theReferenceFrames; }
    static const char          **getReferenceFrameNames()
                                 { return theReferenceFrameNames; }
    int                          getRestPosition(const char *frame,
                                                 UT_Vector3 &pos,
                                                 float t);
    int                          setRestPosition(const char *frame,
                                                 UT_Vector3 &pos,
                                                 float t);

    enum FrameType { FRAME_INVALID = -1, FRAME_WORLD = 0, FRAME_PARENT };
    int                          getPosition( FrameType frame_type,
                                                 UT_Vector3 &pos,
                                                 float t);
    int                          getPosition(const char *frame,
                                                 UT_Vector3 &pos,
                                                 float t);
    int                          setPosition(const char *frame,
                                                 UT_Vector3 &pos,
                                                 float t);

    virtual OBJ_OBJECT_TYPE      getObjectType() const;

    // get actual rotates (in degrees) that were used for cooking
    // (this may replace local xform with the chop rotates solution)
    void                         getCookedLocalRotates( OP_Context &context,
                                                        UT_Vector3 &rot );

    // two specialized methods for calculating translation/scale transform
    // and rotation angles of the bone with respect to the parent bone. 
    // If parent is not a bone, the xforms are with respect to world. 
    void                         getBoneToParentCaptureTranslate( 
                                                        OP_Context &context,
                                                        UT_Vector3 &transl );
    void                         getBoneToParentCaptureRotate(
                                                        OP_Context &context,
                                                        UT_DMatrix4 &xform );
    // return roatation angles rot (in degrees to keep it consistent with
    // getCookedLocalRotates). Angles are orienting bone w.r.t. parent space
    void                         getBoneToParentCaptureRotate(
                                                        OP_Context &context,
                                                        UT_Vector3 &rot );

    // sets capture rotate parameter based on the given rotation angle vector
    // rot - contains angles (in degrees) in parent bone space
    void                         setCaptureRotateInParentSpace(
                                                        OP_Context &context,
                                                        const UT_Vector3 &rot );
        
    // this method obtains a parent to world transform in the capture position.
    // If parent is a bone, the transformation positions the origin
    // at the parent's tip (not base!) and aligns axis with parent's
    // reference frame.
    // If parent is not a bone, the transform is identity.
    void                         getBoneParentCaptureTransform(
                                                        OP_Context &context,
                                                        UT_DMatrix4 &xform );


    // Only affect bone length
    virtual void                 setScaleFromHandle(float t,
                                        const UT_Vector3 &s,
                                        bool create_keys = false,
                                        int key_idx = -1,
                                        bool check_modified = true);

    // Affect rotation and rest angles
    virtual void                 setRotateFromHandle(float t,
                                        const UT_Vector3 &r,
                                        bool create_keys = false,
                                        int key_idx = -1,
                                        bool check_modified = true);

    virtual const char *         getSetRotateParmName() const;

    virtual void                 transferLocalToPreTransform(float gtime);
    virtual void                 transferPreToLocalTransform(float gtime);
    virtual void                 transferLocalToPreTransformRotates( float t );
    
    void                         getCaptureRegions(
                                       UT_PtrArray<SOP_CaptureRegion *> &list );

    
    static PRM_Template         *getTemplateList();
    static PRM_Template         *getObsolete();


    virtual OBJ_Bone            *castToOBJBone()        { return this; }

protected:
    // Used to get pointer to indirection indices for each object type
    virtual int                 *getIndirect() const
                                { return boneIndirect; }

    // This method considers the effect of the LOOKAT fields and produces
    // a matrix that should be premultiplied to the orienation to get the
    // lookat.  It takes the local->world transform (myWorldXform) as this
    // is used to figure out where this is outside cookpaths. 
    // If 'interest' is supplied, then interest will be onto this other node
    // instead.
    // This returns 0 if no lookat is needed, in which case the matrix
    // provided will not be altered!
    // NOTE: this function is virtual, because OBJ_Bone has a "capture"
    //       mode in which the lookAt parameter (or input node's transform 
    //       for that matter) is not considered. For that reason, bones override
    //       this method to provide the mode-dependent transorm
    virtual int          buildLookAt(OP_Context &context,
                                     const UT_DMatrix4 &world, 
                                     UT_DMatrix4 &lookat,
                                     OP_Node *interest = 0);

    // Override these to pre-multiply a transform for the given matrix.
    // These return 1 if the matrix was modified, 0 otherwise
    virtual int     applyInputIndependentTransform(
                                OP_Context &context, UT_DMatrix4 &mat);
    virtual int     applyPreTransform(OP_Context &context, UT_DMatrix4 &mat);
    virtual int     applyInputDependentTransform(
                                        OP_Context &context, UT_DMatrix4 &mat);

private:
    static int                  getReferenceFrame(const char *frame);

    static int                  *boneIndirect;
    static KinOverride           theGlobalKinOverride;
    static const char           *theReferenceFrames[];
    static const char           *theReferenceFrameNames[];

    
    void                    getParmTransformHelper( OP_Context &context,
                                         UT_DMatrix4 &mat, 
                                         OBJ_TransformComponent type );

    void                    transferLocalToPreTransformHelper( float gtime, 
                                         OBJ_TransformComponent type );

    void                    getParmTransformFromBaseClass( 
                                    OP_Context &context, UT_DMatrix4 &mat, 
                                    OBJ_TransformComponent type );

    void                    getParmTransformFromKin( OP_Context &context,
                                  UT_DMatrix4 &mat, OBJ_TransformComponent type );

private:
// Callback for building custom world transforms from objects.
// The callback is responsible for setting the given matrix by
// the local transform of the object.
// Return 0 to stop processing, 1 to continue.
    static int  applyCustomParmTransform( 
            void *data, OBJ_Node *node, OP_Context &context, UT_DMatrix4 &mat);

    int         getCustomChildToWorldTransform(
                    const char *frame, float t, UT_DMatrix4 &mat);
    int         getCustomObjectToWorldTransform(
                    const char *frame, float t, UT_DMatrix4 &mat);

    void        adjustCaptureAndRestAngles(
                                        float gtime, UT_DMatrix4 &rest_xform );

    int         myCurrentReferenceFrame;
    int         myLastKinSolverOpId;
    unsigned    myUseSolverFlag:1,
                myIsUsingSolverFlag:1;
};


#undef EVAL_FLOAT
#undef EVAL_FLOATS
#undef EVAL_INT
#undef EVAL_STR

#undef SET_FLOAT
#undef SET_FLOATREF
#undef SET_INT
#undef SET_STRING

#endif

---