brush.h

Go to the documentation of this file.

//**************************************************************************/
// Copyright (c) 2008 Autodesk, Inc.
// All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
//
//**************************************************************************/
// DESCRIPTION:
// CREATED: August 2009
//**************************************************************************/

#ifndef __MUDBOXSDK_BRUSH_H__
#define __MUDBOXSDK_BRUSH_H__

#include <QtCore/QHash>
#include <QtCore/QSharedPointer>
#include <QtCore/QCoreApplication>

namespace mudbox {

class MBDLL_DECL BrushConfiguration
{
public:
    typedef enum
    {
        PaintTools,
        SculptTools,
        PoseTools,
        SelectTools
    } PredefinedCategory;

public:
    BrushConfiguration( );
    BrushConfiguration( const ClassDesc *pClass, unsigned int iID, const QString& sStringID, const QString& sDisplayName, const QString& sCategory, const QString& sCategoryTr, const QString& sToolTip );
    BrushConfiguration( const ClassDesc *pClass, unsigned int iID, const QString& sStringID, const QString& sDisplayName, PredefinedCategory nCategory, const QString& sToolTip );
    ~BrushConfiguration( );
    unsigned int ID( void ) const;
    virtual QString Name( void ) const;
    virtual QString StringID( void ) const;
    virtual QString DisplayName( void ) const;
    virtual void SetDisplayName( const QString & sDisplayName );
    virtual QString ToolTip( void ) const;
    virtual const ClassDesc *OperationClass( void ) const;
    virtual QString Category() const;
    virtual QString DisplayCategory() const;
    virtual void Serialize( Stream& s );

private:
    const ClassDesc *m_pClass;
    unsigned int m_iID;
    QString m_sStringID, m_sToolTip, m_sCategory;
    QString m_sDisplayName, m_sCategoryTr;
    Action* m_pAction;
};

enum MirrorMode
{
    eMirrorNone,
    eMirrorX,
    eMirrorY,
    eMirrorZ,
    eMirrorLocalX,
    eMirrorLocalY,
    eMirrorLocalZ,
    eMirrorTangent
};

struct MBDLL_DECL MirrorConfiguration
{
    MirrorConfiguration( void );
    MirrorConfiguration( const MirrorConfiguration &v );
    enum MirrorMode MirrorMode( void ) const;
    void SetMirrorMode( enum MirrorMode mode );
    const Store<mudbox::Vector> &MirrorPlaneNormals( void ) const { return m_aMirrorPlaneNormals; };
    const Store<mudbox::Vector> &MirrorPlanePositions( void ) const { return m_aMirrorPlanePositions; };
    bool IsMirrorLocal( void ) const { return m_bMirrorLocal; };
    int MirrorPlanes( void ) const { return m_iMirrorPlanes; };
    Matrix TransformationMatrix( 
            const SurfacePoint *pSourceLocation,    


             bool bNormalizeLocalFrame = false  
        ) const;
    Vector Transform( 
        const Vector &cSource, 
        float fW, 
        const SurfacePoint *pSourceLocation 


        ) const;

    inline bool operator ==( const MirrorConfiguration & ) const throw() { return false; };
    inline bool operator !=( const MirrorConfiguration &v ) const throw() { return !operator ==( v ); };

    virtual void Serialize( Stream& s );

private:
    Matrix AxisTransformationMatrix( 
            const SurfacePoint *pSourceLocation 


        ) const;
    Matrix TangentTransformationMatrix( 
            const SurfacePoint *pSourceLocation,    


             bool bNormalizeLocalFrame = false           
        ) const;

    bool m_bMirrorLocal;
    int m_iMirrorPlanes;
    Store<mudbox::Vector> m_aMirrorPlaneNormals;
    Store<mudbox::Vector> m_aMirrorPlanePositions;

    friend class BrushOperation;
};

typedef AttributeInstance<MirrorConfiguration> amirrorcfg;

MBDLL_DECL AttributeWidget *CreateNewMirrorConfigurationWidget( QWidget *pParent, int iWidth, amirrorcfg *pAttribute );

template <> inline
AttributeWidget *amirrorcfg::CreateEditorWidget( QWidget *pParent, int iWidth ) { return CreateNewMirrorConfigurationWidget( pParent, iWidth, this ); };

template <> inline
Attribute::AttributeType amirrorcfg::Type( void ) const { return typeUnknown; };

template <> inline
QString amirrorcfg::AsString( bool /*bLocalized*/ ) const { return   QString::number(m_cValue.MirrorMode()); };

template <> inline
void amirrorcfg::SetFromString( const QString &mode, bool /*bInternal*/, bool /*bLocalized*/ ) { m_cValue.SetMirrorMode(MirrorMode(mode.toInt()));  };


struct MBDLL_DECL StampConfiguration
{
    StampConfiguration( void )
    {
        m_bActive = false;
        m_bOrientToStroke = true;
        m_bStretch = false;
        m_bFlipX = m_bFlipY = m_bRandomize = m_bRandomizeFlipX = m_bRandomizeFlipY = false;
        m_fRotation = m_fRandomizeScale = m_fRandomizeStrength = 0.0f;
        m_fRandomizeRotation = 0.35f;
        m_fRandomizePositionX = m_fRandomizePositionY = 0.4f;
    }

