gVXR-core/2.0.10/_shader_8h_source.html

 /*

 Copyright (c) 2017, Dr Franck P. Vidal (franck.p.vidal@fpvidal.net),
 http://www.fpvidal.net/
 All rights reserved.

 Redistribution and use in source and binary forms, with or without modification,
 are permitted provided that the following conditions are met:

 1. Redistributions of source code must retain the above copyright notice,
 this list of conditions and the following disclaimer.

 2. 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.

 3. Neither the name of the Bangor University 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.

 */


 #ifndef __Shader_h
 #define __Shader_h


 //******************************************************************************
 //  Include
 //******************************************************************************
 #ifndef __gVirtualXRayConfig_h
 #include "gVirtualXRay/gVirtualXRayConfig.h"
 #endif

 #include <string>


 //******************************************************************************
 //  namespace
 //******************************************************************************
 namespace gVirtualXRay {


 //==============================================================================
 //==============================================================================
 class Shader
 //------------------------------------------------------------------------------
 {
 //******************************************************************************
 public:
     //--------------------------------------------------------------------------
     //--------------------------------------------------------------------------
     Shader();


     //--------------------------------------------------------------------------
     //--------------------------------------------------------------------------
     ~Shader();


     //--------------------------------------------------------------------------
     //--------------------------------------------------------------------------
     void enable() const;


     //--------------------------------------------------------------------------
     //--------------------------------------------------------------------------
     static void disable();


     //--------------------------------------------------------------------------
     //--------------------------------------------------------------------------
     void release();


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     void loadFiles(const std::string& aVertexShaderFilename,
                    const std::string& aFragmentShaderFilename);


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     void loadFile(const std::string& aComputeShaderFilename);


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     void setLabels(const std::string& aVertexShaderLabel,
                    const std::string& aFragmentShaderLabel);


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     void setLabel(const std::string& aComputeShaderLabel);


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     void loadVertexShaderFile(const std::string& aVertexShaderFilename);


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     void loadFragmentShaderFile(const std::string& aFragmentShaderFilename);


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     void loadComputeShaderFile(const std::string& aComputeShaderFilename);


     //--------------------------------------------------------------------------

      //--------------------------------------------------------------------------
     void loadSource(const std::string& aVertexShaderSourceCode,
         const std::string& aFragmentShaderSourceCode);


     //--------------------------------------------------------------------------

      //--------------------------------------------------------------------------
     void loadSource(const std::string& aComputeShaderSourceCode);


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     void loadVertexShaderSource(const std::string& aVertexShaderSourceCode);


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     void loadFragmentShaderSource(const std::string& aFragmentShaderSourceCode);


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     void loadComputeShaderSource(const std::string& aComputeShaderSourceCode);


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     unsigned int getProgramHandle() const;


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     bool isValid() const;


 //******************************************************************************
 protected:
     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     int loadFile(const std::string& aShaderFilename, char**& aShaderSource);


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     unsigned int compileShader(int aShaderType,
                                int aLineNumber,
                                char** aShaderSource);


     //--------------------------------------------------------------------------
     //--------------------------------------------------------------------------
     void linkProgram();


     //--------------------------------------------------------------------------
     //--------------------------------------------------------------------------
     void releaseVertexSourceMemory();


     //--------------------------------------------------------------------------
     //--------------------------------------------------------------------------
     void releaseFragmentSourceMemory();


     //--------------------------------------------------------------------------
     //--------------------------------------------------------------------------
     void releaseComputeSourceMemory();


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     void releaseSourceMemory(int& aLineNumber, char**& aShaderSource);


     static bool m_shader_capable;


     std::string m_vertex_shader_label;


     std::string m_fragment_shader_label;


     std::string m_compute_shader_label;


     std::string m_vertex_shader_filename;


     std::string m_fragment_shader_filename;


     std::string m_compute_shader_filename;


     char **m_vertex_source;


     int m_vertex_source_number_of_lines;


     char **m_fragment_source;


     int m_fragment_source_number_of_lines;


     char **m_compute_source;


     int m_compute_source_number_of_lines;


     bool m_valid;


     unsigned int m_shader_program_id;


     unsigned int m_vertex_shader_id;


     unsigned int m_fragment_shader_id;


     unsigned int m_compute_shader_id;
 };


 } // namespace gVirtualXRay


 //******************************************************************************
 #include "Shader.inl"


 #endif // __Shader_h
gVirtualXRay::Shader::loadFiles
void loadFiles(const std::string &aVertexShaderFilename, const std::string &aFragmentShaderFilename)
Load the vertex and fragment shaders from files.

gVirtualXRay::Shader::releaseComputeSourceMemory
void releaseComputeSourceMemory()
Release the memory held by the compute shader.
Definition: Shader.inl:119

gVirtualXRay::Shader::releaseFragmentSourceMemory
void releaseFragmentSourceMemory()
Release the memory held by the fragment shader.
Definition: Shader.inl:111

gVirtualXRay::Shader::m_vertex_shader_id
unsigned int m_vertex_shader_id
ID of the vertex shader.
Definition: Shader.h:380

gVirtualXRay::Shader::loadVertexShaderFile
void loadVertexShaderFile(const std::string &aVertexShaderFilename)
Load the vertex shader from a file.

gVirtualXRay::Shader::loadFile
void loadFile(const std::string &aComputeShaderFilename)
Load the compute shader from a file.

gVirtualXRay::Shader::m_shader_program_id
unsigned int m_shader_program_id
ID of the shader program.
Definition: Shader.h:376

