MapExtractorAPI.h

Go to the documentation of this file.

#ifndef MAPEXTRACTORAPI_H
#define MAPEXTRACTORAPI_H

#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,           
        vaSculptLayer,      
        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 Sampler
    {
    protected:
        Sampler( void );
        mudbox::aptr<mapextractionmodules::Sampler> m_pSampler;

    public:
        Sampler( mapextractionmodules::Sampler *p ) { m_pSampler = p; };
        inline bool IsEnabled( void ) const { return m_pSampler->IsEnabled(); };
        inline void SetEnabled( bool bEnable ) { m_pSampler->SetEnabled( bEnable ); m_pSampler->Extractor()->ValidityChanged(); };

        enum VertexAction VertexAction( void ) const;
        void SetVertexAction( enum VertexAction eAction );
        QString FileName( void ) const;
        void SetFileName( const QString &sFileName );
        bool UseTmpFile( void ) const;
        void SetUseTmpFile( bool bTmp );
        enum mudbox::Image::Format PixelFormat( void ) const;
        void SetPixelFormat( enum mudbox::Image::Format eFormat );
        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 );
        bool RedirectToSculptLayer( void ) const;
        void SetRedirectToSculptLayer( bool bRedirect );
        mudbox::Layer *ResultLayer( void ) const;

        friend class Extractor;
    };

    class MEADLL DisplacementSampler : public Sampler
    {
    public:
        bool NormalizeToSearchDistance( void ) const;
        void SetNormalizeToSearchDistance( bool bNormalize );
    };

    class MEADLL VectorDisplacementSampler : public DisplacementSampler
    {
    public:
        enum Space Space( void ) const;
        void SetSpace( enum Space eSpace );
    };

    class MEADLL NormalSampler : public Sampler
    {
    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 AmbientOcclusionSampler : public Sampler
    {
    public:
        enum Quality Quality( void ) const;
        void SetQuality( enum Quality eQuality );
        enum 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 PaintLayerSampler : public Sampler
    {
    public:
        QString ChannelName( void ) const;
        void SetChannelName( const QString &sChannelName );
        int LayerIndex( void ) const;
        void SetLayerIndex( int iIndex );
        int LayerInGroupIndex( void ) const;
        void SetLayerInGroupIndex( int iIndex );
    };

    class MEADLL SculptLayerSampler : public Sampler
    {
    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( mapextractionmodules::MapExtractor *pExtractor );
        ~Extractor( void );
        mapextractionmodules::MapExtractor *ExtractorObject( void ) { return m_pMapExtractor; };
        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 );

        void SetTangentGenerator( mudbox::TangentGenerator *pTG );

        // 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 );

        // samplers
        class DisplacementSampler DisplacementSampler( int iIndex = 0 );
        class VectorDisplacementSampler VectorDisplacementSampler( int iIndex = 0 );
        class NormalSampler NormalSampler( int iIndex = 0 );
        class AmbientOcclusionSampler AmbientOcclusionSampler( int iIndex = 0 );
        class PaintLayerSampler PaintLayerSampler( int iIndex = 0 );
        class SculptLayerSampler SculptLayerSampler( int iIndex = 0 );
        class Sampler DummySampler( int iIndex = 0 );

        // locate
        enum LocateMethod LocateMethod( int iIndex = 0 ) const;
        void SetLocateMethod( enum LocateMethod eLocateMethod, int iIndex = 0 );
        void SetLocateMeshes( QVector<mudbox::SubdivisionLevel *> aInputs, QVector<mudbox::SubdivisionLevel *> aOutputs, int iIndex = 0 );
        enum Sampling Sampling( int iIndex = 0 ) const;
        void SetSampling( enum Sampling, int iIndex = 0 );
        float SearchDistance( int iIndex = 0 ) const;
        void SetSearchDistance( float fSearchDistance, int iIndex = 0 );
        bool TestBothSides( int iIndex = 0 ) const;
        void SetTestBothSides( bool bBothSides, int iIndex = 0 );
        bool PickLowestLevel( int iIndex = 0 ) const;
        void SetPickLowestLevel( bool bPickLowest, int iIndex = 0 );
        float Tolerance( int iIndex = 0 ) const;
        void SetTolerance( float fTolerance, int iIndex = 0 );

        bool Execute( bool bInterface = true );

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

#endif