DrawModes.hh

/*===========================================================================*\
 *                                                                           *
 *                              OpenFlipper                                  *
 *           Copyright (c) 2001-2015, RWTH-Aachen University                 *
 *           Department of Computer Graphics and Multimedia                  *
 *                          All rights reserved.                             *
 *                            www.openflipper.org                            *
 *                                                                           *
 *---------------------------------------------------------------------------*
 * This file is part of OpenFlipper.                                         *
 *---------------------------------------------------------------------------*
 *                                                                           *
 * Redistribution and use in source and binary forms, with or without        *
 * modification, are permitted provided that the following conditions        *
 * are met:                                                                  *
 *                                                                           *
 * 1. Redistributions of source code must retain the above copyright notice, *
 *    this list of conditions and the following disclaimer.                  *
 *                                                                           *
 * 2. Redistributions in binary form must reproduce the above copyright      *
 *    notice, this list of conditions and the following disclaimer in the    *
 *    documentation and/or other materials provided with the distribution.   *
 *                                                                           *
 * 3. Neither the name of the copyright holder nor the names of its          *
 *    contributors may be used to endorse or promote products derived from   *
 *    this software without specific prior written permission.               *
 *                                                                           *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS       *
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A           *
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,  *
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,       *
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR        *
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF    *
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING      *
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS        *
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.              *
 *                                                                           *
\*===========================================================================*/






//=============================================================================
//
//  CLASS DrawModes
//
//=============================================================================

#ifndef ACG_DRAWMODES_HH
#define ACG_DRAWMODES_HH


//== FORWARD DECLARATIONS =====================================================


namespace ACG 
{
  namespace SceneGraph 
  {
    class BaseNode;
  }
}


//== INCLUDES =================================================================

#include <string>
#include <vector>
#include "../Config/ACGDefines.hh"
#include <bitset>

// Avoid compiler warning in MSC
#if defined (_MSC_VER)
#   pragma warning (disable:4251)
#endif

//== NAMESPACES ===============================================================


namespace ACG {
namespace SceneGraph {

namespace DrawModes {


  enum DrawModeLightStage
  {
    LIGHTSTAGE_UNLIT,  
    LIGHTSTAGE_SMOOTH, 
    LIGHTSTAGE_PHONG   
  };

  enum DrawModePrimitive
  {
    PRIMITIVE_POINT,
    PRIMITIVE_EDGE,
    PRIMITIVE_HALFEDGE,
    PRIMITIVE_WIREFRAME,
    PRIMITIVE_HIDDENLINE,
    PRIMITIVE_POLYGON,
    PRIMITIVE_CELL
  };

  enum DrawModeColorSource
  {
    COLOR_NONE,         
    COLOR_PER_VERTEX,   
    COLOR_PER_EDGE, 
    COLOR_PER_HALFEDGE, 
    COLOR_PER_FACE      
  };

  enum DrawModeTexCoordSource
  {
    TEXCOORD_NONE,         
    TEXCOORD_PER_VERTEX,   
    TEXCOORD_PER_HALFEDGE, 
    //  TEXCOORD_PER_FACE // TODO: discuss texcoords per face? is it useful?
  };

  enum DrawModeNormalSource
  {
    NORMAL_NONE,          
    NORMAL_PER_VERTEX,    
    NORMAL_PER_HALFEDGE,  
    NORMAL_PER_FACE       
  };

  typedef std::bitset<128> ModeFlagSet;

  class ACGDLLEXPORT DrawModeProperties {

  public:
    DrawModeProperties(
      DrawModePrimitive _primitive = PRIMITIVE_POLYGON,
      DrawModeLightStage _lightStage = LIGHTSTAGE_UNLIT,
      DrawModeNormalSource _normalSource = NORMAL_NONE,
      DrawModeColorSource _colorSource = COLOR_NONE,
      DrawModeTexCoordSource _texcoordSource = TEXCOORD_NONE,
      bool _envMapping = false);

    //===========================================================================
    //===========================================================================

    DrawModePrimitive primitive() const { return primitive_; }
    void primitive(DrawModePrimitive _val) { primitive_ = _val; }

    DrawModeLightStage lightStage() const { return lightStage_; }
    void lightStage(DrawModeLightStage _val) { lightStage_ = _val; }