    void Serialize( Stream &s );

    inline bool operator ==( const StampConfiguration & ) const throw() { return false; };
    inline bool operator !=( const StampConfiguration &v ) const throw() { return !operator ==( v ); };

    QString m_sFileName;
    bool m_bActive;
    bool m_bOrientToStroke, m_bStretch;
    bool m_bFlipX, m_bFlipY;
    float m_fRotation;
    bool m_bRandomize, m_bRandomizeFlipX, m_bRandomizeFlipY;
    float m_fRandomizeScale, m_fRandomizeRotation, m_fRandomizePositionX, m_fRandomizePositionY, m_fRandomizeStrength;
};

typedef AttributeInstance<StampConfiguration> astampcfg;

MBDLL_DECL AttributeWidget *CreateNewStampConfigurationWidget( QWidget *pParent, int iWidth, astampcfg *pAttribute );

template <> inline
AttributeWidget *astampcfg::CreateEditorWidget( QWidget *pParent, int iWidth ) { return CreateNewStampConfigurationWidget( pParent, iWidth, this ); };

template <> inline
Attribute::AttributeType astampcfg::Type( void ) const { return typeUnknown; };
     
template<> inline
QString astampcfg::AsString( bool /*bLocalized*/ ) const
{
    return QString("%0 %1 %2 %3 %4 %5 %6 %7 %8 %9 %10 %11 %12 %13")
        .arg(m_cValue.m_bActive)
        .arg(m_cValue.m_bOrientToStroke)
        .arg(m_cValue.m_bStretch)
        .arg(m_cValue.m_bFlipX)
        .arg(m_cValue.m_bFlipY)
        .arg(m_cValue.m_fRotation)
        .arg(m_cValue.m_bRandomize)
        .arg(m_cValue.m_bRandomizeFlipX)
        .arg(m_cValue.m_bRandomizeFlipY)
        .arg(m_cValue.m_fRandomizeScale)
        .arg(m_cValue.m_fRandomizeRotation)
        .arg(m_cValue.m_fRandomizePositionX)
        .arg(m_cValue.m_fRandomizePositionY)
        .arg(m_cValue.m_fRandomizeStrength);
};

template<> inline
void astampcfg::SetFromString( const QString &s , bool /*bInternal*/, bool /*bLocalized*/ )
{
    m_cValue.m_bActive = s.section( ' ', 0,0 ) == "1" ? true : false;
    m_cValue.m_bOrientToStroke = s.section( ' ', 1,1 ) == "1" ? true : false;
    m_cValue.m_bStretch = s.section( ' ', 2,2) == "1" ? true : false;
    m_cValue.m_bFlipX = s.section( ' ', 3,3 ) == "1" ? true : false;
    m_cValue.m_bFlipY = s.section( ' ', 4,4 ) == "1" ? true : false;
    m_cValue.m_fRotation = s.section( ' ', 5,5 ).toFloat();
    m_cValue.m_bRandomize = s.section( ' ', 6,6 ) == "1" ? true : false;
    m_cValue.m_bRandomizeFlipX  = s.section( ' ', 7,7 ) == "1" ? true : false;
    m_cValue.m_bRandomizeFlipY = s.section( ' ', 8,8 ) == "1" ? true : false;
    m_cValue.m_fRandomizeScale = s.section( ' ', 9,9 ).toFloat();
    m_cValue.m_fRandomizeRotation = s.section( ' ', 10,10 ).toFloat();
    m_cValue.m_fRandomizePositionX = s.section( ' ', 11,11 ).toFloat();
    m_cValue.m_fRandomizePositionY = s.section( ' ', 12,12 ).toFloat();
    m_cValue.m_fRandomizeStrength =s.section( ' ', 13,13 ).toFloat(); 
};
    
class MBDLL_DECL BrushOperation : public Operation
{
    Q_DECLARE_TR_FUNCTIONS(mudbox::BrushOperation)
    DECLARE_CLASS;
public:
    enum Direction
    {
        eDirNormal,
        eDirAveragedNormal,
        eDirVertexNormal,
        eDirForward,
        eDirRight,
        eDirX,
        eDirY,
        eDirZ,
        eDirCamera,
        eDirScreen,
        eDirXY,
        eDirXZ,
        eDirYZ
    };

