KiCad PCB EDA Suite
KIGFX::SHADER Class Reference

Class SHADER provides the access to the OpenGL shaders. More...

#include <shader.h>

Public Member Functions

 SHADER ()
 Constructor. More...
 
virtual ~SHADER ()
 Destructor. More...
 
template<typename... Args>
bool LoadShaderFromStrings (SHADER_TYPE aShaderType, Args &&... aArgs)
 Add a shader and compile the shader sources. More...
 
bool LoadShaderFromFile (SHADER_TYPE aShaderType, const std::string &aShaderSourceName)
 Loads one of the built-in shaders and compiles it. More...
 
bool Link ()
 Link the shaders. More...
 
bool IsLinked () const
 Returns true if shaders are linked correctly. More...
 
void Use ()
 Use the shader. More...
 
void Deactivate ()
 Deactivate the shader and use the default OpenGL program. More...
 
bool IsActive () const
 Returns the current state of the shader. More...
 
void ConfigureGeometryShader (GLuint maxVertices, GLuint geometryInputType, GLuint geometryOutputType)
 Configure the geometry shader - has to be done before linking! More...
 
int AddParameter (const std::string &aParameterName)
 Add a parameter to the parameter queue. More...
 
void SetParameter (int aParameterNumber, float aValue) const
 Set a parameter of the shader. More...
 
void SetParameter (int aParameterNumber, int aValue) const
 
void SetParameter (int aParameterNumber, const VECTOR2D &aValue) const
 
void SetParameter (int aParameterNumber, float f0, float f1, float f2, float f3) const
 
int GetAttribute (const std::string &aAttributeName) const
 Gets an attribute location. More...
 

Static Public Member Functions

static std::string ReadSource (const std::string &aShaderSourceName)
 Read the shader source file. More...
 

Private Member Functions

bool loadShaderFromStringArray (SHADER_TYPE aShaderType, const char **aArray, size_t aSize)
 Compile vertex of fragment shader source code into the program. More...
 
void programInfo (GLuint aProgram)
 Get the shader program information. More...
 
void shaderInfo (GLuint aShader)
 Get the shader information. More...
 

Private Attributes

std::deque< GLuint > shaderNumbers
 Shader number list. More...
 
GLuint programNumber
 Shader program number. More...
 
bool isProgramCreated
 Flag for program creation. More...
 
bool isShaderLinked
 Is the shader linked? More...
 
bool active
 Is any of shaders used? More...
 
GLuint maximumVertices
 The maximum of vertices to be generated. More...
 
GLuint geomInputType
 Input type [e.g. GL_LINES, GL_TRIANGLES, GL_QUADS etc.]. More...
 
GLuint geomOutputType
 Output type [e.g. GL_LINES, GL_TRIANGLES, GL_QUADS etc.]. More...
 
std::deque< GLint > parameterLocation
 Location of the parameter. More...
 

Detailed Description

Class SHADER provides the access to the OpenGL shaders.

The purpose of this class is advanced drawing with OpenGL. One example is using the pixel shader for drawing exact circles or for anti-aliasing. This class supports vertex, geometry and fragment shaders.
Make sure that the hardware supports these features. This can be identified with the "GLEW" library.

Definition at line 76 of file shader.h.

Constructor & Destructor Documentation

◆ SHADER()

SHADER::SHADER ( )

Constructor.

Definition at line 41 of file shader.cpp.

41  :
42  isProgramCreated( false ),
43  isShaderLinked( false ),
44  active( false ),
45  maximumVertices( 4 ),
46  geomInputType( GL_LINES ),
47  geomOutputType( GL_LINES )
48 
49 {
50  // Do not have uninitialized members:
51  programNumber = 0;
52 }
GLuint geomInputType
Input type [e.g. GL_LINES, GL_TRIANGLES, GL_QUADS etc.].
Definition: shader.h:234
GLuint geomOutputType
Output type [e.g. GL_LINES, GL_TRIANGLES, GL_QUADS etc.].
Definition: shader.h:235
bool isShaderLinked
Is the shader linked?
Definition: shader.h:231
GLuint maximumVertices
The maximum of vertices to be generated.
Definition: shader.h:233
bool isProgramCreated
Flag for program creation.
Definition: shader.h:230
GLuint programNumber
Shader program number.
Definition: shader.h:229
bool active
Is any of shaders used?
Definition: shader.h:232