gVirtualXRay::Shader::m_vertex_shader_filename
std::string m_vertex_shader_filename
Name of the file containing the vertex shader.
Definition: Shader.h:334

gVirtualXRay::Shader::disable
static void disable()
Disable the current shader (if any)

gVirtualXRay::Shader::loadFragmentShaderSource
void loadFragmentShaderSource(const std::string &aFragmentShaderSourceCode)
Load the fragment shader from a string.

gVirtualXRay::Shader::m_compute_shader_filename
std::string m_compute_shader_filename
Name of the file containing the compute shader.
Definition: Shader.h:342

gVirtualXRay::Shader::loadFragmentShaderFile
void loadFragmentShaderFile(const std::string &aFragmentShaderFilename)
Load the fragment shader from a file.

gVirtualXRay::Shader::~Shader
~Shader()
Destructor.

gVirtualXRay::Shader::m_vertex_source_number_of_lines
int m_vertex_source_number_of_lines
Number of line of the vertex shader.
Definition: Shader.h:350

gVirtualXRay::Shader::setLabel
void setLabel(const std::string &aComputeShaderLabel)
Set the compute shader label. This is useful for debugging.
Definition: Shader.inl:79

gVirtualXRay::Shader::m_compute_shader_id
unsigned int m_compute_shader_id
ID of the compute shader.
Definition: Shader.h:388

gVirtualXRay::Shader::isValid
bool isValid() const
Accessor on the validity status of the shader.
Definition: Shader.inl:95

gVirtualXRay::Shader::m_fragment_source
char ** m_fragment_source
Source code of the fragment shader.
Definition: Shader.h:354

gVirtualXRay::Shader::m_fragment_shader_filename
std::string m_fragment_shader_filename
Name of the file containing the fragment shader.
Definition: Shader.h:338

gVirtualXRay::Shader::linkProgram
void linkProgram()
Link the vertex and fragment programs.

Shader.inl
Class to handle GLSL shaders.

gVirtualXRay::Shader::m_vertex_shader_label
std::string m_vertex_shader_label
Label of the vertex shader.
Definition: Shader.h:322

gVirtualXRay::Shader::loadComputeShaderSource
void loadComputeShaderSource(const std::string &aComputeShaderSourceCode)
Load the compute shader from a string.

gVirtualXRay::Shader::compileShader
unsigned int compileShader(int aShaderType, int aLineNumber, char **aShaderSource)
Compile the vertex shader or the fragment shader.

gVirtualXRay::Shader
Shader is a class to handle shaders written in GLSL.
Definition: Shader.h:87

gVirtualXRay::Shader::Shader
Shader()
Default constructor.

gVirtualXRay
Definition: AnatomicalMesh.h:73

gVirtualXRay::Shader::m_vertex_source
char ** m_vertex_source
Source code of the vertex shader.
Definition: Shader.h:346

gVirtualXRay::Shader::m_fragment_source_number_of_lines
int m_fragment_source_number_of_lines
Number of line of the fragment shader.
Definition: Shader.h:358

gVirtualXRay::Shader::release
void release()

gVirtualXRay::Shader::m_compute_source_number_of_lines
int m_compute_source_number_of_lines
Number of line of the vertex shader.
Definition: Shader.h:366

gVirtualXRay::Shader::m_fragment_shader_id
unsigned int m_fragment_shader_id
ID of the fragment shader.
Definition: Shader.h:384

gVirtualXRay::Shader::m_compute_shader_label
std::string m_compute_shader_label
Label of the compute shader.
Definition: Shader.h:330

gVirtualXRay::Shader::enable
void enable() const
Enable the current shader.

gVirtualXRay::Shader::getProgramHandle
unsigned int getProgramHandle() const
Accessor on the shader program handle.
Definition: Shader.inl:87

gVirtualXRay::Shader::loadComputeShaderFile
void loadComputeShaderFile(const std::string &aComputeShaderFilename)
Load the compute shader from a file.

gVirtualXRay::Shader::m_compute_source
char ** m_compute_source
Source code of the vertex shader.
Definition: Shader.h:362

gVirtualXRay::Shader::releaseSourceMemory
void releaseSourceMemory(int &aLineNumber, char **&aShaderSource)
Release the memory held by the vertex shader or the fragment shader.

gVirtualXRay::Shader::m_fragment_shader_label
std::string m_fragment_shader_label
Label of the fragment shader.
Definition: Shader.h:326

gVirtualXRay::Shader::loadSource
void loadSource(const std::string &aVertexShaderSourceCode, const std::string &aFragmentShaderSourceCode)
Load the shader source code.

gVirtualXRay::Shader::m_shader_capable
static bool m_shader_capable
Flag set to true when a shader if fully valid.
Definition: Shader.h:318

gVirtualXRay::Shader::m_valid
bool m_valid
Definition: Shader.h:372

gVirtualXRay::Shader::setLabels
void setLabels(const std::string &aVertexShaderLabel, const std::string &aFragmentShaderLabel)
Set the vertex and fragment shader labels. This is useful for debugging.
Definition: Shader.inl:69

gVirtualXRay::Shader::releaseVertexSourceMemory
void releaseVertexSourceMemory()
Release the memory held by the vertex shader.
Definition: Shader.inl:103

gVirtualXRay::Shader::loadVertexShaderSource
void loadVertexShaderSource(const std::string &aVertexShaderSourceCode)
Load the vertex shader from a string.

gVirtualXRayConfig.h