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

class CIPModule;

namespace mudbox {
    class MBDLL_DECL Kernel;   // declare Kernel as an incomplete type -- ptrs to it are allowed. 
};

// Now declare a naked C pointer to the Kernel. \b Please to not use this directly. Use the 
// inline function just below it mudbox::Kernel() to get a pointer to the singleton
// instance of the mudbox Kernel class.
extern "C" MBDLL_DECL class mudbox::Kernel *_g_pKernel__DO_NOT_USE_THIS_DIRECTLY_;  


namespace mudbox {

inline MBDLL_DECL class Kernel *Kernel( void )
{
    return ::_g_pKernel__DO_NOT_USE_THIS_DIRECTLY_;
};


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, bool bTranparentBackground = true);
};

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

class Operation;
class XRef;

#define NUM_CRASHFLAGS    (128)

// define module flags...
#define  CRF_COMMAND           0
#define  CRF_MENU_COMMAND      1
#define  CRF_HARDWARE_RENDER   2
#define  CRF_TEXTURE_PAINT     3
#define  CRF_FAST_BRUSH        4
#define  CRF_TEXTURE           5
#define  CRF_IMAGE             6
#define  CRF_SCENE_VIEW        7
#define  CRF_MESH              8
#define  CRF_SUBDIVIDE         9
#define  CRF_TEXTURE_LAYERS   10
#define  CRF_CURVE            11
#define  CRF_PAINT_BUFFER     12
#define  CRF_IBL_MATERIAL     13
#define  CRF_MB_MATERIAL      14
#define  CRF_HW_PICKER        15
#define  CRF_GUI              16
#define  CRF_CAMERA           17
#define  CRF_CAMERA_2         18
#define  CRF_INTERFACE_1      19
#define  CRF_INTERFACE_2      20
#define  CRF_INTERFACE_3      21
#define  CRF_INTERFACE_4      22
#define  CRF_DIALOGS_1        23
#define  CRF_DIALOGS_2        24
#define  CRF_DIALOGS_3        25
#define  CRF_DIALOGS_4        26
#define  CRF_DIALOGS_5        27
#define  CRF_DIALOGS_6        28
#define  CRF_CG_MATERIAL      29
#define  CRF_CG_MATERIAL_2    30
#define  CRF_SCENE_VIEW_2     31
#define  CRF_SCENE            32
#define  CRF_SCENE_2          33
#define  CRF_IMAGE_BASE       34



// define the 32 Power of 2 flags....
#define  CRF_00 ((unsigned int)(1u    ))
#define  CRF_01 ((unsigned int)(1u<< 1))
#define  CRF_02 ((unsigned int)(1u<< 2))
#define  CRF_03 ((unsigned int)(1u<< 3))
#define  CRF_04 ((unsigned int)(1u<< 4))
#define  CRF_05 ((unsigned int)(1u<< 5))
#define  CRF_06 ((unsigned int)(1u<< 6))
#define  CRF_07 ((unsigned int)(1u<< 7))
#define  CRF_08 ((unsigned int)(1u<< 8))
#define  CRF_09 ((unsigned int)(1u<< 9))
#define  CRF_10 ((unsigned int)(1u<<10))
#define  CRF_11 ((unsigned int)(1u<<11))
#define  CRF_12 ((unsigned int)(1u<<12))
#define  CRF_13 ((unsigned int)(1u<<13))
#define  CRF_14 ((unsigned int)(1u<<14))
#define  CRF_15 ((unsigned int)(1u<<15))
#define  CRF_16 ((unsigned int)(1u<<16))
#define  CRF_17 ((unsigned int)(1u<<17))
#define  CRF_18 ((unsigned int)(1u<<18))
#define  CRF_19 ((unsigned int)(1u<<19))
#define  CRF_20 ((unsigned int)(1u<<20))
#define  CRF_21 ((unsigned int)(1u<<21))
#define  CRF_22 ((unsigned int)(1u<<22))
#define  CRF_23 ((unsigned int)(1u<<23))
#define  CRF_24 ((unsigned int)(1u<<24))
#define  CRF_25 ((unsigned int)(1u<<25))
#define  CRF_26 ((unsigned int)(1u<<26))
#define  CRF_27 ((unsigned int)(1u<<27))
#define  CRF_28 ((unsigned int)(1u<<28))
#define  CRF_29 ((unsigned int)(1u<<29))
#define  CRF_30 ((unsigned int)(1u<<30))
#define  CRF_31 ((unsigned int)(1u<<31))