References programNumber.

◆ ~SHADER()

SHADER::~SHADER ( )
virtual

Destructor.

Definition at line 55 of file shader.cpp.

56 {
57  if( active )
58  Deactivate();
59 
60  if( isProgramCreated )
61  {
62  // Delete the shaders and the program
63  for( std::deque<GLuint>::iterator it = shaderNumbers.begin();
64  it != shaderNumbers.end(); ++it )
65  {
66  GLuint shader = *it;
67 
68  if( glIsShader( shader ) )
69  {
70  glDetachShader( programNumber, shader );
71  glDeleteShader( shader );
72  }
73  }
74 
75  glDeleteProgram( programNumber );
76  }
77 }
std::deque< GLuint > shaderNumbers
Shader number list.
Definition: shader.h:228
void Deactivate()
Deactivate the shader and use the default OpenGL program.
Definition: shader.h:141
bool isProgramCreated
Flag for program creation.
Definition: shader.h:230
GLuint programNumber
Shader program number.
Definition: shader.h:229
bool active
Is any of shaders used?
Definition: shader.h:232

References active, Deactivate(), isProgramCreated, programNumber, and shaderNumbers.

Member Function Documentation

◆ AddParameter()

int SHADER::AddParameter ( const std::string &  aParameterName)

Add a parameter to the parameter queue.

To communicate with the shader use this function to set up the names for the uniform variables. These are queued in a list and can be assigned with the SetParameter(..) method using the queue position.

Parameters
aParameterNameis the name of the parameter.
Returns
the added parameter location.

Definition at line 126 of file shader.cpp.

127 {
128  GLint location = glGetUniformLocation( programNumber, aParameterName.c_str() );
129 
130  if( location >= 0 )
131  parameterLocation.push_back( location );
132  else
133  throw std::runtime_error( "Could not find shader uniform: " + aParameterName );
134 
135  return parameterLocation.size() - 1;
136 }
GLuint programNumber
Shader program number.
Definition: shader.h:229
std::deque< GLint > parameterLocation
Location of the parameter.
Definition: shader.h:236

References parameterLocation, and programNumber.

Referenced by KIGFX::OPENGL_GAL::beginDrawing().

◆ ConfigureGeometryShader()

void SHADER::ConfigureGeometryShader ( GLuint  maxVertices,
GLuint  geometryInputType,
GLuint  geometryOutputType 
)

Configure the geometry shader - has to be done before linking!

Parameters
maxVerticesis the maximum of vertices to be generated.
geometryInputTypeis the input type [e.g. GL_LINES, GL_TRIANGLES, GL_QUADS etc.]
geometryOutputTypeis the output type [e.g. GL_LINES, GL_TRIANGLES, GL_QUADS etc.]

Definition at line 88 of file shader.cpp.

90 {
91  maximumVertices = maxVertices;
92  geomInputType = geometryInputType;
93  geomOutputType = geometryOutputType;
94 }
GLuint geomInputType
Input type [e.g. GL_LINES, GL_TRIANGLES, GL_QUADS etc.].
Definition: shader.h:234
GLuint geomOutputType
Output type [e.g. GL_LINES, GL_TRIANGLES, GL_QUADS etc.].
Definition: shader.h:235
GLuint maximumVertices
The maximum of vertices to be generated.
Definition: shader.h:233

References geomInputType, geomOutputType, and maximumVertices.

◆ Deactivate()

void KIGFX::SHADER::Deactivate ( )
inline

Deactivate the shader and use the default OpenGL program.

Definition at line 141 of file shader.h.

142  {
143  glUseProgram( 0 );
144  active = false;
145  }
bool active
Is any of shaders used?
Definition: shader.h:232

References active.

