fbcharactermanipulator.h

Go to the documentation of this file.

#ifndef __FBCHARACTERMANIPULATOR_H__
#define __FBCHARACTERMANIPULATOR_H__
/**************************************************************************
 Copyright (c) 1994 - 2009 Autodesk, Inc. and/or its licensors.
 All Rights Reserved.
 
 The coded instructions, statements, computer programs, and/or related 
 material (collectively the "Data") in these files contain unpublished 
 information proprietary to Autodesk, Inc. and/or its licensors, which is 
 protected by Canada and United States of America federal copyright law 
 and by international treaties.
 
 The Data may not be disclosed or distributed to third parties, in whole 
 or in part, without the prior written consent of Autodesk, Inc. 
 ("Autodesk").
 
 THE DATA IS PROVIDED "AS IS" AND WITHOUT WARRANTY.
 ALL WARRANTIES ARE EXPRESSLY EXCLUDED AND DISCLAIMED. AUTODESK MAKES NO 
 WARRANTY OF ANY KIND WITH RESPECT TO THE DATA, EXPRESS, IMPLIED OR 
 ARISING BY CUSTOM OR TRADE USAGE, AND DISCLAIMS ANY IMPLIED WARRANTIES 
 OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR 
 PURPOSE OR USE. WITHOUT LIMITING THE FOREGOING, AUTODESK DOES NOT 
 WARRANT THAT THE OPERATION OF THE DATA WILL BE UNINTERRUPTED OR ERROR 
 FREE.
 
 IN NO EVENT SHALL AUTODESK, ITS AFFILIATES, PARENT COMPANIES, LICENSORS 
 OR SUPPLIERS ("AUTODESK GROUP") BE LIABLE FOR ANY LOSSES, DAMAGES OR 
 EXPENSES OF ANY KIND (INCLUDING WITHOUT LIMITATION PUNITIVE OR MULTIPLE 
 DAMAGES OR OTHER SPECIAL, DIRECT, INDIRECT, EXEMPLARY, INCIDENTAL, LOSS 
 OF PROFITS, REVENUE OR DATA, COST OF COVER OR CONSEQUENTIAL LOSSES OR 
 DAMAGES OF ANY KIND), HOWEVER CAUSED, AND REGARDLESS OF THE THEORY OF 
 LIABILITY, WHETHER DERIVED FROM CONTRACT, TORT (INCLUDING, BUT NOT 
 LIMITED TO, NEGLIGENCE), OR OTHERWISE, ARISING OUT OF OR RELATING TO THE 
 DATA OR ITS USE OR ANY OTHER PERFORMANCE, WHETHER OR NOT AUTODESK HAS 
 BEEN ADVISED OF THE POSSIBILITY OF SUCH LOSS OR DAMAGE.
 
**************************************************************************/

#include <kaydaradef.h>
#ifndef FBSDK_DLL 

    #define FBSDK_DLL K_DLLIMPORT
#endif

#include <fbsdk/fbcomponent.h>
#include <fbsdk/fbcore.h>
#include <fbsdk/fbcharacter.h>