// this is a singleton. Used to create some breadcrumbs in the event of a crash
// so if the stack back-trace is corrupt, we have a chance of reproducing the problem.
class MBDLL_DECL MBCrashInfo
{
    private:
        QString       m_ProgressName;
        unsigned int  m_MaxProgress, m_CurProgress;

        QString       m_CurrentHelp;

        unsigned int  m_FlagArray[NUM_CRASHFLAGS];    // 512 bytes
                                                      
        char          m_RingBuffer[256][256];         // 64k bytes
        int           m_head, m_count, m_total;

    public:
        MBCrashInfo() : m_MaxProgress(0), m_CurProgress(0), m_head(0), m_count(0), m_total(0)
        { memset(m_FlagArray, 0, sizeof(m_FlagArray)); memset(m_RingBuffer, 0, sizeof(m_RingBuffer)); }

        void AddToFlag(int flagNum, unsigned int v)    { m_FlagArray[flagNum] += v;   }
        void SubFromFlag(int flagNum, unsigned int v)  { m_FlagArray[flagNum] -= v;   }
        unsigned int GetFlag(int flagNum) const        { return m_FlagArray[flagNum]; }

        void AddStringToRingBuffer(const QString &prefix, const QString &entry);
        void SetProgressName(const QString &name, unsigned int maxVal) { m_ProgressName = name; m_MaxProgress = maxVal; }
        void SetProgressValue(unsigned int val)                  { m_CurProgress = val; }
        void ClearProgress()                         { m_ProgressName = ""; m_MaxProgress = 0; m_CurProgress = 0; }

        void SetHelpString(const QString &st) { m_CurrentHelp = st; }

        friend class ::CIPModule;
};

typedef QString (*DumpFcnTyp)(void);

class MBDLL_DECL Kernel : public Node
{
    Q_DECLARE_TR_FUNCTIONS(mudbox::Kernel);
    DECLARE_CLASS;
    class XRef* m_pXRef;

    DumpFcnTyp  m_ImageStatsFcn;
    DumpFcnTyp  m_PaintBufferStatsFcn;
    MBCrashInfo m_CrashInfo;

public:

    Kernel( void ); 

    void Log(const QString &sMessage);

    DumpFcnTyp GetImageStatsFcn() const              { return m_ImageStatsFcn;       }
    void       SetImageStatsFcn(DumpFcnTyp f)        { m_ImageStatsFcn = f;          }
    DumpFcnTyp GetPaintBufferStatsFcn() const        { return m_PaintBufferStatsFcn; }
    void       SetPaintBufferStatsFcn(DumpFcnTyp f)  { m_PaintBufferStatsFcn = f;    }

    MBCrashInfo *GetCrashInfo()                      { return &m_CrashInfo; }

    void       SetCrashHelpString(const QString &st) { m_CrashInfo.SetHelpString(st); }
    void AddStringToCrashBuffer(const QString &prefix, const QString &entry)
    { m_CrashInfo.AddStringToRingBuffer(prefix, entry); }

    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;

    QString MudboxBuildID( 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;

    int CommandLineParameterCount( void ) const;

    QString CommandLineParameterName( int iIndex ) const;

    QString CommandLineParameterValue( int iIndex ) 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 ) const;

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



// use an instance this as a local variable to set/clear flags in a 32 bit word
// for the crash reporter I recommend using powers of 2 for the flag value.
// Flag numbers range from 0 to 127 
class MBDLL_DECL MBCrashReporterFlag
{
    private:
        int           m_flagNum; 
        unsigned int  m_v;

    public:
        MBCrashReporterFlag(int flagNum, unsigned int v = 1) : m_flagNum(flagNum), m_v(v)
        { Kernel()->GetCrashInfo()->AddToFlag(flagNum, v); }

        ~MBCrashReporterFlag()
        { Kernel()->GetCrashInfo()->SubFromFlag(m_flagNum, m_v); m_flagNum = 0; m_v = 0; }
};



}; // end of namespace mudbox