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 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:

    Kernel( void ); 

    void Log(const QString &sMessage);
    
    void LogMemoryStatus(
        bool bCompact = true    
        );
    
    void LogMemoryBlocks(
        float fSizeLimit = 0.01  
        );
    
    bool CreateNewScene(); 
    
    // 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,       
        bool tiled = false              
        ) 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;
    
    QString MudboxVersionName( void ) const;

    void RegisterWindowPlugin(WindowPlugin* plugin) const;

    mudbox::TrayAccessor *TrayAccessor( void ) const;

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

    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;


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

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


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


    class XRef* XRef() const; 

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

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

    const QList<class ImageIOHandler *> &ExternalImageIOHandlers();

    void FlushUndoQueue();

    aevent StrokeBeginEvent;

    aevent StrokeEndEvent;

    aevent TangentMirrorUpdateEvent;

    aevent LowMemoryEvent;
    
    aevent RestoreMemoryEvent;
    
    aevent PostUndoRedoEvent;

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

    mutable aptr<FileEventNotifier> FileEvent;
 
    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; }
};

class MBDLL_DECL Utility
{
public:

    static QString SanitizeFileName( 
        const QString& sName  
        );
};

}; // end of namespace mudbox