viewport.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 ViewPortFilter;

struct ViewPortState
{
    Texture *m_pColor;
    Texture *m_pDepth;
    Texture *m_pPosition;
    Texture *m_pNormal;
    Texture *m_pLinearDepth;
    Texture *m_pFaceNormal;
    bool m_bHDRNeeded;
};

class MBDLL_DECL ViewPortFilter : public Layer
{
    DECLARE_CLASS;
public:

    typedef int RequirementValue;
    enum
    {
        eNone = 0,
        eColor = 1,
        eHDR = 2,
        eDepth24 = 4,
//      ePosition16 = 8, // not implemented
        eNormal16 = 16,
        ePosition32 = 32,
//      eNormal32 = 64, // not implemented
        eNormalDepth16 = 128,
//      eNormalDepth32 = 256, // not implemented
        eLinearDepth = 512,
        eFaceNormal = 1024,
    };

    virtual QString StringID( const ClassDesc *pClass = 0 ) const;

    virtual QString DisplayName( void ) const;

    virtual void Initialize(void);

    virtual RequirementValue Requirement( void ) const;

    virtual void Process(
        ViewPortState &sState   
        );

    virtual float Transparency( void ) const;

    virtual void SetTransparency(float fTransparency);

    virtual Layer *Children( void ) const;

    virtual Layer *Next( void ) const;

    virtual Layer *Prev( void ) const;

    virtual class LayerContainer *Container( void ) const;

    void SetVisible(
        bool bVisible  
        );

    virtual void LockCalibration(
        bool bLock  
        );

    bool CalibrationLocked(void);

    class ViewPort *m_pViewPort;

protected:
    bool m_bCalibrationLocked;
};


class MBDLL_DECL ViewPort : public LayerContainer
{
    DECLARE_CLASS;

protected:
    ViewPort( void );
public:

    virtual unsigned int FilterCount( void ) const;

    virtual ViewPortFilter *Filter(
        unsigned int iIndex 
        ) const;

    virtual void AddFilter(
        ViewPortFilter *pFilter 
        );

    virtual void RemoveFilter(
        unsigned int iIndex 
        );

    void LockFilterCalibration(
        bool bLocked 
        );

    virtual void SaveScreenshot(
        const QString &sFileName    
        ) const;

    virtual int Width( void );

    virtual int Height( void );

    class ImagePlaneInterface *ActiveImagePlane();

    virtual float CursorXPosition( void ) const;

    virtual float CursorYPosition( void ) const;

    const SurfacePoint *CursorSurfacePoint( 
         bool bMirrored = false 
         ) const;

    unsigned int LayerCount( void ) const;

    class Layer *Layer(
        unsigned int iLayerIndex    
        ) const;

    void UnlinkLayer(
        class Layer *pLayer 
        );

    class Layer *CreateLayer( void );

    void AddLayer(
        class Layer *pLayer 
        );

    class Layer *ActiveLayer( void ) const;

    void SetActiveLayer(
        class Layer *pLayer 
        );

    ViewPortFilter::RequirementValue ViewPortFilterRequirements( void ) const;

    enum RedrawType
    {
        eFull, 
        eArea, 
        eOverlayOnly 
    };

    void Redraw( 
        RedrawType eType = eFull, 
        float fXStart = 0, 
        float fYStart = 0, 
        float fXEnd = 0, 
        float fYEnd = 0 
        );

    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;

    enum MirrorPlanePreviewMode {
        mppOff = 0,
        mppX,
        mppY,
        mppZ,
        mppLocalX,
        mppLocalY,
        mppLocalZ
    };

    enum MirrorDirectionPreviewMode {
        mdpOff = 0,
        mdpToPositive,
        mdpToNegative
    };

    void SetMirrorPlanePreview(
        MirrorPlanePreviewMode newMode,     
        float offset = 0.0                  
        );

    MirrorPlanePreviewMode MirrorPlanePreview( void ) const;

    float MirrorPlanePreviewOffset( void ) const;

    void SetMirrorDirectionPreview( MirrorDirectionPreviewMode newMode );

    MirrorDirectionPreviewMode MirrorDirectionPreview( void ) const;

    virtual struct ViewPortState ViewPortState( void );

    virtual bool ShowCurves( void ) const;

    static aevent PreRenderEvent;
    
    static aevent FrameEvent;
    
    static aevent EndRenderEvent;
    
    static aevent PostRenderEvent;

    static aevent MouseMoveEvent;

    static aevent LeftMouseButtonPressEvent;

    static aevent LeftMouseButtonReleaseEvent;

    static aevent ContextMenuEvent;

    static aevent SceneRenderEvent;

    static aevent ViewportResizeEvent;

protected:
    virtual Image* RenderRegion( ImgTile bounds, ImgTile region, enum Image::Format eFormat, bool bTiled ) const;
};

}; // end of namespace mudbox