MapExtractorAPI.h

Go to the documentation of this file.

#if defined(JAMBUILD)
#include <Mudbox/mudbox.h>
#include <MapExtractor/MapExtractorInterface.h>
#else
#include "../../include/Mudbox/mudbox.h"
#include "../../include/MapExtractor/MapExtractorInterface.h"
#endif

#ifndef COMPILING_MAPEXTRACTORAPI_DLL
#define MEADLL MUDBOX_DLLIMPORT
#else
#define MEADLL MUDBOX_DLLEXPORT
#endif

namespace mapextraction
{
    MEADLL class Extractor CreateNewOperation( void );
    MEADLL int OperationCount( void );
    MEADLL class Extractor OperationByIndex( int iIndex );

    enum UtilizerType
    {
        utilTexture,    
        utilPtex,           
        utilVertex,     

        utilUnknown
    };

    enum LocateMethod
    {
        locRaycast, 

        locSubdivision, 

        locCustom,  

        locUnknown
    };

    enum Space
    {
        spaceWorld,         
        spaceObject,            
        spaceTangent,       


        spaceRawTangent,    

        spaceNormal,            
        spaceUnknown        
    };

    enum VertexAction
    {
        vaVertexColor,      
        vaMove,             
        vaDisplace,         
        vaFreeze,               
        vaSculptLayerMask,
        vaUnknown
    };

    enum Antialiasing
    {
        aaOff,
        aa2X,
        aa4X,
        aa6X,
        aa8X,
        aaUnknown
    };

    enum Sampling
    {
        sampleFurthestOutside,  
        sampleFurthestInside,       
        sampleClosesToTarget,   
        sampleUnknown
    };

    enum Quality
    {
        qualFastest,
        qualFast,
        qualNormal,
        qualGood,
        qualBest,
        qualUnknown
    };

    enum Resolution
    {
        res256,
        res512,
        res1024,
        res2048,
        res4096,
        resUnknown
    };

    enum Compatibility
    {
        compMaya,
        compMax,
        compUnknown
    };

    class MEADLL Component
    {
    protected:
        Component( void );
        mudbox::aptr<mapextractionmodules::Component> m_pComponent;

    public:
        inline bool IsEnabled( void ) const { return m_pComponent->m_bEnabled; };
        inline void SetEnabled( bool bEnable ) { m_pComponent.CheckValidity(); m_pComponent->m_bEnabled = bEnable; m_pComponent->m_pMapExtractor->ValidityChanged(); };

        enum VertexAction VertexAction( void ) const;
        void SetVertexAction( enum VertexAction eAction );
        QString FileName( void ) const;
        void SetFileName( const QString &sFileName );
        bool Preview( void ) const;
        void SetPreview( bool bEnable );
        Space VertexMoveSpace( void ) const;
        void SetVertexMoveSpace( Space eSpace );
        // Returns the multiplier used for vertex based extraction. This is only valid if utilizer type is set to vertex.
        mudbox::Vector VertexFactor( void ) const;
        // Sets the multiplier used for vertex based extraction. This is only valid if utilizer type is set to vertex.
        void SetVertexFactor( const mudbox::Vector &vFactor );
        // Returns the offset used for vertex based extraction. This is only valid if utilizer type is set to vertex.
        mudbox::Vector VertexOffset( void ) const;
        // Sets the offset used for vertex based extraction. This is only valid if utilizer type is set to vertex.
        void SetVertexOffset( const mudbox::Vector &vOffset );
        QString LayerNameForVertexAction( void ) const;
        void SetLayerNameForVertexAction( const QString &sLayerName );

        friend class Extractor;
    };

    class MEADLL DisplacementComponent : public Component
    {
    public:
        bool NormalizeToSearchDistance( void ) const;
        void SetNormalizeToSearchDistance( bool bNormalize );
    };

    class MEADLL VectorDisplacementComponent : public DisplacementComponent
    {
    public:
        enum Space Space( void ) const;
        void SetSpace( enum Space eSpace );
    };

