GLSL.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_BASIC_GLSL
#define GEOGRAM_GFX_BASIC_GLSL
 
#include <geogram_gfx/basic/common.h>
#include <geogram/basic/numeric.h>
 
namespace GEO {
 
    namespace GLSL {
 
        void GEOGRAM_GFX_API initialize();
 
        void GEOGRAM_GFX_API terminate();
 
        struct GEOGRAM_GFX_API GLSLCompileError : std::exception {
 
            const char* what() const GEO_NOEXCEPT override;
        };
 
 
        double GEOGRAM_GFX_API supported_language_version();
 
        /************************************************************/
 
        class Source {
        public:
            Source() : text_(nullptr) {
            }
 
            Source(const char* src) : text_(src) {
            }
 
            Source(const std::string& src) : text_string_(src) {
                text_ = text_string_.c_str();
            }
 
            Source(const Source& rhs) {
                copy(rhs);
            }
 
            Source& operator=(const Source& rhs) {
                if(&rhs != this) {
                    copy(rhs);
                }
                return *this;
            }
 
            const char* text() {
                return text_;
            }
 
        protected:
            void copy(const Source& rhs) {
                if(rhs.text_string_ != "") {
                    text_string_ = rhs.text_string_;
                    text_ = text_string_.c_str();
                } else {
                    text_ = rhs.text_;
                }
            }
 
        private:
            const char* text_;
            std::string text_string_;
        };
 
        class GEOGRAM_GFX_API PseudoFileProvider {
        public:
        virtual ~PseudoFileProvider();
        };
 
        typedef void (*PseudoFile)(
            PseudoFileProvider* provider, std::vector<Source>& sources
        );
 
 
        void GEOGRAM_GFX_API register_GLSL_include_file(
            const std::string& name, const char* source
        );
 
        void GEOGRAM_GFX_API register_GLSL_include_file(
            const std::string& name, PseudoFile file
        );
 
 
        const char* get_GLSL_include_file(
            const std::string& name
        );
 
        GLuint GEOGRAM_GFX_API compile_shader_with_includes(
            GLenum target, const char* source, PseudoFileProvider* provider
        );
 
 
        GLuint GEOGRAM_GFX_API compile_program_with_includes_no_link(
            PseudoFileProvider* provider,
            const char* shader1, const char* shader2 = nullptr, const char* shader3 = nullptr,
            const char* shader4 = nullptr, const char* shader5 = nullptr, const char* shader6 = nullptr
        );
 
 
        /************************************************************/
 
        GLuint GEOGRAM_GFX_API compile_shader(
            GLenum target, const char** sources, index_t nb_sources
        );
 
        GLuint GEOGRAM_GFX_API compile_shader(
            GLenum target,
            const char* source1,
            const char* source2,
            const char* source3 = nullptr,
            const char* source4 = nullptr,
            const char* source5 = nullptr,
            const char* source6 = nullptr,
            const char* source7 = nullptr,
            const char* source8 = nullptr,
            const char* source9 = nullptr,
            const char* source10 = nullptr,
            const char* source11 = nullptr,
            const char* source12 = nullptr,
            const char* source13 = nullptr,
            const char* source14 = nullptr,
            const char* source15 = nullptr,
            const char* source16 = nullptr,
            const char* source17 = nullptr,
            const char* source18 = nullptr,
            const char* source19 = nullptr,
            const char* source20 = nullptr
        );
 
 
        void GEOGRAM_GFX_API link_program(GLuint program);
 
        GLuint GEOGRAM_GFX_API create_program_from_shaders_no_link(
            GLuint shader, ...
        );
 
        GLuint GEOGRAM_GFX_API create_program_from_shaders(GLuint shader, ...);
 
        GLuint GEOGRAM_GFX_API create_program_from_string_no_link(
            const char* string, bool copy_string = true
        );
 
        GLuint GEOGRAM_GFX_API create_program_from_file_no_link(
            const std::string& filename
        );
 
        template <class T> inline bool set_program_uniform_by_name(
            GLuint shader_id, const char* name, T val
        ) {
            geo_argused(shader_id);
            geo_argused(name);
            geo_argused(val);
            geo_assert_not_reached;
            return false;
        }
 
        template<> inline bool set_program_uniform_by_name(
            GLuint shader_id, const char* name, bool val
        ) {
            GLint location = glGetUniformLocation(shader_id, name) ;
            if(location < 0) {
                return false ;
            }
            glUseProgram(shader_id);
            glUniform1i(location, val ? 1 : 0) ;
            glUseProgram(0);
            return true;
        }
 
        template<> inline bool set_program_uniform_by_name(
            GLuint shader_id, const char* name, float val
        ) {
            GLint location = glGetUniformLocation(shader_id, name) ;
            if(location < 0) {
                return false ;
            }
            glUseProgram(shader_id);
            glUniform1f(location, val) ;
            glUseProgram(0);
            return true;
        }
 
        template<> inline bool set_program_uniform_by_name(
            GLuint shader_id, const char* name, double val
        ) {
            GLint location = glGetUniformLocation(shader_id, name) ;
            if(location < 0) {
                return false ;
            }
            glUseProgram(shader_id);
            glUniform1f(location, float(val)) ;
            glUseProgram(0);
            return true;
        }
 
        template<> inline bool set_program_uniform_by_name(
            GLuint shader_id, const char* name, int val
        ) {
            GLint location = glGetUniformLocation(shader_id, name) ;
            if(location < 0) {
                return false ;
            }
            glUseProgram(shader_id);
            glUniform1i(location, val) ;
            glUseProgram(0);
            return true;
        }
 
 
        template<> inline bool set_program_uniform_by_name(
            GLuint shader_id, const char* name, unsigned int val
        ) {
            GLint location = glGetUniformLocation(shader_id, name) ;
            if(location < 0) {
                return false ;
            }
            glUseProgram(shader_id);
#ifdef GEO_GL_150
            glUniform1ui(location, val) ;
#else
            glUniform1i(location, GLint(val)) ;
#endif
            glUseProgram(0);
            return true;
        }
 
        inline bool set_program_uniform_by_name(
            GLuint shader_id, const char* name, index_t count, float* values
        ) {
            GLint location = glGetUniformLocation(shader_id, name) ;
            if(location < 0) {
                return false ;
            }
            glUseProgram(shader_id);
            glUniform1fv(location, GLsizei(count), values) ;
            glUseProgram(0);
            return true;
        }
 
        inline bool set_program_uniform_by_name(
            GLuint shader_id, const char* name, float x, float y
        ) {
            GLint location = glGetUniformLocation(shader_id, name) ;
            if(location < 0) {
                return false ;
            }
            glUseProgram(shader_id);
            glUniform2f(location, x, y);
            glUseProgram(0);
            return true;
        }
 
        GLint GEOGRAM_GFX_API get_uniform_variable_offset(
            GLuint program, const char* varname
        );
 
        size_t GEOGRAM_GFX_API get_uniform_variable_array_stride(
            GLuint program, const char* varname
        );
 
        void GEOGRAM_GFX_API introspect_program(GLuint program);
 
    }
}
 
#endif