    DrawModeColorSource colorSource() const { return colorSource_; }
    void colorSource(DrawModeColorSource _val) { colorSource_ = _val; }

    DrawModeNormalSource normalSource() const { return normalSource_; }
    void normalSource(DrawModeNormalSource _val) { normalSource_ = _val; }

    DrawModeTexCoordSource texcoordSource() const { return texcoordSource_; }
    void texcoordSource(DrawModeTexCoordSource _val) { texcoordSource_ = _val; }

    //===========================================================================
    //===========================================================================

    bool lighting() const { return lightStage_ != LIGHTSTAGE_UNLIT && normalSource_ != NORMAL_NONE; }

    bool textured() const { return texcoordSource_ != TEXCOORD_NONE; }

    bool colored() const { return colorSource_ != COLOR_NONE; }

    bool flatShaded() const { return normalSource_ == NORMAL_PER_FACE; }
    //===========================================================================
    //===========================================================================

    bool operator!=( const DrawModeProperties& _other ) const {
      return ( (envMapped_      != _other.envMapped_)      ||
               (primitive_      != _other.primitive_)      ||
               (lightStage_     != _other.lightStage_)     ||
               (colorSource_    != _other.colorSource_)    ||
               (texcoordSource_ != _other.texcoordSource_) ||
               (normalSource_   != _other.normalSource_)
              );
    }
    
    bool operator==( const DrawModeProperties& _other ) const {
      return ( (envMapped_      == _other.envMapped_)      &&
               (primitive_      == _other.primitive_)      &&
               (lightStage_     == _other.lightStage_)     &&
               (colorSource_    == _other.colorSource_)    &&
               (texcoordSource_ == _other.texcoordSource_) &&
               (normalSource_   == _other.normalSource_)
              );
    }

  private:

    bool envMapped_;

    DrawModePrimitive primitive_;

    DrawModeLightStage lightStage_;

    DrawModeColorSource colorSource_;

    DrawModeTexCoordSource texcoordSource_;

    DrawModeNormalSource normalSource_;

    // TODO: Shaders

  };

  class ACGDLLEXPORT DrawMode {
    public:
      
      DrawMode();
      DrawMode(const DrawMode &) = default;

      explicit DrawMode(size_t _index);
      
      explicit DrawMode( const ModeFlagSet& _flags );

      /* \brief Returns a registered draw mode based on the description passed or if none could be found the default one.
       *
       * @param _description A description created by description().
       */
      static DrawMode getFromDescription(std::string _description);


      //===========================================================================
      //===========================================================================
      DrawMode & operator= (const DrawMode& _mode) = default;

      bool operator==(const DrawMode& _mode) const;

      DrawMode operator&(const DrawMode& _mode) const;
      
      DrawMode& operator++();
      
      DrawMode& operator|=( const DrawMode& _mode2  );
      
      DrawMode& operator&=( const DrawMode& _mode2  );
      
      bool operator!=( const DrawMode& _mode2  ) const;
      
      DrawMode operator|( const DrawMode& _mode2  ) const;
      
      DrawMode operator^( const DrawMode& _mode2  ) const;
      
      DrawMode operator~( ) const;
      
      operator bool() const;

      //===========================================================================
      //===========================================================================

      void addLayer(const DrawModeProperties* _props); // same as bitwise or operator

      size_t getNumLayers() const;

      const DrawModeProperties* getLayer(unsigned int _i) const;

      bool removeLayer(unsigned int _i);

      bool removeLayer(const DrawModeProperties* _prop);


      int getLayerIndex(const DrawModeProperties* _prop) const;

      size_t getIndex() const;

      void filter( DrawMode _filter );


      void combine( DrawMode _mode );
      
      std::string description() const;
      
      bool isAtomic() const;
      
      bool containsAtomicDrawMode( const DrawMode& _atomicDrawMode ) const;
      
      std::vector< DrawMode > getAtomicDrawModes() const;
      
      size_t maxModes() const;
      

      const DrawModeProperties* getDrawModeProperties() const;

      void setDrawModeProperties(const DrawModeProperties* _props);

      void setDrawModeProperties(const DrawModeProperties& _props);


      bool checkConsistency() const;


      int getLayerIndexByPrimitive(DrawModePrimitive _type) const;


    private:
      ModeFlagSet modeFlags_;

