scene.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 SceneMembershipEventNotifier : public Node
{
    DECLARE_CLASS;

    enum Type
    {
        eAboutToAdd,
        eAdded,
        eAboutToRemove,
        eRemoved
    } m_eType;

    aptr<TreeNode> m_pNode;
};

class MBDLL_DECL Scene : virtual public TreeNode
{
    DECLARE_CLASS;

protected:
    Scene( void );

public:

    struct MBDLL_DECL LoadData
    {
        enum UpdateFilter
        {
            updateGeometries = 0x00000001,  
            updateCameras = 0x00000002,     
            updateAll = 0xffffffff,         
            updateNone = 0x00000000         
        };

        enum IncludeFilter
        {
            includeGeometries = 0x00000001,             
            includeCameras = 0x00000002,                
            includeMaterials = 0x00000004,              
            includeLights = 0x00000008,                 
            includeCurves = 0x00000010,                 
            includeSelectionSets = 0x00000020,          
            includeTransformationPalettes = 0x00000040, 
            includeAll = 0xffffffff,                    
            includeNone = 0x00000000                    
        };

        int& IncludeFilter() { return m_eIncludeFilter; }

        int& UpdateFilter() { return m_eUpdateFilter; }

        bool& Merge() { return m_bMerge; }

        void AddDiagnosticMessage( const QString& sMessage ) { m_aDiagnosticMessages.push_back( sMessage ); }

        void LogDiagnosticMessages() const;

        LoadData( bool bMerge = false, int eIncludeFilter = includeAll, int eUpdateFilter = updateNone );

        LoadData( int eUpdateFilter, bool bMerge = false );

        static LoadData ByInclude( bool bGeoms, bool bCams, bool bMats, bool bLights, bool bCurves, bool bSets, bool bPalettes );

        static LoadData& ByMerge( bool bMerge = false );

        bool IncludeGeometries() const { return m_eIncludeFilter & includeGeometries; }

        bool IncludeCameras() const { return m_eIncludeFilter & includeCameras; }

        bool IncludeMaterials() const { return m_eIncludeFilter & includeMaterials; }
        
        bool IncludeLights() const { return m_eIncludeFilter & includeLights; }
        
        bool IncludeCurves() const { return m_eIncludeFilter & includeCurves; }
        
        bool IncludeSelectionSets() const { return m_eIncludeFilter & includeSelectionSets; }

        bool IncludeTransformationPalettes() const { return m_eIncludeFilter & includeTransformationPalettes; }

        bool UpdateGeometries() const { return m_eUpdateFilter & updateGeometries; }

        bool UpdateCameras() const { return m_eUpdateFilter & updateCameras; }
        
    private:
        int m_eIncludeFilter; 

        int m_eUpdateFilter;
        
        bool m_bMerge;

        QStringList m_aDiagnosticMessages;
    };

    // Returns a list of strings of all selected items in the Object List
    virtual QStringList SelectedObjectListNames ( void );

    virtual mudbox::CurveBase *ActiveCurve( void ) const;

    virtual void SetActiveCurve( mudbox::CurveBase *curve );

    virtual mudbox::Camera *ActiveCamera( void ) const;

    virtual void SetActiveCamera( mudbox::Camera *camera );

    virtual mudbox::Light *ActiveLight( void ) const;

    virtual unsigned int CameraCount( void ) const;

    virtual unsigned int CurveCount( void ) const;

    virtual unsigned int SelectedCurveCount( void ) const;

    virtual unsigned int LightCount( void ) const;

    virtual unsigned int GeometryCount( void ) const;

    virtual unsigned int SelectedGeometryCount( void ) const;

    virtual mudbox::Camera *AddCamera(
        mudbox::Camera *pCamera     
        );

    virtual mudbox::Light *AddLight(
        mudbox::Light *pLight       
        );

    virtual mudbox::CurveBase *AddCurve(
        mudbox::CurveBase *pCurve,  
        mudbox::Transformation* pTransformation = 0 
        );

    
    virtual void RemoveCurve(
        mudbox::CurveBase *pCurve  
        );

    virtual mudbox::Geometry *AddGeometry(
        mudbox::Geometry *pGeometry,    
        mudbox::Transformation* pTransformation = 0 
        );


    virtual void RemoveGeometry(
        mudbox::Geometry *pGeometry  
        );

    virtual mudbox::Camera *Camera(
        unsigned int iIndex     
        ) const;

    virtual mudbox::Light *Light(
        unsigned int iIndex     
        ) const;

    virtual mudbox::CurveBase *SelectedCurve(
        unsigned int iIndex     
        ) const;

    virtual mudbox::CurveBase *Curve(
        unsigned int iIndex     
        ) const;

    virtual mudbox::Geometry *SelectedGeometry(
        unsigned int iIndex     
        ) const;

    virtual mudbox::Geometry *Geometry(
        unsigned int iIndex     
        ) const;

    virtual AxisAlignedBoundingBox BoundingBox( void ) const;

    virtual void Render(
        bool bSkipMaterials = false     
        ) const;
        
    virtual bool Export(
        const QString &sFileName,       
        bool bSelectedOnly = false      
        );  // export data to an obj file

    virtual bool Load(
        QString sFileName,              
        Scene::LoadData& cData          
        );

    virtual  mudbox::Geometry *Import( 
        Scene::LoadData& cData,             
        QString sFileName = ""              
        );

    virtual bool Save(
        QString sFileName               
        );
        
    mudbox::Geometry *ActiveGeometry() const;
    
    void SetActiveGeometry(
        mudbox::Geometry *geometry  
        ) const;
        
    virtual void SetActivePaintLayer(
        mudbox::Layer* layer    
        );
    
    virtual void SetActiveTexture(
        mudbox::TexturePool* layer  
        );
    
    virtual mudbox::Layer *ActivePaintLayer() const;
    
    virtual mudbox::TexturePool *ActiveTexture() const;
     
    virtual void MakeThumbnail(QImage &image, int iSize = 128);

    virtual QString FileName() const;

    virtual bool Dirty() const;

    virtual void SetDirty( bool bDirty = true );

    Mesh *CreateMesh(
        Topology::FaceType eType    
        );

    static aevent MaterialChangeEvent;

    static aevent ActiveCameraChangeEvent;

    static aptr<mudbox::Geometry> m_pGeometryToAdd;

    static aptr<SceneMembershipEventNotifier> SceneMembershipEvent;

    static aptr<Node> SelectedNode;

    static aevent PaintSelectionEvent;

    static aevent PaintLayerAddedEvent;

    static aevent PaintLayerRemovedEvent;

    static aevent PaintLayerPropertiesChangedEvent;

    static aevent GeometryTransformedEvent;
};

}; // end of namespace mudbox