kernel.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
//**************************************************************************/

namespace mudbox { 

class MBDLL_DECL FileEventNotifier : public Node
{
    DECLARE_CLASS;

    enum Type
    {
        typeBrowseForRead,
        typeBrowseForWrite,
        typePreRead,
        typePostRead,
        typePreWrite,
        typePostWrite
    } m_eType;
    QString m_sFileName;
};

class MBDLL_DECL KeyboardEventNotifier : public Node
{
    DECLARE_CLASS;

    enum Type
    {
        ePressed,
        eReleased
    } m_eType;
    int m_iKey;
    int m_iModifiers;
};

//-----------------------------------------------------------------------------
class MBDLL_DECL TextureUnprojector : public Node
{
    DECLARE_CLASS;

public:
    virtual Texture*  DoUnproject(int xSize, int ySize, bool want16BitFP = false);
};

//-----------------------------------------------------------------------------

class Operation;
class XRef;

class MBDLL_DECL Kernel : public Node
{
    Q_DECLARE_TR_FUNCTIONS(mudbox::Kernel);
    DECLARE_CLASS;
    class XRef* m_pXRef;
public:
    enum MessageBoxType
    {
        msgInformation,
        msgWarning,
        msgQuestion,
        msgError
    };
    enum MessageBoxButton
    {
        buttonNone      = 0x00000000,
        buttonOk        = 0x00000400,
        buttonCancel    = 0x00400000,
        buttonClose     = 0x00200000,
        buttonYes       = 0x00004000,
        buttonYesToAll  = 0x00008000,
        buttonNo        = 0x00010000,
        buttonNoToAll   = 0x00020000,
        buttonAbort     = 0x00040000,
        buttonRetry     = 0x00080000,
        buttonIgnore    = 0x00100000,
        buttonHelp      = 0x01000000
    };
    enum HUDMessageType
    {
        HUDmsgPin,      
        HUDmsgFade      
    };

    enum StatusType
    {
        stNormal,       
        stWarning,      
        stError         
    };

    static QString menuFile;
    static QString menuEdit;
    static QString menuCreate;
    static QString menuCurves;
    static QString menuDisplay;
    static QString menuHelp;
    static QString menuPlugins;
    static QString menuMesh;
    static QString menuRender;
    static QString menuScripts;
    static QString menuMaps;
    static QString menuWindows;

    Kernel( void ); 

    void Log(const QString &sMessage);
    
    void LogMemoryStatus(
        bool bCompact = true    
        );
    
    void LogMemoryBlocks(
        float fSizeLimit = 0.01  
        );
    
    int MessageBox(
        MessageBoxType iType,   
        const QString &sTitle,  
        const QString &sText,   
        int iButtons = buttonNone,  
        int iDefaultButton = buttonNone 
        );

    int OneTimeMessageBox (
        MessageBoxType iType,   
        const QString &sTitle,  
        const QString &sText,   
        int buttons = 0  
        );

    void HUDMessageShow(
        const QString &sMessage, 
        HUDMessageType iType    
        );
        
    void HUDMessageHide();
    
    void SetStatus(
        StatusType iType,   
        const QString& sMsg 
        );

    void AddClassMenuItem(
        const QString &sMenu,           
        const QString &sSubmenu,        
        const ClassDesc *pClass,        
        const QString &sCreatorText,    
        const int &index = -1,          
        const int &subindex = -1,       
        const bool addSeparator = false 
        );

    void AddCallbackMenuItem(
        const QString &sMenu,       
        const QString &sSubmenu,        
        const QString &sItemName,   
        void (*pCallback)(),        
        const QString &sID = "",    
        const int &index = -1,      
        const int &subindex = -1,   
        const bool addSeparator = false 
        );

    void AddLayerCallbackMenuItem(
        Interface::LayerUIType ltType,
        const QString &sItemName,
        void (*pCallback)()
        );

    Mesh *CreateMesh(
        Topology::FaceType eType    
        );

    void ProgressStart(
        const QString &sDescription,        
        unsigned int iMaxValue          
        );
    
    void ProgressSet(
        unsigned int iValue     
        );
    
    void ProgressAdd( void );
    
    void ProgressEnd( void );
    
    bool ProgressIsCancelRequested( void );

    QString LoadFileDialog(
        const QString &sTitle,  
        const QString &sPath,   
        const QString &sFilter  
        ) const;
    
    QString SaveFileDialog(
        const QString &sTitle,          
        const QString &sPath,           
        const QString &sFilter,         
        bool bAskForOverwrite = true,   
        QString* sSelectedFilter = 0        
        ) const;

    QString GetDirectoryDialog(
        const QString &sTitle,  
        const QString &sPath    
        ) const;

    QStringList LoadFilesDialog(
        const QString &sTitle,  
        const QString &sPath,   
        const QString &sFilter  
        ) const;

    void WaitCursorStart( void );
    
    void WaitCursorEnd( void );

    // Automation

    void RecordCommand( const QString &sCommand );

    astring NextCommand;

    class Scene *CreateDefaultScene( void );

    // plugin management
    const ClassDesc *PreferredDescendant(
        const ClassDesc *pClass     //< [in] The ClassDesc of a base class (obtained via the StaticClass() function:  myClass::StaticClass() )
        ) const;
    
    Node *CreateClassInstance( const ClassDesc *pClass ) const;

    Image *LoadImage(
        const QString &sFileName        
        ) const;

    void GLCheckError(
        const char *sSourceFileName,    
        const char *sFunctionName,      
        unsigned int iLine              
        ) const;
    
    void GLCheckStates(
        const char *sSourceFileName,    
        const char *sFunctionName,      
        unsigned int iLine              
        ) const;


