GLUP_context.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_CONTEXT
#define GEOGRAM_GFX_GLUP_GLUP_CONTEXT
 
#include <geogram_gfx/basic/common.h>
#include <geogram_gfx/GLUP/GLUP.h>
#include <geogram_gfx/GLUP/GLUP_marching_cells.h>
#include <geogram_gfx/basic/GLSL.h>
#include <map>
 
#ifdef GEO_GL_NO_DOUBLES
typedef double GLdouble;
#endif
 
static constexpr GLUPprimitive GLUP_THICK_LINES = GLUP_RESERVED_PRIMITIVE_1;
 
namespace GLUP {
    using namespace GEO;
 
    GLboolean invert_matrix(GLfloat inv[16], const GLfloat m[16]);
 
    GLboolean invert_matrix(GLdouble inv[16], const GLdouble m[16]);
 
    void mult_matrices(
        GLfloat out[16], const GLfloat m1[16], const GLfloat m2[16]
    );
 
    void mult_matrices(
        GLdouble out[16], const GLdouble m1[16], const GLdouble m2[16]
    );
 
    void mult_matrix_vector(
        GLfloat out[4], const GLfloat m[16], const GLfloat v[4]
    );
 
 
    void mult_transpose_matrix_vector(
        GLfloat out[4], const GLfloat m[16], const GLfloat v[4]
    );
 
 
    void mult_transpose_matrix_vector(
        GLdouble out[4], const GLdouble m[16], const GLdouble v[4]
    );
 
    void mult_matrix_vector(
        GLdouble out[4], const GLdouble m[16], const GLdouble v[4]
    );
 
    void transpose_matrix(GLfloat m[16]);
 
    void transpose_matrix(GLdouble m[16]);
 
    void show_matrix(const GLfloat m[16]);
 
    void show_matrix(const GLdouble m[16]);
 
    void show_vector(const GLfloat v[4]);
 
    void show_vector(const GLdouble v[4]);
 
    void load_identity_matrix(GLfloat out[16]);
 
    void load_identity_matrix(GLdouble out[16]);
 
    inline void copy_vector(GLfloat* to, const GLfloat* from, index_t dim) {
        Memory::copy(to, from, sizeof(GLfloat)*dim);
    }
 
    inline void copy_vector(GLdouble* to, const GLdouble* from, index_t dim) {
        Memory::copy(to, from, sizeof(GLdouble)*dim);
    }
 
    inline void copy_vector(GLfloat* to, const GLdouble* from, index_t dim) {
        for(index_t i=0; i<dim; ++i) {
            to[i] = GLfloat(from[i]);
        }
    }
 
    inline void copy_vector(GLdouble* to, const GLfloat* from, index_t dim) {
        for(index_t i=0; i<dim; ++i) {
            to[i] = GLdouble(from[i]);
        }
    }
 
    inline void normalize_vector(GLfloat v[3]) {
        GLfloat s = 1.0f / ::sqrtf(v[0]*v[0]+v[1]*v[1]+v[2]*v[2]);
        v[0] *= s;
        v[1] *= s;
        v[2] *= s;
    }
 
    /**********************************************************************/
 
    class Context;
 
    class MatrixStack {
    public:
 
        static const int MAX_DEPTH=16;
 
        MatrixStack() : top_(0) {
            load_identity_matrix(top());
        }
 
        GLdouble* top() {
            return stack_[top_].data();
        }
 
        void push() {
            geo_assert(top_ != MAX_DEPTH-1);
            GLdouble* from = top();
            ++top_;
            GLdouble* to = top();
            copy_vector(to, from, 16);
        }
 
        void pop() {
            geo_assert(top_ != 0);
            --top_;
        }
 
    protected:
        struct Matrix {
            GLdouble coeff[16];
            GLdouble* data() {
                return &coeff[0];
            }
        };
 
    private:
        Matrix stack_[MAX_DEPTH];
        index_t top_;
    };
 
 
    static const index_t IMMEDIATE_BUFFER_SIZE = 65536;
 
    enum GLUPattribute {
        GLUP_VERTEX_ATTRIBUTE    = 0,
        GLUP_COLOR_ATTRIBUTE     = 1,
        GLUP_TEX_COORD_ATTRIBUTE = 2,
        GLUP_NORMAL_ATTRIBUTE    = 3,
        GLUP_VERTEX_ID_ATTRIBUTE = 4
    };
 