    enum Modifier
    {
        eModNormal,
        eModAdditive,
        eModInverted,
        eModNoEffect
    };

    enum TriggerType
    {
        eTriggerPrimary,    // primary button was used (by default left mouse button)
        eTriggerSecondary,  // secondary button was used (by default middle mouse button)
        eTriggerTertiary    // tertiary button was used (by default left+middle mouse button)
    };

    enum MaskType
    {
        eMaskAny = -1,
        eMaskStamp,
        eMaskStencil,
        eMaskTypeCount
    };

    enum StampSizingMode
    {
        eStampSizingNone,
        eStampSizingRadius,
        eStampSizingDiameter
    };

    struct BrushBehavior
    {
        enum BehaviorType
        {
            eBehaviorNone,
            eBehaviorBrush,
            eBehaviorAttribute
        };

        BrushBehavior( void ) { m_eType = eBehaviorNone; m_sTarget = ""; m_iHotkey = 0; };
        BrushBehavior( BehaviorType type, QString target, int iHotkey ) : m_eType( type ), m_sTarget( target ), m_iHotkey( iHotkey ) {};

        BehaviorType m_eType;
        QString m_sTarget;
        int m_iHotkey;
    };

    BrushOperation( void );

    virtual QString StringID( const ClassDesc *pClass = 0 ) const;
    virtual QString DisplayName( void ) const;

    virtual void OnNodeEvent( const Attribute &cAttribute, NodeEventType eType );

    virtual bool IsScreenSpace( void ) const;
    virtual float BrushSize( void ) const;
    virtual float BrushStrength( void ) const;
    virtual void SetBrushSize( float fSize );
    virtual void SetBrushStrength( float fStrength );
    virtual float EffectiveBrushSize( void ) const;
    virtual float EffectiveBrushStrength( void ) const;
    virtual float BrushSizeBias( void ) const;
    virtual float BrushStrengthBias( void ) const;
    virtual float MaxBrushSize( void ) const;
    virtual float MaxBrushStrength( void ) const;

    virtual bool UsesStrokeSmoothing( void ) const;
    virtual float StrokeSmoothingDistance( void ) const;
    virtual void SetStrokeSmoothing( bool bEnable, float fDistance );
    virtual bool HasCustomCursor( void );

    virtual bool UsesSteadyStroke( void ) const;
    virtual float SteadyStrokeDistance( void ) const;
    virtual void SetSteadyStroke( bool bEnable, float fDistance );

    virtual enum StampSizingMode StampSizingMode( void ) const;
    virtual void SetStampSizingMode( enum StampSizingMode eMode );

    virtual const NURBSCurve *Falloff( void ) const;
    virtual void SetFalloff( NURBSCurve *pCurve );
    virtual const Store<float> &FalloffData( void ) const;
    inline float FalloffValue( float fValue ) const
    {
        return FalloffData()[int(fValue*(FalloffData().ItemCount()-1))];
    };
    virtual bool UsesFalloffBasedOnFacingAngle( void ) const;
    virtual void SetFalloffBasedOnFacingAngle( bool bEnable );

    virtual bool UsesStampRandomize( void ) const;
    virtual void SetStampRandomize( bool bEnable );

    virtual bool IsMaskEnabled( MaskType type = eMaskAny ) const;
    virtual const Image *MaskImage( MaskType type = eMaskAny ) const;
    virtual Matrix MaskMatrix( MaskType type = eMaskAny ) const;
    virtual bool IsMaskInverted( MaskType type = eMaskAny ) const;
    virtual float MaskFactor( MaskType type = eMaskAny ) const;
    virtual bool IsMaskTiled( MaskType type = eMaskAny ) const;
    virtual QString MaskName( MaskType type = eMaskAny ) const;
    virtual bool MaskBuildUp( MaskType type = eMaskAny ) const;
    virtual const Image *MaskOpacityImage( MaskType type = eMaskAny ) const;
    virtual float MaskOffset( MaskType type = eMaskAny ) const;
    virtual void OnMaskChanged( MaskType type = eMaskAny );

    virtual float BuildUpRate( void ) const;
    virtual bool PatchesAtRelease( void ) const;
    virtual bool PressureControlsBrushSize( void ) const;
    virtual bool PressureControlsBrushStrength( void ) const;
    virtual bool IsInverted( void ) const;
    virtual bool IsOrientedToSurface( void ) const;

    Direction Direction( void ) const;
    Vector DirectionVector( unsigned int iVertexIndex ) const;
    virtual void SetDirectionVector( const Vector &vDirection ) const;
    Vector PreviousPatchPosition( void ) const;