    void Redraw( void );

    class Scene *Scene( void ) const;
    
    mudbox::Preferences *Preferences( void ) const;
    
    class mudbox::Interface *Interface( void ) const;

    class Statistics *Statistics( void ) const;
    
    class ViewPort *ViewPort( void ) const;
    
    QWidget *MainWindow( void ) const;

    QString MudboxVersionName( void ) const;

    void AddView(QString className, QString windowTitle, const bool select = false) const;

    void RegisterWindowPlugin(WindowPlugin* plugin) const;

    mudbox::TrayAccessor *TrayAccessor( void ) const;

    bool ExtractArchiveFile(QString sArchiveFilePath, QString sDestPath);
    bool CreateArchiveFile(QString sArchiveFilePath, QStringList files);

    void AddToCreateMeshMenu(QFileInfo fileInfo);
    
    QString DataDirectory( void ) const;

    QString ApplicationDirectory( void ) const;
    
    QString ProjectFilesDirectory( void ) const;
    
    QString SafeWritableDirectory( void ) const;
    
    QString PluginDirectory( const QString& pluginName ) const;
    
    bool IsTestModeOn( void ) const;
    
    bool IsBetaVersion( void ) const;

    void RefreshUI( void ) const;
    
    enum SceneRenderMode {
        srmNormal = 0,          
        srmFlatTexturesOnBlack, 
        srmFlatTexturesOnWhite, 
        srmFlatNoTextures,      
        srmNoTextures           
    };

    Image *RenderScene(
        const QString &sChannel, 
        int  iWidth,        
        int  iHeight,       
        SceneRenderMode renderMode, 
        enum Image::Format fmt = Image::e8integer, 
        bool bTiledImg = true 
        );

    Image *RenderScene(
        int  iWidth,        
        int  iHeight,       
        SceneRenderMode renderMode, 
        enum Image::Format fmt = Image::e8integer, 
        bool bTiledImg = true 
        );

    Image *RenderScene(
        int  iWidth,          
        int  iHeight,         
        enum Image::Format fmt = Image::e8integer, 
        bool bTiledImg = true 
        ) const;



    Image *ExtractUnprojectedTextures(const QString &sChannel, 
                                      int  iWidth,   
                                      int  iHeight,  
                                      enum Image::Format fmt = Image::e8integer, 
                                      bool bTiledImg = false 
        );

    Image *ExtractUnprojectedTextures(int  iWidth,   
                                      int  iHeight,  
                                      enum Image::Format fmt = Image::e8integer, 
                                      bool bTiledImg = false 
        );

     
    Image *ExtractShadingMap(int iWidth,            
                             int iHeight,           
                             enum Image::Format fmt = Image::e8integer,  
                             bool bTiledImg = false 
        );


    int ViewportWidth() const;
    
    int ViewportHeight() const;

    class XRef* XRef() const; 

    void ReportVideoMemoryUsage(
        qint64 iSize        
        );
    
    qint64 VideoMemoryUsage( void ) const;

    qint64 TotalVideoMemory( void ) const;
    
    bool DoOperation(
        Operation *pOp, 
        bool bMerge = false 
        );

    void FlushUndoQueue();

    aevent PreRenderEvent;
    
    aevent FrameEvent;
    
    aevent StrokeBeginEvent;

    aevent StrokeEndEvent;

    aevent EndRenderEvent;
    
    aevent TangentMirrorUpdateEvent;
    
    aevent GeometryAddedEvent;
    
    aevent GeometryRemovedEvent;

    aevent GeometryAboutToRemovedEvent;

    aevent GeometryTransformedEvent;
    
    aevent LowMemoryEvent;
    
    aevent RestoreMemoryEvent;
    
    aevent PostRenderEvent;

    QString TriggerFileEvent(
        FileEventNotifier::Type eType,      
        const QString &sFileName        
        ) const;

    mutable aptr<FileEventNotifier> FileEvent;
 
    mutable aptr<KeyboardEventNotifier> KeyboardEvent;

    aptr<Node> SelectedNode;

    aptr<BrushOperation> SelectedBrush;

    aptr<Geometry> m_pGeometryToAdd;

    aevent PostUIInitializationEvent;

    aevent PaintSelectionEvent;

    aevent PaintLayerAddedEvent;

    aevent PaintLayerRemovedEvent;

    aevent ScenePreDeletedEvent;
};

MBDLL_DECL Kernel *Kernel( void );

class MBDLL_DECL Timer
{
    int m_iIndex;

public:
    Timer( const char *sName, int &iIndex );
    ~Timer( void );
    static unsigned int Current( void );
    static void ResetAll( void );
    static void LogAll( void );
};


class MBDLL_DECL Statistics
{
public:
    void AddRenderedPolygonCount( unsigned int iPolygonCount );
    int FrameCount( void ) const;
};

template < typename c >
c* CreateInstance( void ) { return dynamic_cast<c *>( Kernel()->CreateClassInstance( c::StaticClass() ) ); };

template < typename c >
class MBDLL_TEMPLATE_DECL Instance
{
    c *m_pObject;

public:
    inline Instance( c* pObject ) : m_pObject( pObject ) {};
    inline Instance( void ) { m_pObject = CreateInstance<c>(); };
    inline ~Instance( void ) { if( m_pObject ) delete m_pObject; };
    inline c *operator ->( void ) { return m_pObject; };
    inline const c *operator ->( void ) const { return m_pObject; };
    inline operator c*( void ) const { return m_pObject; };

    inline c * Release() { c* pTemp = m_pObject; m_pObject = 0; return pTemp; }
};

}; // end of namespace mudbox