    class ImmediateBuffer {
 
    public:
 
        ImmediateBuffer() :
            data_(nullptr),
            dimension_(0),
            is_enabled_(false),
            VBO_(0) {
        }
 
        ~ImmediateBuffer() {
            delete[] data_;
            if(VBO_ != 0) {
                glDeleteBuffers(1, &VBO_);
                VBO_ = 0;
            }
        }
 
        void initialize(index_t dim) {
            data_ = new GLfloat[dim * IMMEDIATE_BUFFER_SIZE];
            dimension_ = dim;
            is_enabled_ = true;
        }
 
        void enable() {
            is_enabled_ = true;
        }
 
        void disable() {
            is_enabled_ = false;
        }
 
        bool is_enabled() const {
            return is_enabled_;
        }
 
        void set_current(GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
            current_[0] = x;
            current_[1] = y;
            current_[2] = z;
            current_[3] = w;
        }
 
        void copy_current_to(index_t v) {
            geo_debug_assert(v < IMMEDIATE_BUFFER_SIZE);
            if(is_enabled()) {
                copy_vector(element_ptr(v), current_, dimension());
            }
        }
 
        void copy(index_t to, index_t from) {
            geo_debug_assert(to < IMMEDIATE_BUFFER_SIZE);
            geo_debug_assert(from < IMMEDIATE_BUFFER_SIZE);
            if(is_enabled()) {
                copy_vector(element_ptr(to), element_ptr(from), dimension());
            }
        }
 
        void copy(index_t to, ImmediateBuffer& from_buffer, index_t from) {
            geo_debug_assert(to < IMMEDIATE_BUFFER_SIZE);
            geo_debug_assert(from < IMMEDIATE_BUFFER_SIZE);
            geo_debug_assert(from_buffer.dimension() == dimension());
            copy_vector(
                element_ptr(to), from_buffer.element_ptr(from), dimension()
            );
        }
 
        index_t dimension() const {
            return dimension_;
        }
 
        size_t size_in_bytes() const {
            return IMMEDIATE_BUFFER_SIZE * dimension() * sizeof(GLfloat);
        }
 
        GLfloat* element_ptr(index_t v) {
            geo_debug_assert(v < IMMEDIATE_BUFFER_SIZE);
            return data_ + v*dimension_;
        }
 
        GLfloat* data() {
            return data_;
        }
 
        GLuint& VBO() {
            return VBO_;
        }
 
        ImmediateBuffer(
            const ImmediateBuffer& rhs
        ) {
            data_ = rhs.data_;
            dimension_ = rhs.dimension_;
            is_enabled_ = rhs.is_enabled_;
            VBO_ = rhs.VBO_;
            current_[0] = rhs.current_[0];
            current_[1] = rhs.current_[1];
            current_[2] = rhs.current_[2];
            current_[3] = rhs.current_[3];
            geo_assert(data_ == nullptr);
        }
 
    private:
        GLfloat* data_;
        GLfloat current_[4];
        index_t dimension_;
        bool is_enabled_;
        GLuint VBO_;
    };
 
    class ImmediateState {
    public:
        ImmediateState(index_t* nb_vertices_per_primitive) :
            current_vertex_(0),
            max_current_vertex_(0),
            primitive_(GLUP_POINTS),
            VAO_(0),
            nb_vertices_per_primitive_(nb_vertices_per_primitive)
            {
                buffer[GLUP_VERTEX_ATTRIBUTE].initialize(4);
                buffer[GLUP_COLOR_ATTRIBUTE].initialize(4);
                buffer[GLUP_TEX_COORD_ATTRIBUTE].initialize(4);
                buffer[GLUP_NORMAL_ATTRIBUTE].initialize(4);
 
                // Vertex is always enabled
                buffer[GLUP_VERTEX_ATTRIBUTE].enable();
            }
 
        ~ImmediateState() {
            if(VAO_ != 0) {
                glupDeleteVertexArrays(1, &VAO_);
                VAO_ = 0;
            }
        }
 
        GLuint& VAO() {
            return VAO_;
        }
 
