MaterialNode.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 MaterialNode
//
//=============================================================================
 
#ifndef ACG_MATERIAL_NODE_HH
#define ACG_MATERIAL_NODE_HH
 
 
//== INCLUDES =================================================================
 
#include "BaseNode.hh"
#include <string>
#include <QVariantMap>
 
//== NAMESPACES ===============================================================
 
namespace ACG {
 
QVariantMap ACGDLLEXPORT json_to_variant_map(QString json);
 
namespace SceneGraph {
 
 
//== CLASS DEFINITION =========================================================
 
class ACGDLLEXPORT Material {
 
  friend class MaterialNode;
 
public:
    Material() :
        baseColor_(GLState::default_base_color),
        ambientColor_(GLState::default_ambient_color),
        diffuseColor_(GLState::default_diffuse_color),
        specularColor_(GLState::default_specular_color),
        overlayColor_(GLState::default_overlay_color),
        shininess_(GLState::default_shininess),
        reflectance_(0.0),
        indexOfRefraction_(1.0),
        isRefractive_(false),
        pointSize_(1.0),
        lineWidth_(1.0),
        roundPoints_(false),
        linesSmooth_(false),
        alphaTest_(false),
        alphaClip_(0),
        blending_(false),
        blendParam1_(GL_SRC_ALPHA),
        blendParam2_(GL_ONE_MINUS_SRC_ALPHA),
        colorMaterial_(true),
        backfaceCulling_(false),
        multiSampling_(true) {};
 
    virtual ~Material() {};
 
    Material(const Material&) = default;
 
    static bool support_json_serialization();
    QString serializeToJson() const;
    void deserializeFromJson(const QString &json);
    void deserializeFromVariantMap(const QVariantMap &matMap);
 
    void color(const Vec4f& _c) {
        Vec4f c(0.0,0.0,0.0,1.0);
        baseColor(c);
        overlayColor(c);
        c = _c * 0.2f;  c[3]=_c[3];  ambientColor(c);
        c = _c * 0.6f;  c[3]=_c[3];  diffuseColor(c);
        c = _c * 0.8f;  c[3]=_c[3];  specularColor(c);
    }
 
    void generateRandomColor() {
      color( Vec4f(0.2 + double(rand())/double(RAND_MAX)*0.8,
                   0.2 + double(rand())/double(RAND_MAX)*0.8,
                   0.2 + double(rand())/double(RAND_MAX)*0.8,
                   1.0));
    }
 
    void baseColor(const Vec4f& _c) { baseColor_ = _c;}
    const Vec4f& baseColor() const { return baseColor_; }
 
    void emissionColor(const Vec4f& _c) { baseColor_ = _c;}
    const Vec4f& emissionColor() const { return baseColor_; }
 
    void ambientColor(const Vec4f& _a) { ambientColor_ = _a; }
    const Vec4f& ambientColor() const { return ambientColor_; }
 
    void diffuseColor(const Vec4f& _d) { diffuseColor_ = _d; }
    const Vec4f& diffuseColor() const { return diffuseColor_; }
 
    void specularColor(const Vec4f& _s) { specularColor_ = _s; }
    const Vec4f& specularColor() const { return specularColor_; }
 
    void overlayColor(const Vec4f& _s) { overlayColor_ = _s; }
    const Vec4f& overlayColor() const { return overlayColor_; }
 
    void colorMaterial( const bool _cm) { colorMaterial_ = _cm; }
    void enableColorMaterial() { colorMaterial_ = true; }
    void disableColorMaterial() { colorMaterial_ = false; }
    bool colorMaterial() { return colorMaterial_; }
 
    void shininess(float _s) { shininess_ = _s; }
    float shininess() const { return shininess_; }
 
    void reflectance(double _m) { reflectance_ = _m; }
    double reflectance() const { return reflectance_; }
 
    void indexOfRefraction(double _m) { indexOfRefraction_ = _m; }
    double indexOfRefraction() const { return indexOfRefraction_; }
 
    void setRefractive(bool _r) { isRefractive_ = _r; }
    bool isRefractive() const {return isRefractive_;}
 
    void pointSize(float _sz) { pointSize_ = _sz; }
    float pointSize() const { return pointSize_; }
 