    virtual void BeginStroke( Mesh *pMesh, Modifier eModifier, TriggerType eTriggerType );
    virtual void EndStroke( void );
    virtual void MouseMove( float fXPosition, float fYPosition, float fXDelta, float fYDelta, AxisAlignedBoundingBox &cDirtyWorldArea, float fSize, float fPressure, float fStrength );
    virtual void AddPatch( const SurfacePoint *pPoint, const Vector &vPatchCenter, float fSize, float fPressure, float fStrength, AxisAlignedBoundingBox &cDirtyWorldArea );
    virtual void Flood( Mesh *pTarget, float fStrength = 1.0f, bool bFromCamera = false );

    virtual void SetInactive();
    virtual void SetActiveConfiguration( BrushConfiguration *config );
    virtual void SetActiveConfiguration( const QString &sName );
    virtual BrushConfiguration *ActiveConfiguration( void ) const;

    static void AddConfiguration( BrushConfiguration *config );
    static unsigned int ConfigurationCount( void );
    static BrushConfiguration *Configuration( unsigned int iIndex );

    const StampConfiguration &StampConfig( void ) const;
    void SetStampConfig( StampConfiguration &newConfig );
    void SetStamp( bool bEnable, const QString &sFileName = "" );

    void SetBrushSizeScale( float fScale );
    void SetBrushStrengthScale( float fScale );

    bool UsesGlobalBrushSize( void ) const;

    Modifier CurrentModifier( void ) const;

    const MirrorConfiguration &MirrorConfig( void ) const;
    virtual void SetMirrorConfig( MirrorConfiguration newConfig );

    virtual bool IsConfigurationInited( BrushConfiguration *config ) const;
    virtual void StoreConfiguration( BrushConfiguration *config );
    virtual void RestoreConfiguration( BrushConfiguration *config );
    static void SerializeConfigurationStates( Stream &s );

    virtual QString OverlayIcon( void );
    virtual QPointF OverlayOffset( void );

    virtual bool ExecuteAndInvert( void );
    virtual void Serialize( Stream &s );
    virtual BrushOperation &operator =( const BrushOperation &op );

    virtual bool CanLockLayer( void ) const;

    virtual bool CustomPicker( void );

    virtual Node *AttributeHolderNode( void );

    virtual void SetFalloffIndex( int iIndex );

    virtual int FalloffIndex( void ) const;

    virtual unsigned int AlternateBehaviorCount( void ) const;

    virtual const BrushBehavior &AlternateBehavior( unsigned int iIndex ) const;

    virtual bool IsSnapToCurve( void ) const;
    
    virtual float SnapDistance( void ) const;

protected:
    abool m_bScreenSpace;
    abool m_bInverted;
    abool m_bOrientToSurface;
    afloatr m_fNormalBrushSize, m_fNormalBrushStrength;
    afloatr m_fScreenBrushSize, m_fScreenBrushStrength;
    afloatr m_fMaxBrushSize, m_fMaxBrushStrength;
    afloatr m_fBrushSizeBias, m_fBrushStrengthBias;
    acheckablefloat m_fStrokeSmoothing;
    acheckablefloat m_fSteadyStroke;
    abool m_bRememberSize;
    aenum m_iDirection;
    astampcfg m_cStampCfg;
    amirrorcfg m_cMirrorCfg;
    aevent m_cFlood;
    aevent m_cFloodFromCamera;
    avoid m_vPressure;
    acurveptr m_cFalloff;
    aint m_iFalloffIndex;
    aptr<NURBSCurve> m_pFalloffCurve;
    AttributeCheckableFloatArray m_aFalloffBasedonFacingAngle;
    aevent m_cReset;

    Modifier m_eModifier;
    TriggerType m_eTriggerType;
    float m_fBrushSizeScale;
    float m_fBrushStrengthScale;
    BrushConfiguration *m_pActiveConfiguration;

    BrushBehavior m_cAlternateBehavior1, m_cAlternateBehavior2;

    acheckablefloat m_fSnapToCurve;

private:
    static QHash< BrushConfiguration *, QSharedPointer<mudbox::BrushOperation> > s_aConfigurationStates;
    static Store<BrushConfiguration *> s_aConfigurations;
};

#define MB_ADD_CONFIG( classname, id, name, nametr, category, tooltip ) \
    mudbox::BrushOperation::AddConfiguration( new BrushConfiguration( classname::StaticClass(), id, name, nametr, category, tooltip ) );

#define MB_ADD_CONFIG2( classname, id, name, nametr, category, categoryTr, tooltip ) \
    mudbox::BrushOperation::AddConfiguration( new BrushConfiguration( classname::StaticClass(), id, name, nametr, category, categoryTr, tooltip ) );

}; // end of namespace mudbox

#endif