        void copy_element(index_t to, index_t from) {
            for(index_t i=0; i<NB_IMMEDIATE_BUFFERS; ++i) {
                buffer[i].copy(to, from);
            }
        }
 
 
        void begin(GLUPprimitive primitive, index_t max_current_vertex=0) {
            current_vertex_ = 0;
            if(max_current_vertex != 0) {
                max_current_vertex_ = max_current_vertex;
            } else {
                max_current_vertex_ =
                    IMMEDIATE_BUFFER_SIZE - (
                        IMMEDIATE_BUFFER_SIZE %
                        nb_vertices_per_primitive_[primitive]
                    );
            }
            primitive_ = primitive;
        }
 
        void next_vertex() {
            for(index_t i=0; i<NB_IMMEDIATE_BUFFERS; ++i) {
                buffer[i].copy_current_to(current_vertex_);
            }
            ++current_vertex_;
        }
 
        bool buffers_are_full() {
            return (current_vertex_ == max_current_vertex_);
        }
 
        void reset(index_t new_current_vertex = 0) {
            current_vertex_ = new_current_vertex;
        }
 
        GLUPprimitive primitive() const {
            return primitive_;
        }
 
        index_t nb_vertices() const {
            return current_vertex_;
        }
 
        index_t nb_primitives() const {
            return current_vertex_ / nb_vertices_per_primitive_[
                primitive_
            ];
        }
 
        index_t max_current_vertex() const {
            return max_current_vertex_;
        }
 
        void set_current_vertex(index_t v) {
            geo_debug_assert(v <= max_current_vertex_);
            current_vertex_ = v;
        }
 
        enum { NB_IMMEDIATE_BUFFERS = 4 };
        ImmediateBuffer buffer[NB_IMMEDIATE_BUFFERS];
 
    private:
        index_t current_vertex_;
        index_t max_current_vertex_;
        GLUPprimitive primitive_;
        GLuint VAO_;
        index_t* nb_vertices_per_primitive_;
    };
 
 
    /**********************************************************/
 
    class StateVariableBase {
    public:
 
        StateVariableBase() : address_(nullptr), context_(nullptr) {
        }
 
        StateVariableBase(
            Context* context, const char* name
        ) {
            initialize(context,name);
        }
 
        void initialize(Context* context, const char* name);
 
        const std::string& name() const {
            return name_;
        }
 
    protected:
        friend class Context;
 
        Memory::pointer address() const {
            return address_;
        }
 
        void flag_uniform_buffer_as_dirty();
 
        Memory::pointer address_;
        Context* context_;
        std::string name_;
    };
 
    template <class T> class StateVariable : public StateVariableBase {
    public:
 
        StateVariable() {
        }
 
        StateVariable(
            Context* context, const char* name, T value
        ) : StateVariableBase(context, name) {
            set(value);
        }
 
        void initialize(Context* context, const char* name, T value) {
            StateVariableBase::initialize(context, name);
            set(value);
        }
 
        T get() const {
            return *reinterpret_cast<T*>(address_);
        }
 
        void set(T val) {
            *reinterpret_cast<T*>(address_) = val;
            flag_uniform_buffer_as_dirty();
        }
    };
 
    class FloatsArrayStateVariable : public StateVariableBase {
    public:
 
        FloatsArrayStateVariable() {
        }
 
        FloatsArrayStateVariable(
            Context* context, const char* name
        ) : StateVariableBase(context, name) {
        }
 
        const GLUPfloat* get_pointer() const {
            return reinterpret_cast<const GLUPfloat*>(address_);
        }
 
        GLUPfloat* get_pointer() {
            // This is a non-const pointer, therefore it will be
            // probably modified by client code (else the 'const'
            // version of get_pointer() would have been called).
            flag_uniform_buffer_as_dirty();
            return reinterpret_cast<GLUPfloat*>(address_);
        }
    };
 
    class VectorStateVariable : public FloatsArrayStateVariable {
    public:
 
        VectorStateVariable() : dimension_(0) {
        }
 
        VectorStateVariable(
            Context* context, const char* name, index_t dimension
        ) : FloatsArrayStateVariable(context, name), dimension_(dimension) {
            clear();
        }
 
        void initialize(Context* context, const char* name, index_t dimension) {
            FloatsArrayStateVariable::initialize(context, name);
            dimension_ = dimension;
            clear();
        }
 