      std::vector<DrawModeProperties> layers_;
  };
  
    
  extern ACGDLLEXPORT DrawMode NONE;
  extern ACGDLLEXPORT DrawMode DEFAULT;
  
  //======================================================================
  //  Point Based Rendering Modes
  //======================================================================
  extern ACGDLLEXPORT DrawMode POINTS;

  extern ACGDLLEXPORT DrawMode POINTS_COLORED;
  extern ACGDLLEXPORT DrawMode POINTS_SHADED;
  
  //======================================================================
  //  Edge Based Rendering Modes
  //======================================================================
  extern ACGDLLEXPORT DrawMode EDGES;

  extern ACGDLLEXPORT DrawMode EDGES_COLORED;
  extern ACGDLLEXPORT DrawMode WIREFRAME;
  
  //======================================================================
  //  Face Based Rendering Modes
  //======================================================================  
  // draw faces
  extern ACGDLLEXPORT DrawMode FACES;

  extern ACGDLLEXPORT DrawMode HIDDENLINE;
  extern ACGDLLEXPORT DrawMode SOLID_FLAT_SHADED;
  extern ACGDLLEXPORT DrawMode SOLID_SMOOTH_SHADED;
  extern ACGDLLEXPORT DrawMode SOLID_PHONG_SHADED;
  extern ACGDLLEXPORT DrawMode SOLID_FACES_COLORED;
  extern ACGDLLEXPORT DrawMode SOLID_POINTS_COLORED;
  extern ACGDLLEXPORT DrawMode SOLID_POINTS_COLORED_SHADED;
  extern ACGDLLEXPORT DrawMode SOLID_ENV_MAPPED;
  extern ACGDLLEXPORT DrawMode SOLID_TEXTURED;
  extern ACGDLLEXPORT DrawMode SOLID_TEXTURED_SHADED;
  extern ACGDLLEXPORT DrawMode SOLID_1DTEXTURED;
  extern ACGDLLEXPORT DrawMode SOLID_1DTEXTURED_SHADED;
  extern ACGDLLEXPORT DrawMode SOLID_3DTEXTURED;
  extern ACGDLLEXPORT DrawMode SOLID_3DTEXTURED_SHADED;
  extern ACGDLLEXPORT DrawMode SOLID_FACES_COLORED_FLAT_SHADED;
  extern ACGDLLEXPORT DrawMode SOLID_FACES_COLORED_SMOOTH_SHADED;
  extern ACGDLLEXPORT DrawMode SOLID_FACES_COLORED_2DTEXTURED_FACE_SMOOTH_SHADED;
  extern ACGDLLEXPORT DrawMode SOLID_2DTEXTURED_FACE;
  extern ACGDLLEXPORT DrawMode SOLID_2DTEXTURED_FACE_SHADED;
  extern ACGDLLEXPORT DrawMode SOLID_SHADER;
  extern ACGDLLEXPORT DrawMode SOLID_SMOOTH_SHADED_FEATURES;

  //======================================================================
  //  Face Based Rendering Modes
  //======================================================================  
  // draw cells
  extern ACGDLLEXPORT DrawMode CELLS;

  extern ACGDLLEXPORT DrawMode CELLS_COLORED;


  //======================================================================
  //  Halfedge Based Rendering Modes
  //======================================================================
  extern ACGDLLEXPORT DrawMode HALFEDGES;

  extern ACGDLLEXPORT DrawMode HALFEDGES_COLORED;


  extern ACGDLLEXPORT DrawMode UNUSED;
  

  //=======================================================================
  // Non Member Functions
  //=======================================================================
  
  ACGDLLEXPORT 
  void initializeDefaultDrawModes( void );

  ACGDLLEXPORT
  const DrawMode& addDrawMode( const std::string & _name, bool _propertyBased = false);

  ACGDLLEXPORT
  const DrawMode& addDrawMode( const std::string & _name, const DrawModeProperties& _properties);

  ACGDLLEXPORT 
  const DrawMode& getDrawMode( const std::string & _name);

  
  ACGDLLEXPORT   
  bool drawModeExists(const std::string & _name);
  
  ACGDLLEXPORT 
  DrawMode getDrawModeFromIndex( unsigned int _index );

//=============================================================================
} // namespace DrawModes
} // namespace SceneGraph
} // namespace ACG
//=============================================================================
#endif // ACG_DRAWMODES_HH defined
//=============================================================================