MapExtractorInterface.h

Go to the documentation of this file.

#ifndef __MAPEXTRACTORINTERFACE_H
#define __MAPEXTRACTORINTERFACE_H

#include <QtGui/QComboBox>

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

class TextureExtractionDialog;
class Mapper;

namespace mapextractionmodules
{

#ifndef COMPILING_MAPEXTRACTOR_DLL
#define MEDLL MUDBOX_DLLIMPORT
#else
#define MEDLL MUDBOX_DLLEXPORT
#endif

class MEDLL MapExtractor : public mudbox::TreeNode
{
    DECLARE_CLASS;
    
    virtual void SetTargetCount( unsigned int iTargetCount );
    virtual void SetTargetMesh( 
        unsigned int iTargetIndex, 
        mudbox::SubdivisionLevel *pTarget 
        );
    
    virtual unsigned int TargetCount( void ) const;
    virtual mudbox::SubdivisionLevel *TargetMesh( unsigned int iMeshIndex ) const;
    virtual unsigned int CurrentTarget( void ) const;
    virtual mudbox::SurfaceSmoother *CurrentTargetSmoother( void ) const;
    virtual bool IsCurrentTargetAClone( void ) const;
    
    virtual unsigned int SourceCount( void ) const;
    virtual mudbox::SubdivisionLevel *SourceMesh( unsigned int iIndex ) const;
    virtual void SetSourceCount( unsigned int iMeshCount );
    virtual void SetSourceMesh( unsigned int iIndex, mudbox::SubdivisionLevel *pSource );

    virtual unsigned int SamplerCount( void ) const;
    virtual class Sampler *SamplerByIndex( int iIndex ) const;
    virtual class Sampler *SamplerByName( const QString &sSamplerName ) const;
    virtual class Sampler *SamplerByClass( const mudbox::ClassDesc *, int iIndex = 0 );
    virtual class Sampler *SamplerByClassName( const QString &sClassName, int iIndex = 0 );

    virtual unsigned int LocationCount( void ) const;
    virtual void TargetLocation( unsigned int iIndex, class TargetLocation *pLocation ) const;
    virtual void SourceLocation( unsigned int iIndex, mudbox::SurfacePoint *pLocation ) const;
    
    virtual bool SourceSmoothing( void ) const;
    virtual bool TargetUVSmoothing( void ) const;
    virtual bool TargetSmoothing( void ) const;
    virtual void SetSmoothing( bool bTargetSmoothing, bool bSourceSmoothing, bool bTargetUVSmoothing = false );
    virtual bool SourceCreases( void ) const;
    virtual void SetSourceCreases( bool bOn );
    virtual bool AddProgress( int iProgress );
    
    virtual void SetMapWidth( int iWidth );
    virtual void SetMapHeight( int iHeight );

    virtual class Layout *Layout() const;    
    virtual class Locator *Locator( int iIndex = 0 ) const;

    virtual void RequestTangents( void );
    virtual bool AreTangentsNeeded( void ) const;
    virtual void SetTangentGenerator( mudbox::TangentGenerator *pGenerator );
    virtual mudbox::TangentGenerator *CurrentTangentGenerator( void ) const;

    virtual void SetUtilizerType( const mudbox::ClassDesc *pUtilizerType );
    virtual void SetLocatorType( const mudbox::ClassDesc *pLocatorType, int iIndex = 0 );
    
    virtual bool Execute( 
        bool bInterface = true 
        );
    virtual bool SilentMode( void ) const;

    virtual void ValidityChanged( void );

    static bool DeveloperMode( void );
};

//------------------------------------------------------------------------------
class Data
{
    public:
        union {
            int                     m_int[16];
            float                   m_float[16];
            double                  m_double[8];
            // we cant put classes with copy ctors or assignment operators in a union...
        };
        bool                        m_valid;