Referenced by KIGFX::OPENGL_GAL::beginDrawing(), KIGFX::GPU_CACHED_MANAGER::EndDrawing(), KIGFX::GPU_NONCACHED_MANAGER::EndDrawing(), and ~SHADER().

◆ GetAttribute()

int SHADER::GetAttribute ( const std::string &  aAttributeName) const

Gets an attribute location.

Parameters
aAttributeNameis the name of the attribute.
Returns
the location.

Definition at line 168 of file shader.cpp.

169 {
170  return glGetAttribLocation( programNumber, aAttributeName.c_str() );
171 }
GLuint programNumber
Shader program number.
Definition: shader.h:229

References programNumber.

Referenced by KIGFX::GPU_MANAGER::SetShader().

◆ IsActive()

bool KIGFX::SHADER::IsActive ( ) const
inline

Returns the current state of the shader.

Returns
True if any of shaders is enabled.

Definition at line 152 of file shader.h.

153  {
154  return active;
155  }
bool active
Is any of shaders used?
Definition: shader.h:232

References active.

◆ IsLinked()

bool KIGFX::SHADER::IsLinked ( ) const
inline

Returns true if shaders are linked correctly.

Definition at line 124 of file shader.h.

125  {
126  return isShaderLinked;
127  }
bool isShaderLinked
Is the shader linked?
Definition: shader.h:231

References isShaderLinked.

Referenced by KIGFX::OPENGL_GAL::init().

◆ Link()

bool SHADER::Link ( )

Link the shaders.

Returns
true in case of success, false otherwise.

Definition at line 97 of file shader.cpp.

98 {
99  // Shader linking
100  glLinkProgram( programNumber );
102 
103  // Check the Link state
104  GLint tmp;
105  glGetObjectParameterivARB( programNumber, GL_OBJECT_LINK_STATUS_ARB, &tmp );
106  isShaderLinked = !!tmp;
107 
108 #ifdef DEBUG
109  if( !isShaderLinked )
110  {
111  int maxLength;
112  glGetProgramiv( programNumber, GL_INFO_LOG_LENGTH, &maxLength );
113  maxLength = maxLength + 1;
114  char* linkInfoLog = new char[maxLength];
115  glGetProgramInfoLog( programNumber, maxLength, &maxLength, linkInfoLog );
116  std::cerr << "Shader linking error:" << std::endl;
117  std::cerr << linkInfoLog;
118  delete[] linkInfoLog;
119  }
120 #endif /* DEBUG */
121 
122  return isShaderLinked;
123 }
void programInfo(GLuint aProgram)
Get the shader program information.
Definition: shader.cpp:174
bool isShaderLinked
Is the shader linked?
Definition: shader.h:231
GLuint programNumber
Shader program number.
Definition: shader.h:229

References isShaderLinked, programInfo(), and programNumber.

Referenced by KIGFX::OPENGL_GAL::init().

◆ LoadShaderFromFile()

bool SHADER::LoadShaderFromFile ( SHADER_TYPE  aShaderType,
const std::string &  aShaderSourceName 
)

Loads one of the built-in shaders and compiles it.

Parameters
aShaderSourceNameis the shader source file name.
aShaderTypeis the type of the shader.
Returns
True in case of success, false otherwise.

Definition at line 79 of file shader.cpp.

80 {
81  // Load shader sources
82  const std::string shaderSource = ReadSource( aShaderSourceName );
83 
84  return LoadShaderFromStrings( aShaderType, shaderSource );
85 }
bool LoadShaderFromStrings(SHADER_TYPE aShaderType, Args &&... aArgs)
Add a shader and compile the shader sources.
Definition: shader.h:99
static std::string ReadSource(const std::string &aShaderSourceName)
Read the shader source file.
Definition: shader.cpp:216

References LoadShaderFromStrings(), and ReadSource().

◆ loadShaderFromStringArray()

bool SHADER::loadShaderFromStringArray ( SHADER_TYPE  aShaderType,
const char **  aArray,
size_t  aSize 
)
private

Compile vertex of fragment shader source code into the program.

Definition at line 238 of file shader.cpp.

