material.h

Go to the documentation of this file.

//**************************************************************************/
// Copyright (c) 2008 - 2010 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: Mudbox Plugin API header -- Material and Texture classes.
// CREATED: October 2008
//**************************************************************************/

namespace mudbox {
//------------------------------------------------------------------------------    
class MBDLL_DECL Material : virtual public TreeNode
{
    DECLARE_CLASS;

    enum VertexDataUsage
    {
        eVDUPosition,    
        eVDUNormal,      
        eVDUTextureCoordinate, 
        eVDUVertexColor, 
        eVDUBoneIndices, 
        eVDUBoneWeights, 

        eVDUTangent,     
        eVDUBinormal,    


        eVDUDirectTextureCoordinate0, 
        eVDUDirectTextureCoordinate1, 
        eVDUDirectTextureCoordinate2, 
        eVDUDirectTextureCoordinate3, 
        eVDUDirectTextureCoordinate4, 
        eVDUDirectTextureCoordinate5, 
        eVDUDirectTextureCoordinate6, 
        eVDUDirectTextureCoordinate7, 


        eVDUNotUsed 
    };

protected:
    Material( void );  

public:
    ~Material();

    virtual bool Activate(
        const Mesh *pMesh,                      
        const AxisAlignedBoundingBox &cUVArea,  

        const Color &cColor = Color::white      
        );
    
    virtual void Deactivate( void );

    virtual float Transparency( void ) const;
    
    virtual void SetTransparency(
        float fTransparency         
        );

    virtual bool TexturesVisible( void ) const;
    
    virtual void SetTexturesVisible(
        bool bVisible   
        );

    virtual bool IsTCNeeded( void ) const;
    
    virtual bool IsTNBNeeded( void ) const;

    virtual unsigned int TextureCount( void ) const;
    
    virtual class TexturePool *Texture(
        unsigned int iTextureIndex      
        ) const;

    virtual void SetTextureTileLive(
        const AxisAlignedBoundingBox &cUVArea,  
        bool bLive,                 
        int iLODDelta = 0       
        );
    
    virtual bool IsTextureTileLive(
        const AxisAlignedBoundingBox &cUVArea   
        );
    
    virtual unsigned int TextureTileCount() const;
    
    virtual AxisAlignedBoundingBox TextureTileArea(
        unsigned int iTileIndex     
        ) const;

    virtual void ActivateUVArea( const AxisAlignedBoundingBox &cArea );

    virtual VertexDataUsage MapVertexData( 
        VertexDataUsage eUsage 

        ) const;
};


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

protected:
    TextureMixer( void );

public:
    virtual unsigned int BlendModeCount( void ) const;
    
    virtual QString BlendModeDisplayName(
        int iBlendMode      
        ) const;

    virtual QString BlendModeName(
        int iBlendMode      
        ) const;

    virtual void SetBlendMode( int iBlendMode ) ;

    virtual void SetLayerCount(
        unsigned int iLayerCount    
        );
    
    virtual void SetLayerData(
        unsigned int iLayerIndex,           
        int iTextureID,                     
        float fTransparency,                
        int iMaskID = 0,                    
        float fMaskTransparency = 1.0f      
        );
    
    virtual void Mix(
        class Texture *d,    
        unsigned int iWidth,        
        unsigned int iHeight,       
        enum Image::Format eFormat  
        );

};

//-----------------------------------------------------------------------------
class MBDLL_DECL TextureTileArray {
    private:
        // this describes a texture tile. It has a pointer to the texture and 
        // a small amount of frequently accessed metadata. This object should 
        // be kept as small as possible, as there will be a 2D, non-sparse 
        // array of these kept my the texture pool. 
        // presently 16 bytes on a 64 bit machine, 12 bytes on a 32 bit machine. 
        class TileDescriptor {  
            public:
                TileDescriptor() : m_TileStateIndex(-1) {}
                int           m_TileStateIndex;    
        };


        float  m_UOrigin, m_VOrigin; // origin (may be negative) in UV space of this array. 
        int    m_USize, m_VSize;     // Size in U and V covered by this tile array

        TileDescriptor *m_Tiles;     // pointer to the tile array - declared as 1D, but
                                     // accessed as a 2D array by tileFromUV

        // given UV coordinates, return the TileDescriptor
        TileDescriptor *tileFromUV(float U, float V) const
        {
            U -= m_UOrigin; V -= m_VOrigin;     // bring to 0 origin
            int u = (int)U, v = (int)V;         // same as floor now that they are positive
            return &m_Tiles[(v * m_USize) + u]; // classic 2D array access math.
        }