    void lineWidth(float _sz) { lineWidth_ = _sz; }
    float lineWidth() const { return lineWidth_; }
 
    void roundPoints(bool _b) { roundPoints_ = _b; }
    bool roundPoints() const { return roundPoints_; }
 
    void lineSmooth(bool _b) { linesSmooth_ = _b; }
    bool lineSmooth() const { return linesSmooth_; }
 
    void enableAlphaTest(float _clip) {
      alphaTest_ = true; alphaClip_ = _clip;
    }
 
    void disableAlphaTest() { alphaTest_ = false; }
 
    bool alphaTest() const { return alphaTest_; };
 
    void enableMultisampling() {
      multiSampling_ = true;
    }
 
    void disableMultisampling() {
      multiSampling_ = false;
    }
 
    bool multiSampling() const {
      return multiSampling_;
    }
 
    void multisampling( bool _state ) {
      multiSampling_ = _state;
    }
 
    float alphaValue() const { return alphaClip_; };
 
    bool blending() const { return blending_; };
 
    GLenum blendingParam1() const { return blendParam1_; };
    GLenum blendingParam2() const { return blendParam2_; };
 
    void enableBlending(GLenum _p1 = GL_SRC_ALPHA,
               GLenum _p2 = GL_ONE_MINUS_SRC_ALPHA)
    { blending_ = true; blendParam1_ = _p1; blendParam2_ = _p2; }
    void disableBlending() { blending_ = false; }
 
    bool backfaceCulling() const { return backfaceCulling_; };
 
    void enableBackfaceCulling() { backfaceCulling_ = true; }
    void disableBackfaceCulling() { backfaceCulling_ = false; }
 
    bool isEmissive() const { return (baseColor_[0] > 0.f || baseColor_[1] > 0.f || baseColor_[2] > 0.f); }
 
protected:
 
    Vec4f    baseColor_;
    Vec4f    ambientColor_;
    Vec4f    diffuseColor_;
    Vec4f    specularColor_;
    Vec4f    overlayColor_;
 
    float    shininess_;
    double   reflectance_;
    double   indexOfRefraction_;
    bool     isRefractive_;
    float    pointSize_;
    float    lineWidth_;
 
    bool     roundPoints_;
    bool     linesSmooth_;
 
    bool     alphaTest_;
    float    alphaClip_;
 
    bool     blending_;
    GLenum   blendParam1_;
    GLenum   blendParam2_;
 
    bool     colorMaterial_;
    bool     backfaceCulling_;
 
    bool     multiSampling_;
};
 
 
class ACGDLLEXPORT MaterialNode : public BaseNode
{
public:
 
  enum ApplyProperties
  {
    None=0,
    All=0xffff,
    BaseColor=1,
    Material=2,
    PointSize=4,
    LineWidth=8,
    RoundPoints=16,
    LineSmooth=32,
    AlphaTest=64,
    Blending=128,
    BackFaceCulling=256,
    ColorMaterial=512,
    MultiSampling=1024
  };
 
  MaterialNode( BaseNode*           _parent = 0,
                const std::string&  _name = "<MaterialNode>",
                unsigned int        _applyProperties = (All & ~BackFaceCulling));
 
  virtual ~MaterialNode() {};
 
  void read( std::istream & _is);
 
  //===========================================================================
  //===========================================================================
 
    ACG_CLASSNAME(MaterialNode);
 
    void enter(GLState& _state, const DrawModes::DrawMode& _drawmode) override;
    void leave(GLState& _state, const DrawModes::DrawMode& _drawmode) override;
 
 
    void enterPick(GLState& _state, PickTarget _target, const DrawModes::DrawMode& _drawMode ) override;
 
    void leavePick(GLState& _state, PickTarget _target, const DrawModes::DrawMode& _drawMode ) override;
 
    //===========================================================================
    //===========================================================================
 
    void set_color(const Vec4f& _c) {
      material_.color(_c);
    }
 
    void set_random_color() {
      material_.generateRandomColor();
    }
 
    void set_base_color(const Vec4f& _c) { material_.baseColor(_c); }
    const Vec4f& base_color() const { return material_.baseColor(); }
 