        index_t dimension() const {
            return dimension_;
        }
 
        void get(GLUPfloat* x) const {
            Memory::copy(x, address_, sizeof(GLUPfloat)*dimension_);
        }
 
        void set(const GLUPfloat* x) {
            Memory::copy(address_, x, sizeof(GLUPfloat)*dimension_);
            flag_uniform_buffer_as_dirty();
        }
 
        void clear() {
            Memory::clear(address_, sizeof(GLUPfloat)*dimension_);
            if(dimension_ == 4) {
                reinterpret_cast<GLUPfloat*>(address_)[3] = 1.0f;
            }
            flag_uniform_buffer_as_dirty();
        }
 
    protected:
        index_t dimension_;
    };
 
 
    struct UniformState {
        vector< StateVariable<GLboolean> > toggle;
        vector< VectorStateVariable>       color;
        VectorStateVariable                light_vector;
        VectorStateVariable                light_half_vector;
        StateVariable<GLfloat>             point_size;
        StateVariable<GLfloat>             mesh_width;
        StateVariable<GLfloat>             cells_shrink;
        StateVariable<GLint>               picking_mode;
        StateVariable<GLint>               picking_id;
        StateVariable<GLint>               base_picking_id;
        StateVariable<GLint>               clipping_mode;
        StateVariable<GLint>               texture_mode;
        StateVariable<GLint>               texture_type;
        StateVariable<GLfloat>             alpha_threshold;
        StateVariable<GLfloat>             specular;
        VectorStateVariable                clip_plane;
        VectorStateVariable                world_clip_plane;
        VectorStateVariable                clip_clip_plane;
        FloatsArrayStateVariable           modelview_matrix;
        FloatsArrayStateVariable           modelviewprojection_matrix;
        FloatsArrayStateVariable           projection_matrix;
        FloatsArrayStateVariable           normal_matrix;
        FloatsArrayStateVariable           texture_matrix;
        FloatsArrayStateVariable           inverse_modelviewprojection_matrix;
        FloatsArrayStateVariable           inverse_modelview_matrix;
        FloatsArrayStateVariable           inverse_projection_matrix;
        VectorStateVariable                viewport;
    };
 
    /**********************************************************************/
 
    struct PrimitiveInfo {
 
        typedef Numeric::uint64 ShaderKey;
 
        PrimitiveInfo():
            GL_primitive(0),
            VAO(0),
            elements_VBO(0),
            nb_elements_per_primitive(0),
            primitive_elements(nullptr),
            vertex_gather_mode(false),
            implemented(false) {
        }
 
        PrimitiveInfo(const PrimitiveInfo& rhs) : shader_map(rhs.shader_map) {
            GL_primitive = rhs.GL_primitive;
            VAO = rhs.VAO;
            elements_VBO = rhs.elements_VBO;
            nb_elements_per_primitive = rhs.nb_elements_per_primitive;
            primitive_elements = rhs.primitive_elements;
            vertex_gather_mode = rhs.vertex_gather_mode;
            implemented = rhs.implemented;
            geo_assert(GL_primitive == 0);
            geo_assert(nb_elements_per_primitive == 0);
        }
 
        ~PrimitiveInfo() {
            for(auto& it : shader_map) {
                if(it.second != 0) {
                    glDeleteProgram(it.second);
                    it.second = 0;
                }
            }
            if(elements_VBO != 0) {
                glDeleteBuffers(1, &elements_VBO);
            }
            if(VAO != 0) {
                glupDeleteVertexArrays(1,&VAO);
                VAO = 0;
            }
        }
 
        bool program_is_initialized(ShaderKey k) const {
            return (shader_map.find(k) != shader_map.end());
        }
 
        GLuint program(ShaderKey k) const {
            auto it = shader_map.find(k);
            return ((it == shader_map.end()) ? 0 : it->second);
        }
 
        GLenum GL_primitive;
        std::map<ShaderKey, GLuint> shader_map;
        GLuint VAO;
        GLuint elements_VBO;
        index_t nb_elements_per_primitive;
        index_t* primitive_elements;
        bool vertex_gather_mode;
        bool implemented;
    };
 
    /**********************************************************************/
 
    class Context : public GLSL::PseudoFileProvider {
    public:
        static const char* uniform_state_declaration();
 
