MeVisLab/Standard/Sources/ML/MLWEM/WEMBase/WEM.h

Go to the documentation of this file.

// **InsertLicense** code
//----------------------------------------------------------------------------------

#ifndef __WEM_H
#define __WEM_H

#include "MLWEMIncludes.h"
#include "WEMAttributes.h"
#include "WEMPatch.h"
#include "WEMTrianglePatch.h"
#include "WEMQuadPatch.h"
#include "WEMPolygonPatch.h"


ML_START_NAMESPACE


struct WEMEventContainer 
{
  WEMEventContainer() 
  {
    notificationType = WEM_NOTIFICATION_NONE;
    patchId = WEM_PATCH_ID_ALL;

    repaintFaces =
    repaintEdges =
    repaintNodes =
    repaintBoundingBoxes = false;

    selectionWasClicked = false;
    selectionFaceHit    = 0;
    selectionHitPoint.assign(0,0,0);
  }

  int notificationType;
  int patchId;


  bool repaintFaces;          
  bool repaintEdges;          
  bool repaintNodes;          
  bool repaintBoundingBoxes;  


  bool selectionWasClicked;   
  int  selectionFaceHit;      
  Vector3 selectionHitPoint;  
};


typedef void wemNotificationCB(void* data, std::vector<WEMEventContainer> ecList);


// A define that can be used to detect if the WEM is ref counted:
#define ML_WEM_REFCOUNTED 1

// Declare WEMPtr smart pointer
ML_REFCOUNTED_PTR(WEM)







class MLWEM_EXPORT WEM : public RefCountedBase
{
  ML_CLASS_HEADER(WEM)

public:

  WEM();
  WEM(const WEM& wem);

protected:
  virtual ~WEM();

public:

  struct WEMNotificationCBData 
  {
    wemNotificationCB* notificationCB;     
    void* notificationCBData;              
    std::vector<WEMEventContainer> ecList; 
  };


  void clone(const WEM& wem);
  virtual WEM* deepCopy() const;


  void addNotificationObserver(wemNotificationCB* callback, void* userData);
  void removeNotificationObserver(wemNotificationCB* callback, void* userData);
  void notifyObservers(std::vector<WEMEventContainer> ecList);
  static void removeNotificationObserverFromAllWEMs(wemNotificationCB* callback, void* userData);


  unsigned int getCurrentWEMPatchId();
  inline void setCurrentWEMPatchId(unsigned int id) { _currentLastWEMPatchId = id;   }


  void addWEMPatch(WEMPatch* wemPatch);
  WEMTrianglePatch* addWEMPatchCopy(WEMTrianglePatch* wemPatch, bool assignNewId=false);
  WEMQuadPatch* addWEMPatchCopy(WEMQuadPatch* wemPatch, bool assignNewId=false);
  WEMPolygonPatch* addWEMPatchCopy(WEMPolygonPatch* wemPatch, bool assignNewId=false);

  bool removeWEMPatch(WEMPatch* wemPatch);
  bool removeWEMPatch(unsigned int id);
  bool removeAll();
  void clear();


  WEMPatch* getWEMPatchAt(unsigned int index);
  inline const WEMPatch* getWEMPatchAt(unsigned int index) const { return const_cast<WEM*>(this)->getWEMPatchAt(index); }
  WEMPatch* getWEMPatchById(unsigned int id);
  inline const WEMPatch* getWEMPatchById(unsigned int id) const { return const_cast<WEM*>(this)->getWEMPatchById(id); }
  unsigned int getWEMPatchIndex(WEMPatch* wemPatch) const;
  unsigned int getWEMPatchIndex(unsigned int id) const;
  bool hasWEMPatch(WEMPatch* wemPatch) const;


  inline unsigned int getNumWEMPatches() const { return static_cast<unsigned int>(_wemPatchList.size()); }


  inline void enableRepaintObserver()      { _enableRepaintObserver = true;  }
  inline void disableRepaintObserver()     { _enableRepaintObserver = false; }

  inline void enableFinishedObserver()     { _enableFinishedObserver = true;  }
  inline void disableFinishedObserver()    { _enableFinishedObserver = false; }

  inline void enableInteractionObserver()  { _enableInteractionObserver = true;  }
  inline void disableInteractionObserver() { _enableInteractionObserver = false; }

  inline void enableSelectionObserver()    { _enableSelectionObserver = true;  }
  inline void disableSelectionObserver()   { _enableSelectionObserver = false; }


  inline bool isRepaintNotificationEnabled()         const { return _enableRepaintObserver;     }
  inline bool isFinishedNotificationEnabled()        const { return _enableFinishedObserver;    }
  inline bool isInteractionInitNotificationEnabled() const { return _enableInteractionObserver; }
  inline bool isSelectionNotificationEnabled()       const { return _enableSelectionObserver;   }


  inline int getId() const { return _uniqueId; }
  inline std::string getName() const { return _name; }
  inline void setName(std::string name) { _name = name; }
  

  bool loadWEMSurface(const std::string& filename, bool generateEdges=true, ProgressField *progressFld=NULL);
  bool loadWEMSurface(const std::string& filename, int filesize, bool generateEdges=true, ProgressField *progressFld=NULL);
  bool loadWEMSurface(std::istream& instream, int filesize, bool generateEdges=true, ProgressField *progressFld=NULL);
  void saveWEMSurface(const std::string& filename, ProgressField *progressFld=NULL);  
  void saveWEMSurface(std::ostream& outstream, ProgressField *progressFld=NULL);


  bool hasPrimitiveValueListForAllPatches(std::string description) const;
  std::vector<std::string> getRegisteredPrimitiveValueLists() const;
  

  void flatten(WEMTrianglePatch *triPatch, WEMRequirements* requirements, TriangulationModes triangulationMode);

private:    

  void _setIdAndName();

  static int _getUniqueId();

  int _uniqueId;

  std::string _name;

  std::vector<WEMPatch*>_wemPatchList;

  unsigned int _currentLastWEMPatchId;

  std::vector<WEMNotificationCBData>_notificationObservers;

  bool _enableRepaintObserver;
  bool _enableFinishedObserver;
  bool _enableInteractionObserver;
  bool _enableSelectionObserver;


  static int _currentLastId;

  static std::vector<WEM*> _registeredWEMs;

  static void registerWEM(WEM* wem);
  static void deregisterWEM(WEM* wem);
};



ML_END_NAMESPACE


#endif // __WEM_H