240 {
241  assert( !isShaderLinked );
242 
243  // Create the program
244  if( !isProgramCreated )
245  {
246  programNumber = glCreateProgram();
247  isProgramCreated = true;
248  }
249 
250  // Create a shader
251  GLuint shaderNumber = glCreateShader( aShaderType );
252  shaderNumbers.push_back( shaderNumber );
253 
254  // Get the program info
256 
257  // Attach the sources
258  glShaderSource( shaderNumber, aSize, (const GLchar**) aArray, NULL );
260 
261  // Compile and attach shader to the program
262  glCompileShader( shaderNumber );
263  GLint status;
264  glGetShaderiv( shaderNumber, GL_COMPILE_STATUS, &status );
265 
266  if( status != GL_TRUE )
267  {
268  shaderInfo( shaderNumber );
269 
270  GLint maxLength = 0;
271  glGetShaderiv( shaderNumber, GL_INFO_LOG_LENGTH, &maxLength );
272 
273  // The maxLength includes the NULL character
274  std::vector<GLchar> errorLog( (size_t) maxLength );
275  glGetShaderInfoLog( shaderNumber, maxLength, &maxLength, &errorLog[0] );
276 
277  // Provide the infolog in whatever manor you deem best.
278  // Exit with failure.
279  glDeleteShader( shaderNumber ); // Don't leak the shader.
280 
281  throw std::runtime_error( &errorLog[0] );
282  }
283 
284  glAttachShader( programNumber, shaderNumber );
286 
287  // Special handling for the geometry shader
288  if( aShaderType == SHADER_TYPE_GEOMETRY )
289  {
290  glProgramParameteriEXT( programNumber, GL_GEOMETRY_VERTICES_OUT_EXT, maximumVertices );
291  glProgramParameteriEXT( programNumber, GL_GEOMETRY_INPUT_TYPE_EXT, geomInputType );
292  glProgramParameteriEXT( programNumber, GL_GEOMETRY_OUTPUT_TYPE_EXT, geomOutputType );
293  }
294 
295  return true;
296 }
GLuint geomInputType
Input type [e.g. GL_LINES, GL_TRIANGLES, GL_QUADS etc.].
Definition: shader.h:234
GLuint geomOutputType
Output type [e.g. GL_LINES, GL_TRIANGLES, GL_QUADS etc.].
Definition: shader.h:235
void programInfo(GLuint aProgram)
Get the shader program information.
Definition: shader.cpp:174
bool isShaderLinked
Is the shader linked?
Definition: shader.h:231
GLuint maximumVertices
The maximum of vertices to be generated.
Definition: shader.h:233
#define NULL
std::deque< GLuint > shaderNumbers
Shader number list.
Definition: shader.h:228
void shaderInfo(GLuint aShader)
Get the shader information.
Definition: shader.cpp:195
Geometry shader.
Definition: shader.h:48
bool isProgramCreated
Flag for program creation.
Definition: shader.h:230
GLuint programNumber
Shader program number.
Definition: shader.h:229

References geomInputType, geomOutputType, isProgramCreated, isShaderLinked, maximumVertices, NULL, programInfo(), programNumber, KIGFX::SHADER_TYPE_GEOMETRY, shaderInfo(), and shaderNumbers.

Referenced by LoadShaderFromStrings().

◆ LoadShaderFromStrings()

template<typename... Args>
bool KIGFX::SHADER::LoadShaderFromStrings ( SHADER_TYPE  aShaderType,
Args &&...  aArgs 
)
inline

Add a shader and compile the shader sources.

Parameters
aArgsis the list of strings (std::string or convertible to const char*) which are concatenated and compiled as a single shader source code.
aShaderTypeis the type of the shader.
Returns
True in case of success, false otherwise.

Definition at line 99 of file shader.h.

100  {
101  const char* arr[] = { DETAIL::translateStringArg( aArgs )... };
102  return loadShaderFromStringArray( aShaderType, arr, sizeof...(Args) );
103  }
bool loadShaderFromStringArray(SHADER_TYPE aShaderType, const char **aArray, size_t aSize)
Compile vertex of fragment shader source code into the program.
Definition: shader.cpp:238
const char * translateStringArg(const std::string &str)
Definition: shader.h:53