        // resize the TileArray to include these UV coordinates.
        void     resizeArrayToInclude(float U, float V);

        // initialize the class.
        void init()
        {
            m_UOrigin, m_VOrigin = 0;  
            m_USize, m_VSize = 0;      
            m_Tiles = NULL;
        }

    public : 

        TextureTileArray()  { init();    }
        ~TextureTileArray() { dropAll(); } 

        float getMinU() const { return m_UOrigin; }
        float getMinV() const { return m_VOrigin; }
        float getMaxU() const { return m_UOrigin + (float)m_USize; }
        float getMaxV() const { return m_VOrigin + (float)m_VSize; }

        void getTotalUVBounds(float &minU, float &minV, float &maxU, float &maxV) const
        {
            minU = m_UOrigin; 
            minV = m_VOrigin; 
            maxU = minU + (float)m_USize;
            maxV = minV + (float)m_VSize;
        }

        bool contains(float U, float V) const
        {
            return m_Tiles && U >= getMinU() && U < getMaxU() && V >= getMinV() && V < getMaxV();
        }


        int getTileStateIndex(float U, float V) const 
        {
            if (!contains(U, V)) return -1; else
            return tileFromUV(U, V)->m_TileStateIndex;
        }

        void setTileStateIndex(float U, float V, int indx) 
        {
            if (!contains(U, V)) resizeArrayToInclude(U, V);
            tileFromUV(U, V)->m_TileStateIndex = indx;
        }


        void dropAll();

        void clearTileStateIndices(); 
};


//-----------------------------------------------------------------------------
class MBDLL_DECL TexturePool : virtual public Node
{
    DECLARE_CLASS;

protected:
    TexturePool( void );

    TextureTileArray     m_TextureTileArray;

public:

    enum RenderMode
    {
        renderModeConstantColor,
        renderModeTexture,
        renderModeVertexColor
    };

    enum Location
    {
        locationUnknown,
        locationGPU,
        locationCPU,
        locationDisk
    };

    enum Usage
    {
        usagePaintLayer,
        usageLayerMask,
        usageAdjustmentLayer,
        usageUnknown
    };

    virtual enum Usage Usage() const;

    virtual void SetUsage( enum Usage eUsage );

    virtual QString Name( void ) const;
    
    virtual void SetName(
        const QString &sName    

        );
    
    virtual unsigned int RenderMode( void ) const;
    
    virtual void SetRenderMode( unsigned int iMode );
    
    virtual void SetLocation( unsigned int iLocation );
    
    virtual unsigned int Location( void ) const;
    
    virtual TexturePool &operator =( TexturePool &cT );

    virtual int Width( void ) const;
    
    virtual void SetWidth( int iWidth );
    
    virtual void SetFileName(
        const QString &sFileName        
        );
    
    virtual const QString& FileName( void ) const;
    
    virtual void Save(
        const QString &sFileName = "",  
        const QString &sFormat = "",    


        Material *m = NULL,             
        bool bForced = false            
        );          

    virtual void Export(
        const QString &sFileName,       
        const QString &sFormat = "",        


        Material *m = NULL             
        );

    virtual void SetDirty(
        bool bDirty     
        );
    
    virtual bool IsDirty( void ) const;
    
    virtual void AddToDirtyArea( 
        const Vector &cPoint    
    );

    virtual void Reload( void );
    
    virtual void SetContentChanged( void );
    
    virtual bool IsContentChanged( void );

    virtual unsigned int TileCount( void ) const;
    
    virtual class Texture *Tile(
        unsigned int iTileIndex     
        );
    
    virtual class Texture *Tile(
        const AxisAlignedBoundingBox &cTCArea,  
        bool bAlloc = true                      

        );

    virtual class Texture *Tile(float U, float V, bool bAlloc = true);
    
    virtual AxisAlignedBoundingBox TileArea(
        unsigned int iTileIndex     
        ) const;

    TextureTileArray  *getTextureTileArray() { return &m_TextureTileArray; }
    
    virtual TextureMixer *Mixer( void ) const;
    
    virtual int BlendMode( void ) const;
    
    virtual void SetBlendMode(
        int iMode       

        );

    virtual void SetMaterial(
        Material* pMaterial 
        );

    virtual Material *GetMaterial() const; 

    // Internal use only.
    virtual TexturePool *Buffer( void ) const;

