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( int iTargetCount );
    virtual void SetTarget( 
        int iTargetIndex, 
        mudbox::SubdivisionLevel *pTarget 
        );
    
    virtual int TargetCount( void ) const;
    virtual mudbox::SubdivisionLevel *TargetMesh( int iMeshIndex ) const;
    virtual int CurrentTarget( void ) const;
    
    virtual unsigned int SourceCount( void ) const;
    virtual mudbox::SubdivisionLevel *Source( unsigned int iIndex ) const;
    virtual void SetSourceCount( unsigned int iMeshCount );
    virtual void SetSource( unsigned int iIndex, mudbox::SubdivisionLevel *pSource );
    
    virtual int ComponentCount( void ) const;
    virtual class Component *ComponentByIndex( int iIndex ) const;
    virtual class Component *ComponentByName( const QString &sComponentName ) const;
    virtual class Component *ComponentByClassName( const QString &sClassName ) const;

    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 void AddProgress( int iProgress );
    
    virtual void SetMapWidth( int iWidth );
    virtual void SetMapHeight( int iHeight );
    virtual class Layout *Layout() const;    
    virtual class Locator *GetLocator() const;

    virtual void SetTangentGenerator( mudbox::TangentGenerator *pGenerator );
    
    virtual void SetUtilizerType( const mudbox::ClassDesc *pUtilizerType );
    virtual void SetLocatorType( const mudbox::ClassDesc *pLocatorType );
    
    virtual bool Execute( 
        bool bInterface = true 
        );
    virtual bool SilentMode( void ) const;

    virtual void ValidityChanged( void );
};

//------------------------------------------------------------------------------
class Data
{
    private:
        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...
        };

    public:
        Data(int                       r) { m_int[0]    = r; } 
        Data(float                     r) { m_float[0]  = r; } 
        Data(double                    r) { m_double[0] = r; } 
        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; } 
        Data(const mudbox::Vector     &r) { m_float[0]  = r.x; m_float[1]  = r.y; m_float[2]  = r.z; m_float[3]  = 0; } 
        Data(const mudbox::DblVector  &r) { m_double[0] = r.x; m_double[1] = r.y; m_double[2] = r.z; m_double[3] = 0; }
        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; } 
        Data(const mudbox::Quaternion &r) { memcpy(m_float, &r.m_fW, sizeof(float) * 4);    } 
        Data(const mudbox::Matrix     &r) { memcpy(m_float, r.m_fData, sizeof(float) * 16); } 

        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( void ) : m_pMapper( NULL ) {};
    ~Locator( void ) {};
    virtual void Prepare( void ) {};
    virtual bool LocateSurfacePoint( mudbox::SurfacePoint &pPoint, const class TargetLocation &vTarget );
    virtual QWidget *UserInterface( void );
    virtual void Serialize( mudbox::Stream &s );
    class MapExtractor *MapExtractor( void ) const;

    Mapper *m_pMapper;
};

class MEDLL ComponentUI : public QObject, public mudbox::Node
{
    Q_OBJECT;
protected:
    ComponentUI( class Component *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:
    using mudbox::Node::Initialize;
    virtual void Initialize( void );
    virtual QWidget *RootWidget( void );
    virtual void UpdateValues( void );

    TextureExtractionDialog *m_pDialog;
    Mapper *m_pMapper;
    bool m_bValidData;
    bool m_bDefaultTargetToLowestLevel;
    class Component *m_pTarget;
    QLabel *SmallerLabel( const QString& text );
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:
    QComboBox *m_pLocateMethod;
};

enum PhaseEventType
{
    eventSectionStart,  
    eventSectionEnd,    
    eventQueueFlush,    
    eventQueueLocated,

    eventQueueProcessed
};

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

    Layout( void ) : m_pMapExtractor( NULL ) {};
    void 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 );
public:
    MapExtractor *m_pMapExtractor;
};

class MEDLL Component : 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;    

    };
    Component( void );
    void Serialize( mudbox::Stream & );
    virtual int Prepare( void );
    virtual void CleanUp( void );

    virtual Data ProcessSurfacePoint( const TargetLocation &cTarget, const mudbox::SurfacePoint &cSource );
    virtual ComponentUI *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;

public:
    mudbox::abool m_bEnabled;
    Mapper *m_pMapper;
    class MapExtractor *m_pMapExtractor;
    class Utilizer *m_pUtilizer;
};

class MEDLL TargetLocation : public mudbox::SurfacePoint
{
public:
    float m_fDiameter;
    int m_aLayoutData[16];
    unsigned int m_iReferenceFaceIndex;
    float m_fReferenceFaceU, m_fReferenceFaceV;
    unsigned int m_iIndex;
    mudbox::Base m_bTangent;
    TargetLocation( void ) : m_iReferenceFaceIndex( 0xffffffff ) {};
    TargetLocation( class mudbox::Mesh *pMesh, unsigned int iVertexIndex, unsigned int iFaceIndex ) : SurfacePoint( pMesh, iVertexIndex, iFaceIndex ), m_iReferenceFaceIndex( 0xffffffff ) {};
    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              
        );

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

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

class MEDLL Utilizer : public mudbox::Node
{
    DECLARE_CLASS;
    Utilizer( void ) : m_pComponent( NULL ), m_bEnabled( true ) {};
    virtual QString MapTypeName( void ) const;
    virtual void OnPhaseEvent( PhaseEventType eType );
    virtual bool IsValid( void );
    virtual void CleanUp( void );
    using mudbox::Node::Initialize;
    virtual void Initialize( Layout *pLayout, Component *pComponent );
    // This function is called every time when a new data is calculated by the associated component 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, 
        bool bHit 
        );
    virtual QWidget *UserInterface( void );
    virtual Layout *CreateLayout( void );
    virtual void Serialize( mudbox::Stream &s );

public:
    Component *m_pComponent;
    bool m_bEnabled;
};

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

};

#endif