tessellator.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_ALGO_TESSELLATOR_H
#define EASY3D_ALGO_TESSELLATOR_H
 
#include <vector>
#include <easy3d/core/types.h>
 
namespace easy3d {
 
    class Tessellator {
    public:
        struct Vertex : std::vector<double> {
 
            explicit Vertex(const vec3 &xyz, int idx = 0) : index(idx) { append(xyz); }
 
            template<typename FT>
            Vertex(const FT *data, std::size_t size, int idx = 0) : std::vector<double>(data, data + size), index(idx) {}
 
            explicit Vertex(std::size_t size = 0, int idx = 0) : std::vector<double>(size), index(idx) {}
 
            Vertex(const Vertex &v, int idx = 0) : std::vector<double>(v.begin(), v.end()), index(idx) {}
 
            template<typename Vec>
            inline void append(const Vec &v) {
                for (int i = 0; i < v.size(); ++i)
                    push_back(v[i]);
            }
 
            // this can be used to carry and map to the original vertex index
            int index;
        };
 
    public:
        Tessellator();
 
        ~Tessellator();
 
        enum WindingRule {
            WINDING_ODD = 100130,
            WINDING_NONZERO = 100131,
            WINDING_POSITIVE = 100132,
            WINDING_NEGATIVE = 100133,
            WINDING_ABS_GEQ_TWO = 100134
        };
 
 
        void set_boundary_only(bool b);
 
        void set_winding_rule(WindingRule rule);
 
        void begin_polygon(const vec3 &normal);
        void begin_polygon();
 
        void begin_contour();
 
        void add_vertex(const Vertex &data);
        void add_vertex(const float *data, unsigned int size, int idx = 0);
        void add_vertex(const vec3 &xyz, int idx = 0);
        void add_vertex(const vec3 &xyz, const vec2 &t, int idx = 0);
        void add_vertex(const vec3 &xyz, const vec3 &v1, int idx = 0);
        void add_vertex(const vec3 &xyz, const vec3 &v1, const vec2 &t, int idx = 0);
        void add_vertex(const vec3 &xyz, const vec3 &v1, const vec3 &v2, int idx = 0);
        void add_vertex(const vec3 &xyz, const vec3 &v1, const vec3 &v2, const vec2 &t, int idx = 0);
 
        void end_contour();
 
        void end_polygon();
 
 
        const std::vector<Vertex *> &vertices() const;
 
        const std::vector<std::vector<unsigned int> > &elements() const { return elements_; }
 
        unsigned int num_elements_in_polygon() const { return num_elements_in_polygon_; }
 
 
 
        void reset();
 
    private:
        void _add_element(const std::vector<unsigned int> &element);
 
        // GLU tessellator callbacks
        static void beginCallback(unsigned int w, void *cbdata);
        static void endCallback(void *cbdata);
        static void vertexCallback(void *vertex, void *cbdata);
        static void combineCallback(const double coords[3], void *vertex_data[4], const float weight[4], void **dataOut, void *cbdata);
 
    private:
        void *tess_obj_;
        void *vertex_manager_;
 
        // The tessellator decides the most efficient primitive type while performing tessellation.
        unsigned int primitive_type_; // GL_TRIANGLES, GL_TRIANGLE_FAN, GL_TRIANGLE_STRIP
 
        // The list of elements (triangle or contour) created over many calls. Each entry is the vertex indices of the
        // element.
        std::vector<std::vector<unsigned int> > elements_;
 
        // The growing number of elements (triangle or contour) in the current polygon.
        unsigned int num_elements_in_polygon_;
 
        // The vertex indices (including the original ones and the new vertices) of the current polygon.
        std::vector<unsigned int> vertex_ids_;
 
        // The length of the vertex data. Used to handle user provided data in the combine function.
        unsigned int vertex_data_size_;
    };
 
 
    namespace csg {
        void tessellate(std::vector<Polygon2> &polygons, Tessellator::WindingRule rule);
 
        void union_of(std::vector<Polygon2> &polygons);
 
        void intersection_of(const Polygon2& polygon_a, const Polygon2& polygon_b, std::vector<Polygon2> &result);
 
        void difference_of(const Polygon2& polygon_a, const Polygon2& polygon_b, std::vector<Polygon2> &result);
    }
 
}
 
#endif  // EASY3D_ALGO_TESSELLATOR_H