preferences.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: October 2008
//**************************************************************************/

#include <QtCore/QDir>
#include <QtCore/QCoreApplication>

namespace mudbox {

// Remove Linux's system header clashing defines.
#if defined(Bool)
#undef Bool
#endif

enum TiffCompression
{
    eTiffNoCompression      = 0,
    eTiffLZWCompression     = 1,
    eTiffDeflateCompression = 2
};

enum LinearUnits
{
    eMillimeter,
    eCentimeter,
    eMeter,
    eInch
};

enum SelectionMode
{
    ePaint = 0,
    eRectangle,
    eLasso
};

enum InactiveLevelDisplay
{
    eNone,
    eHide,
    eShade
};

class MBDLL_DECL AttributeLocale : public astring
{
    Q_DECLARE_TR_FUNCTIONS(mudbox::AttributeLocale)

public:
    AttributeLocale( Node *pOwner, const QString &sID);
    AttributeLocale( Node *pOwner, const QString &sID, const QString& cValue );
    virtual ~AttributeLocale();

public:
    virtual AttributeWidget* CreateEditorWidget( QWidget *pParent, int iWidth );
};

class MBDLL_DECL Preferences : public Node
{
    Q_DECLARE_TR_FUNCTIONS(mudbox::Preferences);
    DECLARE_CLASS;
public:
    Preferences( void );
    ~Preferences( void );
    void Serialize( Stream & );
    void ProcessLine( QString &sSrc, QString &sName, QString &sValue );
    void SavePaths( void );
    bool LoadPaths( void );
    QString FindSettings( QString &sDir );
    QString DefaultDataPath() const;

    Attribute *RegisterVariable( const QString &sName, const QString &sCategory, const QString& sNameTr, const QString &sCategoryTr, Attribute::AttributeType eType, const QString &sDefaultValue );
    inline afloatr *RegisterFloatVariable( const QString &sName, const QString &sCategory, const QString& sNameTr, const QString &sCategoryTr, float fDefaultValue ) { return (afloatr *)RegisterVariable( sName, sCategory, sNameTr, sCategoryTr, Attribute::typeFloat, QString("%1").arg(fDefaultValue) ); };
    inline abool *RegisterBoolVariable( const QString &sName, const QString &sCategory, const QString& sNameTr, const QString &sCategoryTr, bool bDefaultValue ) { return (abool *)RegisterVariable( sName, sCategory, sNameTr, sCategoryTr, Attribute::typeBool, bDefaultValue ? "true" : "false" ); };
    inline astring *RegisterStringVariable( const QString &sName, const QString &sCategory, const QString& sNameTr, const QString &sCategoryTr, const QString &sDefaultValue ) { return (astring *)RegisterVariable( sName, sCategory, sNameTr, sCategoryTr, Attribute::typeString, sDefaultValue ); };
    inline acolor *RegisterColorVariable( const QString &sName, const QString &sCategory, const QString& sNameTr, const QString &sCategoryTr, const mudbox::Color &cDefaultValue ) { return (acolor *)RegisterVariable( sName, sCategory, sNameTr, sCategoryTr, Attribute::typeColor, QString("%1 %2 %3 %4").arg(cDefaultValue.r).arg(cDefaultValue.g).arg(cDefaultValue.b).arg(cDefaultValue.a) ); };
    inline aint *RegisterIntegerVariable( const QString &sName, const QString &sCategory, const QString& sNameTr, const QString &sCategoryTr, int iDefaultValue ) { return (aint *)RegisterVariable( sName, sCategory, sNameTr, sCategoryTr, Attribute::typeInt, QString("%1").arg(iDefaultValue) ); };
    inline avector *RegisterVectorVariable( const QString &sName, const QString &sCategory, const QString& sNameTr, const QString &sCategoryTr, const mudbox::Vector &vDefaultValue ) { return (avector *)RegisterVariable( sName, sCategory, sNameTr, sCategoryTr, Attribute::typeVector, QString("%f %f %f").arg(vDefaultValue.x).arg(vDefaultValue.y).arg(vDefaultValue.z ) ); };
    inline aenum *RegisterEnumVariable( const QString &sName, const QString &sCategory, const QString& sNameTr, const QString &sCategoryTr, int iDefaultValue ) { return (aenum *)RegisterVariable( sName, sCategory, sNameTr, sCategoryTr, Attribute::typeEnum, QString("%1").arg(iDefaultValue) ); };