        Context();
 
        ~Context() override;
 
 
        virtual const char* profile_name() const = 0;
 
        virtual bool primitive_supports_array_mode(GLUPprimitive prim) const;
 
        virtual void setup();
 
        virtual void bind_uniform_state(GLuint program);
 
        void load_matrix(const GLfloat m[16]) {
            copy_vector(matrix_stack_[matrix_mode_].top(), m, 16);
            flag_matrices_as_dirty();
        }
 
        void load_matrix(const GLdouble m[16]) {
            copy_vector(matrix_stack_[matrix_mode_].top(), m, 16);
            flag_matrices_as_dirty();
        }
 
        void load_identity() {
            load_identity_matrix(matrix_stack_[matrix_mode_].top());
            flag_matrices_as_dirty();
        }
 
        void mult_matrix(const GLdouble m[16]) {
            GLdouble product[16];
            mult_matrices(product,m,matrix_stack_[matrix_mode_].top());
            load_matrix(product);
        }
 
        void push_matrix() {
            matrix_stack_[matrix_mode_].push();
        }
 
        void pop_matrix() {
            matrix_stack_[matrix_mode_].pop();
            flag_matrices_as_dirty();
        }
 
        void set_matrix_mode(GLUPmatrix matrix) {
            matrix_mode_ = matrix;
        }
 
        GLUPmatrix get_matrix_mode() const {
            return matrix_mode_;
        }
 
        void immediate_vertex(
            GLfloat x, GLfloat y, GLfloat z=0.0f, GLfloat w=1.0f
        ) {
            immediate_state_.buffer[GLUP_VERTEX_ATTRIBUTE].set_current(x,y,z,w);
            immediate_state_.next_vertex();
            if(immediate_state_.buffers_are_full()) {
                flush_immediate_buffers();
            }
        }
 
        void immediate_color(
            GLfloat r, GLfloat g, GLfloat b, GLfloat a = 1.0f
        ) {
            immediate_state_.buffer[GLUP_COLOR_ATTRIBUTE].set_current(r,g,b,a);
        }
 
        void immediate_tex_coord(
            GLfloat s, GLfloat t=0.0f, GLfloat u=0.0f, GLfloat v=1.0f
        ) {
            immediate_state_.buffer[GLUP_TEX_COORD_ATTRIBUTE].set_current(
                s,t,u,v
            );
        }
 
        void immediate_normal(GLfloat x, GLfloat y, GLfloat z) {
            immediate_state_.buffer[GLUP_NORMAL_ATTRIBUTE].set_current(
                x,y,z,0.0f
            );
        }
 
        void set_user_program(GLuint program) {
            user_program_ = program;
        }
 
        virtual void begin(GLUPprimitive primitive);
 
        virtual void end();
 
        virtual void draw_arrays(
            GLUPprimitive primitive, GLUPint first, GLUPsizei count
        );
 
        virtual void draw_elements(
            GLUPprimitive primitive, GLUPsizei count,
            GLUPenum type, const GLUPvoid* indices
        );
 
        virtual Memory::pointer get_state_variable_address(const char* name);
 
        UniformState& uniform_state() {
            return uniform_state_;
        }
 
        const UniformState& uniform_state() const {
            return uniform_state_;
        }
 
        void flag_uniform_buffer_as_dirty() {
            uniform_buffer_dirty_ = true;
        }
 
 
        void flag_lighting_as_dirty() {
            uniform_buffer_dirty_ = true;
            lighting_dirty_ = true;
        }
 
        void flag_matrices_as_dirty() {
            uniform_buffer_dirty_ = true;
            matrices_dirty_ = true;
        }
 
        GLUPdouble* get_matrix(GLUPmatrix matrix) {
            geo_debug_assert(matrix < 3);
            return matrix_stack_[matrix].top();
        }
 
        virtual void get_vertex_shader_preamble_pseudo_file(
            std::vector<GLSL::Source>& sources
        );
 
        virtual void get_fragment_shader_preamble_pseudo_file(
            std::vector<GLSL::Source>& sources
        );
 
        virtual void get_geometry_shader_preamble_pseudo_file(
            std::vector<GLSL::Source>& sources
        );
 