    virtual qint64 GPUMemoryUsageInBytes( void ) const;
};

//-----------------------------------------------------------------------------
class MBDLL_DECL Texture : virtual public Node
{
    Q_DECLARE_TR_FUNCTIONS(Texture);
    DECLARE_CLASS;

protected:
    Texture( void );

public:
    virtual void Create(
        unsigned int iWidth,            
        unsigned int iHeight,           
        unsigned int iChannelCount,     
        enum Image::Format eFormat,     
        const Color &cColor             
        );
    
    virtual void Create(
        unsigned int iWidth,            
        unsigned int iHeight,           
        unsigned int iChannelCount,     
        enum Image::Format eFormat      
        );
    
    virtual bool CreateFromFile(
        const QString &sFileName        
        );
    
    virtual const Image *AsImage( void );

    virtual void CopyTo(
        Texture &cTexture       
        ) const;

    virtual unsigned int Width( void ) const;
    
    virtual unsigned int Height( void ) const;
    
    virtual unsigned int BitDepth( void ) const;
    
    virtual enum Image::Format Format( void ) const;

    virtual bool Activate( void ) const;
    
    virtual bool Deactivate( void ) const;

    virtual unsigned int OpenGLName( void ) const;

    virtual bool SetAsRenderTarget( void );
    
    virtual bool RestoreRenderTarget( void );

    virtual abool *getFilteringPref();

    virtual void CopyFrom(
        Image *pImage       
        );

    virtual void ReplaceWith(
        Image *pImage       
        );
    
    virtual void CopyTo(
        Image *pImage,                  
        bool tiled = true,              
        const ImgTile *region = 0,      
        ImageDescriptor::MemoryChannelOrder eOrder = ImageDescriptor::orderRGBA     

        );

    virtual void SetLocation( 
        unsigned int iLocation      

        );
    
    virtual unsigned int Location( void ) const;

    virtual int64 TotalMemoryUsage( void ) const;

    virtual qint64 GPUMemoryUsageInBytes() const;

    virtual void SetLive(
        bool bLive
        );
    
    virtual bool IsLive( void ) const;



        virtual bool NewVersion();                                      

        virtual bool PrevVersion();

        virtual bool NextVersion();

        virtual int  NumVersions();

        virtual bool MergeOldestVersions();

        virtual bool PurgeNewerVersions();

        virtual bool PurgeAllButCurrentVersion();

        virtual bool BeginUndoableOperation();

        virtual bool EndUndoableOperation();


        virtual void SetFiltered( 
            bool bFiltered 
            );

        virtual void SetConvert32To16bitFloat( 
            bool bConvert 
            );

        virtual void setProxyLevel(unsigned char level);

        virtual unsigned char getProxyLevel() const; 

protected:
    ImgTile   m_DirtyTile;

public:

    virtual bool IsDirty( void ) const;

    virtual void SetDirty( bool bDirty );

    

        void ResetDirtyTile() 
        {
            m_DirtyTile = ImgTile(0, 0, 0, 0);       
        }

        virtual void AddToDirtyTile(
            int x,  
            int y   
            )
        {
            m_DirtyTile.ExpandToInclude(x, y);
        }

        virtual void AddToDirtyTile(
            const ImgTile &t 
            )
        {
            m_DirtyTile.ExpandToInclude(t.x, t.y);
            m_DirtyTile.ExpandToInclude(t.x+t.nx, t.y+t.ny);
        }

        const ImgTile &DirtyTile() const { return m_DirtyTile; }

};


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

    enum Slot
    {
        eSlotColor0 = 0,
        eSlotColor1,
        eSlotColor2,
        eSlotColor3,
        eSlotDepth,
        eSlotCount      // placeholder for last position - not a type of slot
    };

public:
    virtual void DrawTexture( 
        const class Texture *pTexture
        );
    
    virtual bool Attach(
        mudbox::Texture *pTexture,  
        Slot eSlot = eSlotColor0    
        );
    
    virtual void Detach(
        Slot eSlot = eSlotColor0    
        );
    
    virtual mudbox::Texture *Texture(
        Slot eSlot = eSlotColor0    
        ) const;
    
    virtual unsigned int Width( void ) const;
    
    virtual unsigned int Height( void ) const;
    
    virtual void SetSize(
        unsigned int iWidth,
        unsigned int iHeight
        );

    virtual void Activate( void );
    
    virtual void Restore( void );

    virtual void SetMultisampling( bool bMultisampling );
};





}; // end of namespace mudbox