        Data(void)                        { m_valid = false; };                       
        Data(int                       r) { m_int[0]    = r; m_valid = true; } 
        Data(float                     r) { m_float[0]  = r; m_float[1] = m_float[2] = 0; m_float[3] = 1; m_valid = true; } 
        Data(double                    r) { m_double[0] = r; m_valid = true; } 
        Data(const mudbox::Color      &r) { m_float[0]  = r.m_fRed;  m_float[1] = r.m_fGreen; 
                                            m_float[2]  = r.m_fBlue; m_float[3] = r.m_fAlpha; m_valid = true; } 
        Data(const mudbox::Vector     &r) { m_float[0]  = r.x; m_float[1]  = r.y; m_float[2]  = r.z; m_float[3]  = 1; m_valid = true; } 
        Data(const mudbox::DblVector  &r) { m_double[0] = r.x; m_double[1] = r.y; m_double[2] = r.z; m_double[3] = 1; m_valid = true; }
        Data(const mudbox::Vector4    &r) { m_float[0]  = r.x; m_float[1]  = r.y; 
                                            m_float[2]  = r.z; m_float[3]  = r.w; m_valid = true; } 
        Data(const mudbox::Quaternion &r) { memcpy(m_float, &r.m_fW, sizeof(float) * 4); m_valid = true; } 
        Data(const mudbox::Matrix     &r) { memcpy(m_float, r.m_fData, sizeof(float) * 16); m_valid = true; } 
        bool IsValid( void ) const { return m_valid; }

        int                    As_int        () const { return m_int[0];            }
        float                  As_float      () const { return m_float[0];          }
        double                 As_double     () const { return m_double[0];         }
        mudbox::Color          As_Color      () const { return mudbox::Color(m_float[0], m_float[1], m_float[2], m_float[3]);     }
        mudbox::Vector         As_Vector     () const { return mudbox::Vector(m_float[0], m_float[1], m_float[2]);                }
        mudbox::DblVector      As_DblVector  () const { return mudbox::DblVector(m_double[0], m_double[1], m_double[2]);          }
        mudbox::Vector4        As_Vector4    () const { return mudbox::Vector4(m_float[0], m_float[1], m_float[2], m_float[3]);   }
        mudbox::Quaternion     As_Quaternion () const { mudbox::Quaternion q; memcpy(&q.m_fW, m_float, sizeof(float) * 4); return q; }
        mudbox::Matrix         As_Matrix     () const { mudbox::Matrix m; memcpy(m.m_fData,  m_float, sizeof(float) * 16); return m; }
};


//------------------------------------------------------------------------------
// This is the base class for locators, i.e. nodes which should find surface 
// points on the source mesh to match surface points on the target mesh. The map 
// extractor node always uses one instance of a locator during the extraction 
// process
class MEDLL Locator : public mudbox::Node
{
    DECLARE_CLASS;
public:
    Locator( Mapper *pMapper = 0 ) : m_pMapper( pMapper ) {};
    ~Locator( void ) {};
    virtual void Prepare( void ) {};
    virtual void CleanUp( void ) {};
    virtual bool LocateSurfacePoint( mudbox::SurfacePoint &pPoint, const class TargetLocation &vTarget );
    virtual QWidget *UserInterface( void );
    virtual void Serialize( mudbox::Stream &s );
    virtual bool IsValid( void );
    MapExtractor *Extractor( void ) const;
    void SetMeshes( QVector<mudbox::SubdivisionLevel *> pInputs, QVector<mudbox::SubdivisionLevel *> pOutputs );

    QVector <mudbox::SubdivisionLevel *> m_pInputs, m_pOutputs;
    Mapper *m_pMapper;
private:

    friend class Mapper;
};

class MEDLL SamplerUI : public QObject, public mudbox::Node
{
    Q_OBJECT;
protected:
    SamplerUI( class Sampler *pTarget );
    QWidget *CreateTargetWidget( 
        bool bSmoothing = true, 
        bool bUVSmoothing = true, 
        bool bDefaultToLowest = true, 
        bool bShowLevels = true 
        );
    QWidget *CreateSourceWidget( 
        bool bSmoothing = true 
        );
    QWidget *CreateLocatorWidget( void );
    QWidget *CreateLayoutWidget( void );
    QWidget *CreateOutputWidget( void );
public:
    Mapper *m_pMapper;
    using mudbox::Node::Initialize;
    virtual void Initialize( void );
    virtual QWidget *RootWidget( void );
    virtual void UpdateValues( void );