        virtual void get_tess_control_shader_preamble_pseudo_file(
            std::vector<GLSL::Source>& sources
        );
 
        virtual void get_tess_evaluation_shader_preamble_pseudo_file(
            std::vector<GLSL::Source>& sources
        );
 
 
        virtual void get_toggles_pseudo_file(
            std::vector<GLSL::Source>& sources
        );
 
        virtual void get_primitive_pseudo_file(
            std::vector<GLSL::Source>& sources
        );
 
        virtual void get_marching_cells_pseudo_file(
            std::vector<GLSL::Source>& sources
        );
 
        void setup_shaders_source_for_toggles(
            GLUPbitfield toggles_state,
            GLUPbitfield toggles_undetermined=0
        );
 
        virtual void setup_shaders_source_for_primitive(
            GLUPprimitive primitive
        );
 
        ImmediateState& immediate_state() {
            return immediate_state_;
        }
 
        virtual void flush_immediate_buffers();
 
 
        static const char* glup_primitive_name(GLUPprimitive prim);
 
 
    protected:
 
        const MarchingCell& get_marching_cell() const;
 
        bool extension_is_supported(const std::string& extension);
 
        virtual void prepare_to_draw(GLUPprimitive primitive);
 
 
        virtual void done_draw(GLUPprimitive primitive);
 
        virtual void setup_state_variables();
 
 
        virtual void setup_immediate_buffers();
 
        virtual void stream_immediate_buffers();
 
        virtual void setup_primitives();
 
        virtual void setup_GLUP_POINTS();
 
        virtual void setup_GLUP_LINES();
 
        virtual void setup_GLUP_THICK_LINES();
 
        virtual void setup_GLUP_TRIANGLES();
 
        virtual void setup_GLUP_QUADS();
 
        virtual void setup_GLUP_TETRAHEDRA();
 
        virtual void setup_GLUP_HEXAHEDRA();
 
        virtual void setup_GLUP_PRISMS();
 
        virtual void setup_GLUP_PYRAMIDS();
 
        virtual void setup_GLUP_CONNECTORS();
 
        virtual void setup_GLUP_SPHERES();
 
        virtual void set_primitive_info(
            GLUPprimitive glup_primitive, GLenum gl_primitive, GLuint program,
            bool bind_attrib_loc_and_link = true
        );
 
        virtual void set_primitive_info_vertex_gather_mode(
            GLUPprimitive glup_primitive, GLenum gl_primitive, GLuint program
        );
 
        virtual void set_primitive_info_immediate_index_mode(
            GLUPprimitive glup_primitive, GLenum gl_primitive, GLuint program,
            index_t nb_elements_per_glup_primitive,
            index_t* element_indices
        );
 
        void update_uniform_buffer() {
            if(uniform_buffer_dirty_) {
                do_update_uniform_buffer();
            }
        }
 
        virtual void do_update_uniform_buffer();
 
        virtual void update_matrices();
 
        virtual void update_lighting();
 
        virtual void update_base_picking_id(GLint new_value);
 
        std::string primitive_declaration(GLUPprimitive prim) const;
 
        void setup_shaders_source_for_toggles_config(
            PrimitiveInfo::ShaderKey toggles_config
        ) {
            if(toggles_config == (1 << GLUP_PICKING)) {
                setup_shaders_source_for_toggles(
                    (1 << GLUP_PICKING),  // picking=true
                    (1 << GLUP_CLIPPING)  // clipping=undecided (use state)
                );
            } else {
                setup_shaders_source_for_toggles(GLUPbitfield(toggles_config));
            }
        }
 
        void update_toggles_config();
 
        void create_program_if_needed(GLUPprimitive primitive);
 
        void shrink_cells_in_immediate_buffers();
 
        void create_CPU_side_uniform_buffer();
 
        void bind_immediate_state_buffers_to_VAO();
 
        void classify_vertices_in_immediate_buffers();
 
        bool cell_is_clipped(index_t first_v);
 
 
        index_t get_config(index_t first_v, index_t nb_v) {
            index_t result = 0;
            for(index_t lv=0; lv<nb_v; ++lv) {
                if(v_is_visible_[first_v+lv]) {
                    result = result | (1u << lv);
                }
            }
            return result;
        }
 