    void OnNodeEvent( const Attribute &, NodeEventType );

    const ClassDesc *SelectedMeshRenderer() { return m_pSelectedMeshRenderer; }

    abool m_bCheckFrustum, m_bMultiThreadRender, m_bHighlightBrushArea;
    aint m_iFastBrushLevel;
    abool m_bFocusWhenEmpty, m_bFocusWhenNotEmpty, m_bZoomWhileFocus;
    abool m_bPickBothSide;
    abool m_bUseVideoMemory;

    abool m_bRemoveLevels, m_bRemoveOctree;
    abool m_bSmoothPos, m_bCreateUVs, m_bSmoothUV, m_bPreserveBorders, m_bPreserveUVBorders; 
    abool m_bEnableCreasing, m_bPreserveHardEdges, m_bCreaseHardEdges;  
    aenum m_iBoundaryRule;

    aenum m_eDefaultMaterial;
    abool m_bDisableLODChange;
    abool m_bNoPaintUndo;
    aenum m_eSoloLayerVisibility;

    aint m_fMinPenPressure, m_fMaxPenPressure;
    aint m_iGridSize, m_iGridSteps;
    aint m_iDoubleClickTime;
    abool m_bWireOnShaded;
    aenum m_bWireframeType;
    abool m_bShowPickedFace;
    aint m_iWireLevel;
    aenum m_eImportAutofocus;
    bool m_bFlatLighting;
    bool m_bFacetedShading;
    bool m_bLighting;
    abool m_bDisplayCreaseNormals; 

    afloatr m_fCameraDollySensitivity;
    afloatr m_fCameraTrackSensitivity;
    afloatr m_fCameraRotateSensitivity;
    
    abool m_bOptimizeMeshes;
    abool m_bShowLayerMask;
    abool m_bUseDraftRender, m_bShowFrozenVertices;
    aint m_iPointRenderRarity;
    aint m_iDraftRenderMinFaceCount;
    abool m_bHUDProjectedSubdiv, m_bHUDSelected, m_bHUDVisible, m_bHUDFPS, m_bHUDRendered;
    aint m_iHUDProjectedXSubdivisionLevel;
    aint m_iMinutesToAlarm, m_iBuildUpRate;
    afloatr m_fPressureTreshold;
    afloatr m_fStencilRotateSensitivity;
    abool m_bForceVidmemRender;
    abool m_bUseLocalYForCameraRotation;
    aenum m_iCameraControlMode;
    afloatr m_fRollArea;

    abool m_bSaveIndicator, m_bSelectPicked, m_bLocalFocus;

    aint m_iMirrorPlanes;
    Store<mudbox::Vector> m_aMirrorPlaneNormals;
    Store<mudbox::Vector> m_aMirrorPlanePositions;
    abool m_bMirrorLocal;