#ifdef FBSDKUseNamespace
    namespace FBSDKNamespace {
#endif

// Return value for manipulation functions
enum FBManipulationStartResult 
{ 
    kFBManipulationOK,              
    kFBManipulationOKNoUndo,        
    kFBManipulationRefuse           
};

enum FBManipulationGetResult
{ 
    kFBManipulationGetDone,         
    kFBManipulationGetContinue,     
    kFBManipulationGetFail          
};

enum FBManipulationSetResult
{ 
    kFBManipulationSetContinue,     
    kFBManipulationSetFail          
};

enum FBReferencialType
{
    FBRefTypeNone,                  
    FBRefTypeGlobal,                
    FBRefTypeLocal,                 
    FBRefTypeLayer,                 
    FBRefTypeSumLayers,             
    FBRefTypeParent,                
};

enum FBSetType
{
    FBSetTypeNone,                  
    FBSetTypeExact,                 
    FBSetTypeCumulative,            
};

enum FBSetWhat
{
    FBSetWhatNone,                  
    FBSetWhatX,                     
    FBSetWhatY,                     
    FBSetWhatZ,                     
    FBSetWhatXYZ,                   
    FBSetWhatAll,                   
};                                  
                                    
enum FBManipPivot
{
    FBManipPivotObjectTranslation,  
    FBManipPivotObjectRotation,     
    FBManipPivotObjectScaling,      
    FBManipPivotObjectUnknown       
};

enum FBManipMode
{
    FBManip_EditorOther,        
    FBManip_EditorTranslation,  
    FBManip_EditorRotation,     
    FBManip_EditorScaling       
};

FB_DEFINE_COMPONENT( FBSDK_DLL, CharacterManipulator );
FB_DEFINE_COMPONENT( FBSDK_DLL, CharacterManipulatorCtrlSet );

// FBCharacterManipulator

__FB_FORWARD( FBCharacterManipulator);

class FBSDK_DLL FBCharacterManipulator : public FBComponent 
{
    __FBClassDeclare( FBCharacterManipulator,FBComponent );
public:
    FBCharacterManipulator(const char* pName, HIObject pObject=NULL);

    virtual FBManipulationGetResult     TranslationIsEditable( bool &pEditable, FBReferencialType pRefType ) = 0;

    // Manipulation Get/Set
    virtual FBManipulationSetResult     TranslationSet( FBTVector &pT, FBReferencialType pRefType, FBSetType pSetType, FBSetWhat pSetWhat ) = 0;
    virtual FBManipulationGetResult     TranslationGet( FBTVector &pT, FBReferencialType pRefType, FBManipPivot pPivot = FBManipPivotObjectTranslation ) = 0;
    
    // Manipulation
    virtual FBManipulationStartResult   TranslationStartManipulation( FBReferencialType pRefType, const FBTime* pTime = NULL ) = 0;
    virtual void                        TranslationStopManipulation () = 0;


    //Rotation
    virtual FBManipulationGetResult     RotationIsEditable( bool &pEditable, FBReferencialType pRefType ) = 0;
    
    /* Matrix Get/Set */
    virtual FBManipulationSetResult     RotationSet( FBMatrix &pRM, FBReferencialType pRefType, FBSetType pSetType, bool pOnlyRoot = false ) = 0;
    virtual FBManipulationGetResult     RotationGet( FBMatrix &pRM, FBReferencialType pRefType ) = 0;

    /* Manipulation */
    virtual FBManipulationStartResult   RotationStartManipulation( FBReferencialType pRefType ) = 0;
    virtual void                        RotationStopManipulation () = 0;

    //Scaling
    virtual FBManipulationGetResult     ScalingIsEditable( bool &pEditable ) = 0;
    
    /* Manipulation Get/Set*/
    virtual FBManipulationSetResult     ScalingSet( FBSVector &pS, FBReferencialType pRefType, FBSetType pSetType, FBSetWhat pSetWhat ) = 0;
    virtual FBManipulationGetResult     ScalingGet( FBSVector &pS, FBReferencialType pRefType ) = 0;

    /* Manipulation */
    virtual FBManipulationStartResult   ScalingStartManipulation( FBReferencialType pRefType ) = 0;
    virtual void                        ScalingStopManipulation () = 0;

    bool    IsReleasePinPressed();

    FBModel *GetManipulatedNode();

    FBManipMode GetManipulatorMode();
};

#define FBCharacterManipulatorCtrlSetDeclare( ClassName, Parent ) \
    FBClassDeclare( ClassName, Parent ); \
  public: \
    ClassName(const char* pName):Parent(pName) { FBClassInit; } \
  private:

#define FBCharacterManipulatorCtrlSetImplementation( ThisComponent ) \
        FBClassImplementation( ThisComponent )

// FBCharacterManipulatorCtrlSet
__FB_FORWARD( FBCharacterManipulatorCtrlSet);

class FBSDK_DLL FBCharacterManipulatorCtrlSet : public FBCharacterManipulator 
{
    __FBClassDeclare( FBCharacterManipulatorCtrlSet,FBCharacterManipulator );
public:
    FBCharacterManipulatorCtrlSet(const char* pName, HIObject pObject=NULL);

    FBCharacter *                       GetCharacter();

    virtual void                        AllocateState(FBCharacter* pCharacter);

    virtual void                        DeallocateState();

    bool                                IsFullBody(); 

    bool                                IsFullBodyNoPull(); 

    bool                                IsBodyPart(); 

    bool                                IsReachOverride();

    bool                                IsStiffnessOverride();

    bool                                IsIKPivotUse();

    virtual void                        SyncCharacter(FBEvaluateInfo *pEvalInfo);
   
    FBEffectorId                        GetManipulatedEffectorId();

    FBEffectorId                        GetManipulatedEffectorIdForRotation();

    FBEffectorId                        GetManipulatedEffectorIdForTranslation();

    FBEffectorSetID                     GetEffectorSet();

    FBBodyNodeId                        GetManipulatedBodyNode();

    bool                                IsDescendantPulling(FBEffectorId pEffectorId);

    int                                 GetDescendantEffectorCount(FBEffectorId pEffectorId);

    FBEffectorId                        GetDescendantEffector(FBEffectorId pEffectorId, int pIndex);

    float                               GetEffectorReachTValue(int pEffectorId);              
    void                                SetEffectorReachTValue(int pEffectorId, float pValue);              

    float                               GetEffectorPullValue(int pEffectorId);              
    void                                SetEffectorPullValue(int pEffectorId, float pValue);              

    void                                TranslationSetGlobal(FBTVector pVector, int pEffectorId);
    void                                TranslationSetLocal(FBTVector pVector, int pEffectorId);

    //For the following function, please see the description in the parent class.
    //Translation
    virtual FBManipulationGetResult     TranslationIsEditable( bool &pEditable, FBReferencialType pRefType );
    // Manipulation Get/Set
    virtual FBManipulationSetResult     TranslationSet( FBTVector &pT, FBReferencialType pRefType, FBSetType pSetType, FBSetWhat pSetWhat );
    virtual FBManipulationGetResult     TranslationGet( FBTVector &pT, FBReferencialType pRefType, FBManipPivot pPivot = FBManipPivotObjectTranslation );
    // Manipulation
    virtual FBManipulationStartResult   TranslationStartManipulation( FBReferencialType pRefType, const FBTime* pTime = NULL );
    void                                TranslationStopManipulation ();

    //Rotation
    virtual FBManipulationGetResult     RotationIsEditable( bool &pEditable, FBReferencialType pRefType );
    /* Matrix Get/Set */
    virtual FBManipulationSetResult     RotationSet( FBMatrix &pRM, FBReferencialType pRefType, FBSetType pSetType, bool pOnlyRoot = false );
    virtual FBManipulationGetResult     RotationGet( FBMatrix &pRM, FBReferencialType pRefType );
    /* Manipulation */
    virtual FBManipulationStartResult   RotationStartManipulation( FBReferencialType pRefType );
    virtual void                        RotationStopManipulation ();

    //Scaling
    virtual FBManipulationGetResult     ScalingIsEditable( bool &pEditable );
    /* Manipulation Get/Set*/
    virtual FBManipulationGetResult     ScalingGet( FBSVector &pS, FBReferencialType pRefType );
    virtual FBManipulationSetResult     ScalingSet( FBSVector &pS, FBReferencialType pRefType, FBSetType pSetType, FBSetWhat pSetWhat );
    /* Manipulation */
    virtual FBManipulationStartResult   ScalingStartManipulation( FBReferencialType pRefType );
    virtual void                        ScalingStopManipulation ();
};

#ifdef FBSDKUseNamespace
    }
#endif
#endif