state.h

/********************************************************************
 * Copyright (C) 2015 Liangliang Nan <liangliang.nan@gmail.com>
 * https://3d.bk.tudelft.nl/liangliang/
 *
 * This file is part of Easy3D. If it is useful in your research/work,
 * I would be grateful if you show your appreciation by citing it:
 * ------------------------------------------------------------------
 *      Liangliang Nan.
 *      Easy3D: a lightweight, easy-to-use, and efficient C++ library
 *      for processing and rendering 3D data.
 *      Journal of Open Source Software, 6(64), 3255, 2021.
 * ------------------------------------------------------------------
 *
 * Easy3D is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License Version 3
 * as published by the Free Software Foundation.
 *
 * Easy3D is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 ********************************************************************/
 
#ifndef EASY3D_RENDERER_STATE_H
#define EASY3D_RENDERER_STATE_H
 
#include <string>
 
#include <easy3d/core/types.h>
 
 
namespace easy3d {
 
    class Texture;
 
    class State {
    public:
 
        enum Method {
            UNIFORM_COLOR, COLOR_PROPERTY, SCALAR_FIELD, TEXTURED
        };
 
        enum Location {
            VERTEX, FACE, EDGE, HALFEDGE
        };
 
        struct Material {
            Material() = default;
            Material(const vec4 &ambi, const vec4 &spec, float shin);
 
            vec4 ambient;
            //vec3    diffuse; // we have per face/point/line color!
            vec4 specular;
            float shininess;   // specular power
        };
 
    public:
        State();
        State(const State& s);
        State& operator=(const State& rhs);
 
        virtual ~State() = default;
 
        bool is_visible() const { return visible_; }
        void set_visible(bool v) { visible_ = v; }
 
        bool is_selected() const { return selected_; }
        void set_selected(bool b) { selected_ = b; }
 
 
        void set_uniform_coloring(const vec4 &color);
 
        void set_property_coloring(Location color_location, const std::string &color_name = "");
 
        void set_texture_coloring(Location texcoord_location, const std::string &texcoord_name,
                                  const Texture *texture = nullptr, float repeat = 1.0f,
                                  float repeat_fraction = 0.0f);
 
        void set_scalar_coloring(Location scalar_location, const std::string &scalar_name,
                                 const Texture *texture = nullptr, float clamp_lower = 0.05f,
                                 float clamp_upper = 0.05f);
 
        void set_coloring(Method method, Location location, const std::string &name);
 
        void set_coloring_method(Method method) { coloring_method_ = method; }
 
        Method coloring_method() const { return coloring_method_; }
 
        const vec4 &color() const { return color_; }
        void set_color(const vec4& c) { color_ = c; }
 
        Location property_location() const { return property_location_; }
 
        const std::string &property_name() const { return property_name_; }
 
        bool lighting() const { return lighting_; }
        void set_lighting(bool l) { lighting_ = l; }
 
        bool lighting_two_sides() const { return lighting_two_sides_; }
        void set_lighting_two_sides(bool b) { lighting_two_sides_ = b; }
 
        bool distinct_back_color() const { return distinct_back_color_; }
        void set_distinct_back_color(bool b) { distinct_back_color_ = b; }
 
        const vec4 &back_color() const { return back_color_; }
        void set_back_color(const vec4 &c) { back_color_ = c; }
 
        const Texture *texture() const { return texture_; }
        void set_texture(Texture *tex) { texture_ = tex; }
 
        float texture_repeat() const { return texture_repeat_; };
        void set_texture_repeat(float r) { texture_repeat_ = r; };
 
        float texture_fractional_repeat() const { return texture_fractional_repeat_; };
        void set_texture_fractional_repeat(float fr) { texture_fractional_repeat_ = fr; };
 
        // \todo: reuse the texture() and set_texture()
        bool is_ssao_enabled() const { return ssao_enabled_; }
        void enable_ssao(bool b) { ssao_enabled_ = b; }
        void set_ssao_texture(unsigned int tex) { ssao_texture_ = tex; }
 
        bool clamp_range() const { return clamp_range_; }
        void set_clamp_range(bool b) { clamp_range_ = b; }
 
        float clamp_lower() const { return clamp_lower_; }
        void set_clamp_lower(float v) { clamp_lower_ = v; }
 
        float clamp_upper() const { return clamp_upper_; }
        void set_clamp_upper(float v) { clamp_upper_ = v; }
 
        Material &material() { return material_; }
        const Material &material() const { return material_; }
        void set_material(const Material &m) { material_ = m; }
 
        bool plane_clip_discard_primitive() const { return plane_clip_discard_primitive_; };
        void set_plane_clip_discard_primitive(bool b) { plane_clip_discard_primitive_ = b; };
 
        bool highlight() const { return highlight_; };
        void set_highlight(bool b) { highlight_ = b; }
        void set_highlight_range(const std::pair<int, int> &range) { highlight_range_ = range; }
        const std::pair<int, int> &highlight_range() const { return highlight_range_; }
 
    protected:
        bool visible_;
        bool selected_;
 
        Method coloring_method_;
        vec4 color_; // valid when color method is UNIFORM_COLOR
        Location property_location_;
        std::string property_name_;
 
        bool lighting_;
 
        bool lighting_two_sides_;
        bool distinct_back_color_;
        vec4 back_color_;
 
        // texture
        const Texture *texture_;
        // How many times do you want to repeat the texture?
        float texture_repeat_;
        // Control at a finer level: 100 fractional repeat == repeat.
        float texture_fractional_repeat_;
 
        bool ssao_enabled_;
        unsigned int ssao_texture_;
 
        bool clamp_range_;
        float clamp_lower_;
        float clamp_upper_;
 
        Material material_;
 
        // Clipping plane behavior.
        //  - true: completely discard a primitive if one of its vertices has a negative clip distance
        //  - false: linearly interpolated (standard plane clipping behavior)
        bool plane_clip_discard_primitive_;
 
        // highlight the primitives within the range [highlight_id_low_, highlight_id_high_]
        bool highlight_;
        std::pair<int, int> highlight_range_;
    };
 
}
 
 
#endif  // EASY3D_RENDERER_STATE_H