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& _m) :
        baseColor_(_m.baseColor_),
        ambientColor_(_m.ambientColor_),
        diffuseColor_(_m.diffuseColor_),
        specularColor_(_m.specularColor_),
        overlayColor_(_m.overlayColor_),
        shininess_(_m.shininess_),
        reflectance_(_m.reflectance_),
        indexOfRefraction_(_m.indexOfRefraction_),
        isRefractive_(_m.isRefractive_),
        pointSize_(_m.pointSize_),
        lineWidth_(_m.lineWidth_),
        roundPoints_(_m.roundPoints_),
        linesSmooth_(_m.linesSmooth_),
        alphaTest_(_m.alphaTest_),
        alphaClip_(_m.alphaClip_),
        blending_(_m.blending_),
        blendParam1_(_m.blendParam1_),
        blendParam2_(_m.blendParam2_),
        colorMaterial_(_m.colorMaterial_),
        backfaceCulling_(_m.backfaceCulling_),
        multiSampling_(_m.multiSampling_) {};

    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);
    void leave(GLState& _state, const DrawModes::DrawMode& _drawmode);


    void enterPick(GLState& _state, PickTarget _target, const DrawModes::DrawMode& _drawMode );

    void leavePick(GLState& _state, PickTarget _target, const DrawModes::DrawMode& _drawMode );

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

    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
//=============================================================================