        void compute_intersection(index_t v1, index_t v2, index_t vi) {
            const GLUPfloat* eqn = world_clip_plane_;
            const GLUPfloat* p1 = immediate_state_.buffer[0].element_ptr(v1);
            const GLUPfloat* p2 = immediate_state_.buffer[0].element_ptr(v2);
 
            GLUPfloat t = -eqn[3] -(
                eqn[0]*p1[0] +
                eqn[1]*p1[1] +
                eqn[2]*p1[2]
            );
 
            GLUPfloat d =
                eqn[0]*(p2[0]-p1[0]) +
                eqn[1]*(p2[1]-p1[1]) +
                eqn[2]*(p2[2]-p1[2]) ;
 
            if(fabs(double(d)) < 1e-6) {
                t = 0.5f;
            } else {
                t /= d;
            }
 
            GLUPfloat s = 1.0f - t;
 
            isect_vertex_attribute_[0][4*vi+0] = s*p1[0] + t*p2[0];
            isect_vertex_attribute_[0][4*vi+1] = s*p1[1] + t*p2[1];
            isect_vertex_attribute_[0][4*vi+2] = s*p1[2] + t*p2[2];
            isect_vertex_attribute_[0][4*vi+3] = 1.0f;
 
            for(index_t i=1; i<3; ++i) {
                if(immediate_state_.buffer[i].is_enabled()) {
                    const GLUPfloat* a1 =
                        immediate_state_.buffer[i].element_ptr(v1);
                    const GLUPfloat* a2 =
                        immediate_state_.buffer[i].element_ptr(v2);
                    isect_vertex_attribute_[i][4*vi+0] = s*a1[0] + t*a2[0];
                    isect_vertex_attribute_[i][4*vi+1] = s*a1[1] + t*a2[1];
                    isect_vertex_attribute_[i][4*vi+2] = s*a1[2] + t*a2[2];
                    isect_vertex_attribute_[i][4*vi+3] = s*a1[3] + t*a2[3];
                }
            }
        }
 
        virtual void copy_uniform_state_to_current_program();
 
        void use_program(GLuint program) {
            if(program != 0 && program != latest_program_) {
                glUseProgram(program);
                latest_program_ = program;
                copy_uniform_state_to_current_program();
            } else {
                glUseProgram(program);
            }
        }
 
        void create_vertex_id_VBO();
 
        static void initialize();
 
    protected:
 
        // OpenGL Uniform state.
        GLuint default_program_;
        GLuint uniform_buffer_;
        GLuint uniform_binding_point_;
        GLint  uniform_buffer_size_;
        bool uniform_buffer_dirty_;
 
        // C++ Uniform state.
        Memory::byte* uniform_buffer_data_;
        UniformState uniform_state_;
 
        bool lighting_dirty_;
 
        // Matrix stacks.
        GLUPmatrix matrix_mode_;
        MatrixStack matrix_stack_[3];
        bool matrices_dirty_;
 
        index_t nb_vertices_per_primitive_[GLUP_NB_PRIMITIVES];
 
        // Immediate mode buffers.
        ImmediateState immediate_state_;
 
        // Primitive informations (i.e., how to
        // draw a primitive of a given type).
        vector<PrimitiveInfo> primitive_info_;
 
        // The marching cells, for computing
        // intersections when clipping mode
        // is GLUP_CLIP_SLICE_CELLS
        MarchingCell marching_tet_;
        MarchingCell marching_hex_;
        MarchingCell marching_prism_;
        MarchingCell marching_pyramid_;
        MarchingCell marching_connector_;
 
        GLuint user_program_;
 
        PrimitiveInfo::ShaderKey toggles_config_;
 
        GLUPprimitive primitive_source_;
        GLUPbitfield toggles_source_state_;
        GLUPbitfield toggles_source_undetermined_;
 
        bool precompile_shaders_;
 
        bool use_core_profile_;
        bool use_ES_profile_;
 
        GLUPfloat* world_clip_plane_;
 
        std::map<std::string, GLsizei> variable_to_offset_;
 
        bool v_is_visible_[IMMEDIATE_BUFFER_SIZE];
 
        GLUPfloat isect_vertex_attribute_[3][12*4];
 
        GLuint latest_program_;
 
        GLuint vertex_id_VBO_;
    };
 
    /*********************************************************************/
}
 
#endif