    TextureExtractionDialog *m_pDialog;
    bool m_bValidData;
    bool m_bDefaultTargetToLowestLevel;
    class Sampler *m_pTarget;
    QLabel *SmallerLabel( const QString& text );
    MapExtractor *Extractor( void ) const;
private slots:
    void OnAddSelectedAsTarget( void );
    void OnAddAllAsTarget( void );
    void OnRemoveTarget( void );
    void OnTargetItemClicked( int row, int column );
    void OnSourceItemClicked( int row, int column );
    void OnSmoothTargetChanged( void );
    void OnSmoothTargetUVChanged( void );
    void OnPreserveCreasesAndHardEdgesChanged( void );
    void OnSmoothSourceChanged( void );
    void OnAddSelectedAsSource( void );
    void OnAddAllAsSource( void );
    void OnRemoveSource( void );
    void OnTargetReordered( int, int, int );
    void OnMapTypeChanged( const QString & );
protected:
    QLabel *m_pLocateSign;
    QWidget *m_pRoot;
private:

    friend class Sampler;
    friend class Mapper;
};

enum PhaseEventType
{
    eventSectionStart,  
    eventSectionEnd,    
    eventQueueFlush,    
    eventQueueLocated,
    eventQueueProcessed,
    eventTargetStart,   
    eventTargetEnd      
};

class MEDLL Layout : public mudbox::Node
{
    DECLARE_CLASS;

    Layout( void ) : m_pMapExtractor( NULL ) {};
    bool ProcessSurfacePoint( const TargetLocation &vLocation );
    void Flush( void );
    void BeginSection( void );
    void EndSection( void );
    virtual void CleanUp( void );
    void Serialize( mudbox::Stream & );

    virtual unsigned int Prepare( void );
    virtual void ProcessSurface( mudbox::SubdivisionLevel *pTarget );
    virtual QWidget *UserInterface( void );
    MapExtractor *Extractor( void ) const { return m_pMapExtractor; };
    MapExtractor *m_pMapExtractor;
private:

    friend class Mapper;
};

class MEDLL Gate : public mudbox::Node
{
    DECLARE_CLASS;
public:
    virtual Data Process( const Data &cData, const mudbox::SurfacePoint &cSource, const TargetLocation &cTarget );
    virtual class Sampler *Sampler( void ) const { return m_pSampler; };
    virtual void Serialize( mudbox::Stream & );
private:
    class Sampler *m_pSampler;

    friend class Sampler;
};

class MEDLL Sampler : public mudbox::Node
{
    DECLARE_CLASS;
    enum Normalization
    {
        eNormNone,      
        eNormFull,      
        eNormKeepZero,
        eNormCustom 
    }; 
    enum Precision
    {
        ePrecByte,      
        ePrecFloat, 
        ePrecFloatOnly  
    };
    struct DataInfo
    {
        DataInfo() : m_eNormalization( eNormNone ), m_fLowerBound( 0 ), m_fUpperBound( 1 ), m_iChannelCount( 3 ), m_ePrecision( ePrecFloat ) {};
        Normalization m_eNormalization; 
        float m_fLowerBound;    
        float m_fUpperBound;    
        int m_iChannelCount;    
        Precision m_ePrecision; 
        QString m_sMaterialChannelName; 
        QString m_sDataName;    
    };
    Sampler( void );
    ~Sampler( void );
    void Serialize( mudbox::Stream & );
    virtual int Prepare( void );
    virtual void CleanUp( void );

    virtual Data ProcessSurfacePoint( const TargetLocation &cTarget, const mudbox::SurfacePoint &cSource );
    virtual SamplerUI *UserInterface( void );
    virtual unsigned int ConfigurationCount( void ) const;
    virtual void SetConfiguration( unsigned int iConfiguration );
    virtual bool IsValid( void );
    virtual void SetupPaintLayer( mudbox::TexturePool *pPaintLayer ) const;
    virtual void OnPhaseEvent( PhaseEventType eType );
    virtual Data DefaultData( void ) const;
    virtual struct DataInfo DataInfo( void ) const;
    virtual void AddGate( Gate *pGate );
    // Remove all gates added to the sampler.
    virtual void RemoveAllGates( void );

    class Utilizer *Utilizer( void ) const { return m_pUtilizer; };

    void SetEnabled( bool bOn );
    bool IsEnabled( void ) const { return m_bEnabled; };

    MapExtractor *Extractor( void ) const { return m_pMapExtractor; };
    Mapper *m_pMapper;
    class MapExtractor *m_pMapExtractor;
    class Utilizer *m_pUtilizer;
    QVector<Gate *> m_aGates;

private:

    mudbox::abool m_bEnabled;
    friend class Mapper;
};

class MEDLL TargetLocation : public mudbox::SurfacePoint
{
public:
    enum Flags
    {
        flagMirrorX = 1,
        flagMirrorY = 2,
        flagMirrorZ = 4,
        flagLocalMirror = 8
    };

    float m_fDiameter;
    int m_aLayoutData[16];
    unsigned int m_iReferenceFaceIndex;
    float m_fReferenceFaceU, m_fReferenceFaceV;
    unsigned int m_iIndex;
    mutable unsigned int m_iFlags;
    mudbox::Base m_bTangent;

    TargetLocation( void ) : m_fDiameter( 1.0f ), m_iReferenceFaceIndex( 0xffffffff ), m_fReferenceFaceU(0), m_fReferenceFaceV(0), m_iIndex(0xffffffff), m_iFlags( 0 ) {};
    TargetLocation( class mudbox::Mesh *pMesh, unsigned int iVertexIndex, unsigned int iFaceIndex ) : 
        SurfacePoint( pMesh, iVertexIndex, iFaceIndex ), m_fDiameter( 1.0f ), m_iReferenceFaceIndex( 0xffffffff ), 
        m_fReferenceFaceU(0), m_fReferenceFaceV(0), m_iIndex(0xffffffff), m_iFlags( 0 ) {}; 

    void Fill( 
        class mudbox::Mesh *pMesh, 
        unsigned int iFaceIndex, 
        float fFaceU, 
        float fFaceV, 
        float fDiameter = 1.0f 
        );
    void FillUsingUV( 
                     class mudbox::Mesh *pMesh, 
                     unsigned int iFaceIndex,           
                     float fU,                                  
                     float fV,                                  
                     mudbox::SurfaceSmoother *pSS = NULL,
                     float fDiameter = 1.0f             
                     );

    void FillNSided(
        class mudbox::Mesh *pMesh,  
        unsigned int iFaceIndex,            
        const mudbox::Vector &vPosition,
        float fDiameter = 1.0f              
        );

    void AddFlag( Flags eFlagToAdd ) const { m_iFlags |= eFlagToAdd; };

    void CalculateSmoothData( const MapExtractor * );
    mudbox::Base TangentBase( void ) const { return m_bTangent; };

private:
    bool RefineFaceIndex( void );
    float RefineFaceCoordinates( const mudbox::SurfaceSmoother *pSS, float fTargetU, float fTargetV, unsigned int iSteps );
};

class MEDLL Utilizer : public mudbox::Node
{
    DECLARE_CLASS;
    Utilizer( void ) : m_pSampler( 0 ) {};
    virtual QString MapTypeName( void ) const;
    virtual void OnPhaseEvent( PhaseEventType eType );
    virtual bool IsValid( void );
    virtual void CleanUp( void );
    virtual void Prepare( Layout *pLayout, class Sampler *pSampler );
    // This function is called every time when a new data is calculated by the associated sampler of the utilizer.  Usually the utilizer obtains additional data
    // from the cTarget objects, which is able to hold generic data from the layout (m_aLayoutData). The utilizer should know the current layout type, so it 
    // knows how to interpret the data stored in that area. This function must be thread safe.
    virtual void StoreData( 
        const Data &cData, 
        const TargetLocation &cTarget, 
        const mudbox::SurfacePoint &cSource 
        );
    virtual QWidget *UserInterface( void );
    virtual Layout *CreateLayout( void );
    virtual void Serialize( mudbox::Stream &s );
    virtual mudbox::Layer *ResultLayer( void ) const;

    class Sampler *Sampler( void ) const { return m_pSampler; };
    MapExtractor *Extractor( void ) const { return Sampler()->Extractor(); };
    class Sampler *m_pSampler;
private:

    friend class Mapper;
};

class MEDLL Mapping : public mudbox::TreeNode
{
    DECLARE_CLASS;
    virtual void Prepare( void );
    virtual void CleanUp( void );
    virtual mudbox::Mesh *Target( void ) const;
    virtual bool MapSurfacePoint( mudbox::SurfacePoint &pPoint, const class TargetLocation &vTarget );
};

};

#endif