    class MEADLL NormalComponent : public Component
    {
    public:
        enum Space Space( void ) const;
        void SetSpace( enum Space eSpace );
        bool Smooth( void ) const;
        void SetSmooth( bool bSmooth );
        enum Compatibility Compatibility( void ) const;
        void SetCompatibility( enum Compatibility eCompatibility );
    };

    class MEADLL AmbientOcclusionComponent : public Component
    {
    public:
        enum Quality Quality( void ) const;
        void SetQuality( enum Quality eQuality );
        Resolution ShadowMapResolution( void ) const;
        void SetShadowMapresolution( Resolution eResolution );
        float ShadowDarkness( void ) const;
        void SetShadowDarkness( float fDarkness );
        float ShadowContrast( void ) const;
        void SetShadowContrast( float fContrast );
        float Filter( void ) const;
        void SetFilter( float fFilter );
    };

    class MEADLL PaintLayerScanComponent : public Component
    {
    public:
        QString ChannelName( void ) const;
        void SetChannelName( const QString &sChannelName );
        int LayerIndex( void ) const;
        void SetLayerIndex( int iIndex );
    };

    class MEADLL SculptLayerScanComponent : public Component
    {
    public:
        QString Layer( void ) const;
        void SetLayer( const QString &sLayerName );
    };

    class MEADLL Extractor
    {
        Extractor( void );
        mudbox::aptr<mapextractionmodules::MapExtractor> m_pMapExtractor;
        bool m_bOwn;
    public:
        ~Extractor( void );
        int SourceCount( void ) const;
        mudbox::SubdivisionLevel *Source( int iIndex ) const;
        void SetSourceCount( int iCount );
        void SetSource( int iIndex, mudbox::SubdivisionLevel *pSource );
        bool SourceSmoothing( void ) const;
        void SetSourceSmoothing( bool bSourceSmoothing );

        int TargetCount( void ) const;
        mudbox::SubdivisionLevel *Target( int iIndex ) const;
        void SetTargetCount( int iCount );
        void SetTarget( int iIndex, mudbox::SubdivisionLevel *pTarget );
        bool TargetSmoothing( void ) const;
        void SetTargetSmoothing( bool bTargetSmoothing );
        bool TargetUVSmoothing( void ) const;
        void SetTargetUVSmoothing( bool bSmoothUV );
        bool TargetCreases( void ) const;
        void SetTargetCreases( bool bUse );

        // layout
        enum UtilizerType UtilizerType( void ) const;
        void SetUtilizerType( enum UtilizerType eUtilizerType );
        int MapWidth( void ) const;
        int MapHeight( void ) const;
        void SetMapWidth( int iWidth );
        void SetMapHeight( int iHeight );
        enum Antialiasing Antialiasing( void ) const;
        void SetAntialiasing( enum Antialiasing eAntialiasing );
        int EdgeBleeding( void ) const;
        void SetEdgeBleeding( int iPixels );

        // components
        class DisplacementComponent DisplacementComponent( void ) const;
        class VectorDisplacementComponent VectorDisplacementComponent( void ) const;
        class NormalComponent NormalComponent( void ) const;
        class AmbientOcclusionComponent AmbientOcclusionComponent( void ) const;
        class PaintLayerScanComponent PaintLayerScanComponent( void ) const;
        class SculptLayerScanComponent SculptLayerScanComponent( void ) const;

        // locate
        enum LocateMethod LocateMethod( void ) const;
        void SetLocateMethod( enum LocateMethod eLocateMethod );
        enum Sampling Sampling( void ) const;
        void SetSampling( enum Sampling );
        float SearchDistance( void ) const;
        void SetSearchDistance( float fSearchDistance );
        bool TestBothSides( void ) const;
        void SetTestBothSides( bool bBothSides );
        bool PickLowestLevel( void ) const;
        void SetPickLowestLevel( bool bPickLowest );

        bool Execute( bool bInterface = true );

        friend MEADLL Extractor CreateNewOperation( void );
        friend MEADLL Extractor OperationByIndex( int );
    };
};