GLUP_marching_cells.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2000-2022 Inria
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *  * 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.
 *  * Neither the name of the ALICE Project-Team 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.
 *
 *  Contact: Bruno Levy
 *
 *     https://www.inria.fr/fr/bruno-levy
 *
 *     Inria,
 *     Domaine de Voluceau,
 *     78150 Le Chesnay - Rocquencourt
 *     FRANCE
 *
 */
 
#ifndef GEOGRAM_GFX_GLUP_GLUP_MARCHING_CELLS
#define GEOGRAM_GFX_GLUP_GLUP_MARCHING_CELLS
 
#include <geogram_gfx/GLUP/GLUP.h>
#include <geogram_gfx/basic/common.h>
#include <geogram/basic/logger.h>
#include <geogram/mesh/mesh.h> // For cell descriptors / marching cells.
 
namespace GLUP {
    using namespace GEO;
 
    /**********************************************************************/
 
    class MarchingCell {
    public:
 
        MarchingCell(GLUPprimitive prim);
 
        ~MarchingCell();
 
        index_t nb_vertices() const {
            return nb_vertices_;
        }
 
        index_t nb_edges() const {
            return nb_edges_;
        }
 
 
        index_t nb_configs() const {
            return nb_configs_;
        }
 
        index_t edge_vertex(index_t e, index_t lv) const {
            geo_debug_assert(e < nb_edges());
            geo_debug_assert(lv < 2);
            return edge_[e*2+lv];
        }
 
        index_t config_size(index_t config) const {
            geo_debug_assert(config < nb_configs());
            return config_size_[config];
        }
 
        index_t max_config_size() const {
            return max_config_size_;
        }
 
        const index_t* config_edges(index_t config) const {
            geo_debug_assert(config < nb_configs());
            return config_ + config * nb_edges_;
        }
 
        const char* GLSL_uniform_state_declaration() const {
            return GLSL_uniform_state_declaration_.c_str();
        }
 
        const char* GLSL_compute_intersections() const {
            return GLSL_compute_intersections_.c_str();
        }
 
 
        GLuint uniform_binding_point() const {
            return uniform_binding_point_;
        }
 
        GLuint create_UBO();
 
        GLuint create_elements_VBO();
 
        void bind_uniform_state(GLuint program);
 
    protected:
 
        void compute_config(index_t config);
 
        void move_to_next(index_t& f, index_t& lv) {
            lv = (lv+1) % desc_->nb_vertices_in_facet[f];
        }
 
        index_t origin_vertex(index_t f, index_t lv) {
            return desc_->facet_vertex[f][lv];
        }
 
        index_t destination_vertex(index_t f, index_t lv) {
            move_to_next(f, lv);
            return origin_vertex(f, lv);
        }
 
        index_t edge(index_t f, index_t lv) {
            index_t v1 = origin_vertex(f, lv);
            index_t v2 = destination_vertex(f, lv);
            index_t result = vv_to_e_[v1*desc_->nb_vertices+v2];
            geo_debug_assert(result != index_t(-1));
            return result;
        }
 
        void move_to_opposite(index_t& f, index_t& lv);
 
        bool edge_is_intersected(index_t f, index_t lv, index_t config) {
            index_t v1 = origin_vertex(f, lv);
            index_t v2 = destination_vertex(f, lv);
            bool v1_in = ((config & 1u<<v1) != 0);
            bool v2_in = ((config & 1u<<v2) != 0);
            return (v1_in != v2_in);
        }
 
        bool config_is_ambiguous(index_t config);
 
        bool get_first_edge(index_t& f, index_t& lv, index_t config);
 
    private:
        MarchingCell(const MarchingCell& rhs);
 
        MarchingCell& operator=(const MarchingCell& rhs);
 
    private:
        const CellDescriptor* desc_;
        index_t vv_to_e_[64];
        index_t nb_vertices_;
        index_t nb_configs_;
        index_t* config_size_;
        index_t max_config_size_;
        index_t* config_;
        index_t nb_edges_;
        index_t* edge_;
        std::string GLSL_uniform_state_declaration_;
        std::string GLSL_compute_intersections_;
        GLuint uniform_binding_point_;
        GLuint UBO_;
        GLuint elements_VBO_;
    };
 
    /**********************************************************************/
 
}
 
#endif