References loadShaderFromStringArray(), and KIGFX::DETAIL::translateStringArg().

Referenced by KIGFX::OPENGL_GAL::init(), and LoadShaderFromFile().

◆ programInfo()

void SHADER::programInfo ( GLuint  aProgram)
private

Get the shader program information.

Parameters
aProgramis the program number.

Definition at line 174 of file shader.cpp.

175 {
176  GLint glInfoLogLength = 0;
177  GLint writtenChars = 0;
178 
179  // Get the length of the info string
180  glGetProgramiv( aProgram, GL_INFO_LOG_LENGTH, &glInfoLogLength );
181 
182  // Print the information
183  if( glInfoLogLength > 2 )
184  {
185  GLchar* glInfoLog = new GLchar[glInfoLogLength];
186  glGetProgramInfoLog( aProgram, glInfoLogLength, &writtenChars, glInfoLog );
187 
188  std::cerr << glInfoLog << std::endl;
189 
190  delete[] glInfoLog;
191  }
192 }
int PGM_BASE * aProgram
Definition: cvpcb/cvpcb.cpp:97

References aProgram.

Referenced by Link(), and loadShaderFromStringArray().

◆ ReadSource()

std::string SHADER::ReadSource ( const std::string &  aShaderSourceName)
static

Read the shader source file.

Parameters
aShaderSourceNameis the shader source file name.
Returns
the source as string

Definition at line 216 of file shader.cpp.

217 {
218  // Open the shader source for reading
219  std::ifstream inputFile( aShaderSourceName.c_str(), std::ifstream::in );
220  std::string shaderSource;
221 
222  if( !inputFile )
223  throw std::runtime_error( "Can't read the shader source: " + aShaderSourceName );
224 
225  std::string shaderSourceLine;
226 
227  // Read all lines from the text file
228  while( getline( inputFile, shaderSourceLine ) )
229  {
230  shaderSource += shaderSourceLine;
231  shaderSource += "\n";
232  }
233 
234  return shaderSource;
235 }

Referenced by LoadShaderFromFile().

◆ SetParameter() [1/4]

void SHADER::SetParameter ( int  aParameterNumber,
float  aValue 
) const

Set a parameter of the shader.

Parameters
aParameterNumberis the number of the parameter.
aValueis the value of the parameter.

Definition at line 139 of file shader.cpp.

140 {
141  assert( (unsigned) parameterNumber < parameterLocation.size() );
142 
143  glUniform1f( parameterLocation[parameterNumber], value );
144 }
std::deque< GLint > parameterLocation
Location of the parameter.
Definition: shader.h:236

References parameterLocation.

Referenced by KIGFX::OPENGL_GAL::beginDrawing().

◆ SetParameter() [2/4]

void SHADER::SetParameter ( int  aParameterNumber,
int  aValue 
) const

Definition at line 147 of file shader.cpp.

148 {
149  assert( (unsigned) parameterNumber < parameterLocation.size() );
150 
151  glUniform1i( parameterLocation[parameterNumber], value );
152 }
std::deque< GLint > parameterLocation
Location of the parameter.
Definition: shader.h:236

References parameterLocation.

◆ SetParameter() [3/4]

void SHADER::SetParameter ( int  aParameterNumber,
const VECTOR2D aValue 
) const

Definition at line 161 of file shader.cpp.

162 {
163  assert( (unsigned)aParameterNumber < parameterLocation.size() );
164  glUniform2f( parameterLocation[aParameterNumber], aValue.x, aValue.y );
165 }
std::deque< GLint > parameterLocation
Location of the parameter.
Definition: shader.h:236

References parameterLocation, VECTOR2< T >::x, and VECTOR2< T >::y.

◆ SetParameter() [4/4]

void SHADER::SetParameter ( int  aParameterNumber,
float  f0,
float  f1,
float  f2,
float  f3 
) const

Definition at line 154 of file shader.cpp.