    abool m_bUseQtFileDialog;
    afloatr m_fSmartFocus;
    acolor m_cViewportCenter, m_cViewportTop, m_cViewportBottom, m_cViewportFlat, m_cGrid, m_cGridAxis, m_cLocked;
    acolor m_cSelection, m_cMask, m_cActiveLayer, m_cInactiveLayer, m_cLayerMask, m_cMirrorGrid;
    acolor m_cSceneInfoBg, m_cFalloffCurve, m_cFalloffHull, m_cFalloffFill;
    acolor m_cExpandedUV;
    aenum m_eUnitLinear;
    aenum m_eFaceSelectionMode, m_eObjectSelectionMode;
    float m_aLinearUnitRates[4];
    astring m_sDefaultObjDir, m_sDefaultMudDir, m_sDefaultStampDir, m_sDefaultStencilDir, m_sDefaultIconDir,
            m_sDefaultImagePlaneDir, m_sDefaultTextureLayerDir, m_sDefaultPSDDir, m_sDefaultSaveScreenDir;
    astring m_sLogPath, m_sTempPath, m_sSettingsPath, m_sDataPath;
    astring m_sTexturePath; 
    astring m_sMayaInstallPath; 
#ifdef WantSendToMax
#ifdef WIN32
    astring m_sMaxInstallPath;
#endif
#endif
    abool m_bPathsChanged;
    abool m_bExpertHidesWest, m_bExpertHidesNorth, m_bExpertHidesSouth, m_bExpertHidesEast, m_bExpertHidesMenu, m_bExpertHidesStatus;
    aint m_iDragBoxSize;
    abool m_bShowLearningMovies;
    abool m_bShowWelcomeDialog;
    abool m_bWhatsNewHighlight;
    aenum m_eWhatsNewVersion;
    abool m_bWhatsNewBoxOnStartup;
    acolor m_cWhatsNewHighlightColor;
    abool m_bShowViewCube;
    abool m_bEnableMTGestures;
    aenum m_eTouchPadMTSupport;
    abool m_bHUDInfoMessage;
    abool m_bHUDHelpMessage;
    aenum m_iHelpType;
    astring m_sHelpLocation;
    abool m_bCompressFiles;
    abool m_bOBJThumbnail;
    abool m_bMUDContainsView, m_bMUDContainsBrush;
    abool m_bCull, m_bCreateBackup;
    abool m_bShowTileInfo;

    aenum m_bRenderSelectedPerFace;
    // map extraction
    //struct MapExtraction
    //{
        aint m_iMapWidth;
        aint m_iMapHeight;
        astring m_sOutputDir;
        abool m_bExtractNormal;
        abool m_bExtractDisplacement;
        abool m_bSmoothNormals;
        aint m_iSmoothLevel;
        aint m_iNormalSpace;
        afloat m_fRayTravel;
        aint m_eRayCenter;
        abool m_bPickBothSides;
        aint m_iEdgeBleed;
        aint m_iNormalFormat;
        aint m_iDisplacementFormat;
        aint m_iSubdivLow;
        astring m_sNormalFileName;
        astring m_sDisplacementFileName;
        abool m_bSkipEmptyMaps;
        aint m_iExtUDim;
        aint m_iUStart;
        abool m_bSelectedFacesOnly;
        astring m_sLowObjectName;
        astring m_sHighObjectName;
        abool m_bInvertTangent;
        abool m_bInvertBinormal;
        afloat m_fAreaTreshold;
    //} m_cMapExtraction;

    //struct DisplacementPreferences
    //{
        astring m_sTileRange;
        afloat m_fMiddleValue;
        aint m_iFirstTileIndex, m_iDispUDim;
        aint m_iMaskChannel, m_iNegativeDisplacementChannel, m_iPositiveDisplacementChannel;
        aint m_iXSubdivisionLevel;
        astring m_sObjectName;
        astring m_sDisplacementFileMask;
        astring m_sMaskFileMask;
//  } m_cDisplacement;

    aenum m_eTextureRatio;
    afloat m_fTextureRatio;

    aenum m_eTiffCompression;

    avoid m_lExpertModeLabel;
    abool m_bMultisampling;
    astring m_sNextCommand;

    Store<Attribute *> m_aPluginAttributes;

    aenum m_eMeshRenderers;

    afloatr m_fPaintBleedDistance;
    abool m_bRenderEdgeBleed;
    // Edge bleed overlap can be calculated by two different methods:
    // Image method: slower than the geometry method, but more accurate.
    // Geometry method: faster than the Image method, and less accurate.
    enum HighlightEdgeBleedOverlapMethod {
        eNone = 0, 
        eImage = 1,              
        eGeometry =  2           
    }; 
    aenum m_eHighlightEdgeBleedOverlap;
    abool m_bBleedRejectOverlap;
    afloatr m_fPaintBrushOffset;
    abool m_bFastDryBrush;
    astring m_sExportFilter;
    abool m_bUse16bitinternalformat;

