102 lines
4.3 KiB
C++
102 lines
4.3 KiB
C++
#ifndef _PIPELINE_PROGRAM_H_
|
|
#define _PIPELINE_PROGRAM_H_
|
|
|
|
#include "openGLHeader.h"
|
|
|
|
/*
|
|
CSCI 420 Computer Graphics, University of Southern California
|
|
Jernej Barbic, Bohan Wang, 2020
|
|
|
|
Shader program helper class.
|
|
It loads shaders and properly initializes them in OpenGL.
|
|
*/
|
|
|
|
/* This class stores a set of shaders that serve as the stages of the rendering pipeline.
|
|
The stages are:
|
|
(A) vertex shader (OpenGL 2.0 and higher),
|
|
(B) fragment shader (OpenGL 2.0 and higher),
|
|
(C) geometry shader (OpenGL 3.2 and higher),
|
|
(D) tessellation control shader (OpenGL 4.0 and higher),
|
|
(E) tessellation evaluation shader (OpenGL 4.0 and higher)
|
|
|
|
Note: this is not the actual order of the stages in the pipeline. This order
|
|
is used for historic reasons and to reflect the popularity of each stage,
|
|
with (A) most popularly used, and (E) least popular.
|
|
The actual pipeline order is:
|
|
(A), (D), (E), (C), (B)
|
|
|
|
The shaders are provided either by loading them from a file, or from a C string.
|
|
*/
|
|
|
|
class PipelineProgram
|
|
{
|
|
public:
|
|
PipelineProgram();
|
|
virtual ~PipelineProgram();
|
|
|
|
// Loads the shaders, compiles them, and links them into a pipeline program
|
|
// If a shader is not provided, the pointer should be set to nullptr on input.
|
|
// The provided shaders must come from one of the following choices:
|
|
// (A), (B)
|
|
// (A), (B), (C)
|
|
// (A), (B), (D), (E)
|
|
// (A), (B), (C), (D), (E)
|
|
//
|
|
// Load shaders from a text file.
|
|
// All shaders must reside in the same folder, denoted by "filenameBasePath".
|
|
int BuildShadersFromFiles(const char * filenameBasePath,
|
|
const char * vertexShaderFilename,
|
|
const char * fragmentShaderFilename,
|
|
const char * geometryShaderFilename = nullptr,
|
|
const char * tessellationControlShaderFilename = nullptr,
|
|
const char * tessellationEvaluationShaderFilename = nullptr);
|
|
// Load shaders from a C text string.
|
|
int BuildShadersFromStrings(const char * vertexShaderCode,
|
|
const char * fragmentShaderCode,
|
|
const char * geometryShaderCode = nullptr,
|
|
const char * tessellationControlShaderCode = nullptr,
|
|
const char * tessellationEvaluationShaderCode = nullptr);
|
|
|
|
// Binds (activates) this pipeline program. This means that all the shaders in this pipeline program become active.
|
|
void Bind();
|
|
|
|
// Get the handle to this pipeline program. This is used to disambiguate one pipeline program from another.
|
|
GLuint GetProgramHandle() { return programHandle; }
|
|
|
|
// Get the handle to the uniform shader variable named "name".
|
|
// Uniform variables are shader variables that the *same* for all the vertices, such as the modelview matrix or the projection matrix.
|
|
// Note: this routine will malfunction if you attempt to obtain a handle to a non-uniform variable such as an attribute.
|
|
GLint GetUniformVariableHandle(const char * name);
|
|
|
|
// Set the uniform variable of type "int".
|
|
void SetUniformVariablei(const char * name, int value);
|
|
// Set the uniform variable of type "float".
|
|
void SetUniformVariablef(const char * name, float value);
|
|
// Set the uniform variable of type "float[3]".
|
|
void SetUniformVariable3fv(const char * name, float * value);
|
|
// Set the uniform variable of type "float[4]".
|
|
void SetUniformVariable4fv(const char * name, float * value);
|
|
// Set the uniform variable of type "4x4 matrix of floats" (column-major).
|
|
void SetUniformVariableMatrix4fv(const char * name, GLboolean transpose, float value[16]);
|
|
|
|
protected:
|
|
GLuint programHandle; // the handle to the pipeline program
|
|
|
|
// Load shader from a file into a string.
|
|
int LoadShader(const char * filename, char * code, int len);
|
|
|
|
// Compile a shader.
|
|
// input:
|
|
// code: the shader code
|
|
// shaderType: the type of shader: GL_VERTEX_SHADER, GL_FRAGMENT_SHADER, GL_GEOMETRY_SHADER, GL_TESS_CONTROL_SHADER, GL_TESS_EVALUATION_SHADER
|
|
// output:
|
|
// shaderHandle: the handle to the compiled shader
|
|
// return value: 0=success, non-zero: failure
|
|
int CompileShader(const char * code, GLenum shaderType, GLuint & shaderHandle); // compile a shader
|
|
|
|
virtual int PreLink(); // Custom operations to perform before linking (nothing in most cases).
|
|
};
|
|
|
|
#endif
|
|
|