    void set_emission(const Vec4f& _c) { material_.baseColor(_c); }
    const Vec4f& emission() const { return material_.baseColor(); }
 
    void set_ambient_color(const Vec4f& _a) { material_.ambientColor(_a); }
    const Vec4f& ambient_color() const { return material_.ambientColor(); }
 
    void set_diffuse_color(const Vec4f& _d) { material_.diffuseColor(_d); }
    const Vec4f& diffuse_color() const { return material_.diffuseColor(); }
 
    void set_specular_color(const Vec4f& _s) { material_.specularColor(_s); }
    const Vec4f& specular_color() const { return material_.specularColor(); }
 
    void set_overlay_color(const Vec4f& _s) { material_.overlayColor(_s); }
    const Vec4f& overlay_color() const { return material_.overlayColor(); }
 
    void colorMaterial( const bool _cm) { material_.colorMaterial(_cm); }
    void enable_color_material() { material_.enableColorMaterial(); }
    void disable_color_material() { material_.disableColorMaterial(); }
    bool colorMaterial() { return material_.colorMaterial(); }
 
    void set_shininess(float _s) { material_.shininess(_s); }
    float shininess() const { return material_.shininess(); }
 
    void set_reflectance(double _m) { material_.reflectance(_m); }
    double reflectance() const { return material_.reflectance(); }
 
    void set_indexOfRefraction(double _m) { material_.indexOfRefraction(_m); }
    double indexOfRefraction() const { return material_.indexOfRefraction(); }
 
    void set_refractive(bool _r) { material_.isRefractive_ = _r; }
    bool isRefractive() const {return material_.isRefractive_;}
 
  //===========================================================================
  //===========================================================================
    void set_point_size(float _sz) { material_.pointSize(_sz); }
    float point_size() const { return material_.pointSize(); }
 
    void set_line_width(float _sz) { material_.lineWidth(_sz); }
    float line_width() const { return material_.lineWidth(); }
 
    void set_round_points(bool _b) { material_.roundPoints(_b); }
    bool round_points() const { return material_.roundPoints(); }
 
    void set_line_smooth(bool _b) { material_.lineSmooth(_b); }
    bool line_smooth() const { return material_.lineSmooth(); }
 
  //===========================================================================
  //===========================================================================
 
    void enable_alpha_test(float _clip) { material_.enableAlphaTest(_clip); }
 
    void disable_alpha_test() { material_.disableAlphaTest(); }
 
    bool alpha_test() { return material_.alphaTest(); };
 
  //===========================================================================
  //===========================================================================
 
    void enable_multisampling() { material_.enableMultisampling(); }
 
    void disable_multisampling() { material_.disableMultisampling(); }
 
    bool multiSampling() { return material_.multiSampling(); }
 
    void set_multisampling( bool _state ) { material_.multisampling(_state); }
 
  float alpha_value(){ return material_.alphaValue(); };
 
  bool blending() { return material_.blending(); };
 
  GLenum blending_param1() { return material_.blendingParam1(); };
  GLenum blending_param2() { return material_.blendingParam2(); };
 
  void enable_blending(GLenum _p1 = GL_SRC_ALPHA,
               GLenum _p2 = GL_ONE_MINUS_SRC_ALPHA) {
      material_.enableBlending(_p1, _p2);
  }
  void disable_blending() { material_.disableBlending(); }
 
  bool backface_culling() { return material_.backfaceCulling(); };
 
  void enable_backface_culling() { material_.enableBackfaceCulling(); }
 
  void disable_backface_culling() { material_.disableBackfaceCulling(); }
 
  unsigned int applyProperties() const { return applyProperties_; }
 
  void applyProperties(unsigned int _applyProperties) {
    applyProperties_ = _applyProperties;
  }
 
  ACG::SceneGraph::Material& material() { return material_; }
 
  void set_material(const ACG::SceneGraph::Material& _m) { material_ = _m; }
 
private:
 
    int applyProperties_;
 
    ACG::SceneGraph::Material material_;
 
    ACG::SceneGraph::Material materialBackup_;
};
 
 
//=============================================================================
} // namespace SceneGraph
} // namespace ACG
//=============================================================================
#endif // ACG_MATERIAL_NODE_HH defined
//=============================================================================