    abool m_bHideEULANag;

    aint m_movieWidth;
    aint m_movieHeight;
    aint m_movieRecordFps;
    aint m_moviePlaybackFps;
    abool m_moviePauseWhenIdle;
    abool m_movieUses3dView;

    astring m_sPaintLayerFormat;
    aint m_iPaintLayerSize;

    AttributeLocale m_langui;
    AttributeLocale m_langhelp;
    AttributeLocale m_locale;

    abool m_bUseGigatexelEngine;
    afloatr m_fPaintBufferMemoryBudget;
    abool m_bLoadProxyTextures;

    astring m_sUILayoutPath;
    abool m_bLockUILayout;

    // Interaction Mode Preferences
    aenum m_eInteractionModeSelected;

    // Controls use of two channel textures.  Two channel textures (GL_LUMINANCE_ALPHA) save on GPU
    // memory.  Typically we'd always want to use two channel textures, however we're having regressions
    // on some AMD video cards.  Until we have those regressions addressed we'll default to four channel
    // for now.  This attribute is not retroactive, any textures that are already four channel will not
    // be turned into two channels.
    //
    // The number of channels used is internal only.  The user only sees four channel textures.
    abool m_bUseTwoChannelTextures;

    abool m_bDisplayCurvePoints;

    astring m_sSelectedBrushName;

    bool m_bLoadingPaths;

    abool m_bInitialized3DConnexion;
    aint m_iSpeed;
    aint m_iInputThreshold;
    aint m_iDollyMode;
    abool m_bKeepSceneUpright;
    abool m_bCenterPivotOnSelection;
    abool m_bPanZoom;
    abool m_bTiltSpinRoll;

    class MBDLL_DECL Integer
    {
    public:
        Integer( 
            const QString &sName, 
            const QString &sCategory, 
            const QString &sNameTr, 
            const QString &sCategoryTr, 
            unsigned int iDefaultValue, 
            bool bVisible = true 
            );
        operator unsigned int( void ) const;
        aint *m_pAttribute;
    };
    class MBDLL_DECL Bool
    {
    public:
        Bool( const QString &sName, const QString &sCategory, const QString &sNameTr, const QString &sCategoryTr, bool bDefaultValue, bool bVisible = true );
        operator bool( void ) const;
        abool *m_pAttribute;
    };
    class MBDLL_DECL Float
    {
    public:
        Float( const QString &sName, const QString &sCategory, const QString &sNameTr, const QString &sCategoryTr, float fDefaultValue, float fMinimum = 0.0f, float fMaximum = 1.0f, bool bVisible = true );
        operator float( void ) const;
        afloatr *m_pAttribute;
    };
    class MBDLL_DECL String
    {
    public:
        String( const QString &sName, const QString &sCategory, const QString &sNameTr, const QString &sCategoryTr, const QString &sDefaultValue, bool bVisible = true );
        operator QString( void ) const;
        astring *m_pAttribute;
    };
    class MBDLL_DECL Color
    {
    public:
        Color( const QString &sName, const QString &sCategory, const QString &sNameTr, const QString &sCategoryTr, const mudbox::Color &cDefaultValue, bool bVisible = true );
        operator mudbox::Color( void ) const;
        acolor *m_pAttribute;
    };
    class MBDLL_DECL Vector
    {
    public:
        Vector( const QString &sName, const QString &sCategory, const QString &sNameTr, const QString &sCategoryTr, const mudbox::Vector &vDefaultValue, bool bVisible = true );
        operator mudbox::Vector( void ) const;
        avector *m_pAttribute;
    };
    class MBDLL_DECL Enum
    {
    public:
        Enum( const QString &sName, const QString &sCategory, const QString &sNameTr, const QString &sCategoryTr, int iDefaultValue, bool bVisible = true );
        operator int( void ) const;
        aenum *m_pAttribute;
    };

    private:
        QDir m_PreferencesPath;
        ClassDesc *m_pSelectedMeshRenderer;
};

}; // end of namespace mudbox