155 {
156  assert( (unsigned)parameterNumber < parameterLocation.size() );
157  float arr[4] = { f0, f1, f2, f3 };
158  glUniform4fv( parameterLocation[parameterNumber], 1, arr );
159 }
std::deque< GLint > parameterLocation
Location of the parameter.
Definition: shader.h:236

References parameterLocation.

◆ shaderInfo()

void SHADER::shaderInfo ( GLuint  aShader)
private

Get the shader information.

Parameters
aShaderis the shader number.

Definition at line 195 of file shader.cpp.

196 {
197  GLint glInfoLogLength = 0;
198  GLint writtenChars = 0;
199 
200  // Get the length of the info string
201  glGetShaderiv( aShader, GL_INFO_LOG_LENGTH, &glInfoLogLength );
202 
203  // Print the information
204  if( glInfoLogLength > 2 )
205  {
206  GLchar* glInfoLog = new GLchar[glInfoLogLength];
207  glGetShaderInfoLog( aShader, glInfoLogLength, &writtenChars, glInfoLog );
208 
209  std::cerr << glInfoLog << std::endl;
210 
211  delete[] glInfoLog;
212  }
213 }

Referenced by loadShaderFromStringArray().

◆ Use()

void KIGFX::SHADER::Use ( )
inline

Use the shader.

Definition at line 132 of file shader.h.

133  {
134  glUseProgram( programNumber );
135  active = true;
136  }
GLuint programNumber
Shader program number.
Definition: shader.h:229
bool active
Is any of shaders used?
Definition: shader.h:232

References active, and programNumber.

Referenced by KIGFX::OPENGL_GAL::beginDrawing(), KIGFX::GPU_CACHED_MANAGER::EndDrawing(), and KIGFX::GPU_NONCACHED_MANAGER::EndDrawing().

Member Data Documentation

◆ active

bool KIGFX::SHADER::active
private

Is any of shaders used?

Definition at line 232 of file shader.h.

Referenced by Deactivate(), IsActive(), Use(), and ~SHADER().

◆ geomInputType

GLuint KIGFX::SHADER::geomInputType
private

Input type [e.g. GL_LINES, GL_TRIANGLES, GL_QUADS etc.].

Definition at line 234 of file shader.h.

Referenced by ConfigureGeometryShader(), and loadShaderFromStringArray().

◆ geomOutputType

GLuint KIGFX::SHADER::geomOutputType
private

Output type [e.g. GL_LINES, GL_TRIANGLES, GL_QUADS etc.].

Definition at line 235 of file shader.h.

Referenced by ConfigureGeometryShader(), and loadShaderFromStringArray().

◆ isProgramCreated

bool KIGFX::SHADER::isProgramCreated
private

Flag for program creation.

Definition at line 230 of file shader.h.

Referenced by loadShaderFromStringArray(), and ~SHADER().

◆ isShaderLinked

bool KIGFX::SHADER::isShaderLinked
private

Is the shader linked?

Definition at line 231 of file shader.h.

Referenced by IsLinked(), Link(), and loadShaderFromStringArray().

◆ maximumVertices

GLuint KIGFX::SHADER::maximumVertices
private

The maximum of vertices to be generated.

Definition at line 233 of file shader.h.

Referenced by ConfigureGeometryShader(), and loadShaderFromStringArray().

◆ parameterLocation

std::deque<GLint> KIGFX::SHADER::parameterLocation
private

Location of the parameter.

Definition at line 236 of file shader.h.

Referenced by AddParameter(), and SetParameter().

◆ programNumber

GLuint KIGFX::SHADER::programNumber
private

Shader program number.

Definition at line 229 of file shader.h.

Referenced by AddParameter(), GetAttribute(), Link(), loadShaderFromStringArray(), SHADER(), Use(), and ~SHADER().

◆ shaderNumbers

std::deque<GLuint> KIGFX::SHADER::shaderNumbers
private

Shader number list.

Definition at line 228 of file shader.h.

Referenced by loadShaderFromStringArray(), and ~SHADER().


The documentation for this class was generated from the following files: