GLuint makeShaderFromSource(
const char* vert,
const char* frag,
const char* geom)
{
std::cout << " vs-";
GLuint vertSrc = loadShaderFile(vert, GL_VERTEX_SHADER);
printShaderInfoLog(vertSrc);
std::cout << " fs-";
GLuint fragSrc = loadShaderFile(frag, GL_FRAGMENT_SHADER);
printShaderInfoLog(fragSrc);
// Vertex and fragment shaders are required
if ((vertSrc == 0) || (fragSrc == 0))
{
std::cout << " SHADER NOT COMPILED - source not found." << std::endl;
return 0;
}
//std::cout << " gs: ";
GLuint geomSrc = loadShaderFile(geom, GL_GEOMETRY_SHADER_EXT);
GLuint program = glCreateProgram();
glCompileShader(vertSrc);
glCompileShader(fragSrc);
GLint success = 0;
glGetShaderiv(vertSrc, GL_COMPILE_STATUS, &success);
assert(success == GL_TRUE);
glGetShaderiv(fragSrc, GL_COMPILE_STATUS, &success);
assert(success == GL_TRUE);
glAttachShader(program, vertSrc);
glAttachShader(program, fragSrc);
// Will be deleted when program is.
glDeleteShader(vertSrc);
glDeleteShader(fragSrc);
// Initialize Geometry shader state after creation, before linking.
if (geomSrc)
{
std::cout << " gs-";
printShaderInfoLog(geomSrc);
glCompileShader(geomSrc);
glAttachShader (program, geomSrc);
}
glLinkProgram(program);
std::cout << " prog: ";
printProgramInfoLog(program);
std::cout << std::endl;
glUseProgram(0);
return program;
}
/// Append any applicable suffixes to the name given and attempt to find
/// vertex, fragment and (optionally) geometry shader source.
GLuint makeShaderByName(const char* name)
{
if (!name)
return 0;
std::string vs(name);
std::string fs(name);
std::string gs(name);
vs += ".vert";
fs += ".frag";
gs += ".geom";
std::cout << std::endl
<< "makeShaderByName("
<< vs
<< ", "
<< fs
<< ", "
<< gs
<< "):__"
<< std::endl;
GLuint vertSrc = loadShaderFile(vs.c_str(), GL_VERTEX_SHADER);
GLuint fragSrc = loadShaderFile(fs.c_str(), GL_FRAGMENT_SHADER);
GLuint geomSrc = loadShaderFile(gs.c_str(), GL_GEOMETRY_SHADER_EXT);
printShaderInfoLog(vertSrc);
printShaderInfoLog(fragSrc);
GLuint program = glCreateProgram();
glCompileShader(vertSrc);
glCompileShader(fragSrc);
glAttachShader(program, vertSrc);
glAttachShader(program, fragSrc);
// Will be deleted when program is.
glDeleteShader(vertSrc);
glDeleteShader(fragSrc);
// Initialize Geometry shader state after creation, before linking.
if (geomSrc)
{
printShaderInfoLog(geomSrc);
glCompileShader(geomSrc);
glAttachShader (program, geomSrc);
}
glLinkProgram(program);
printProgramInfoLog(program);
glUseProgram(0);
return program;
}
void Shader::load(const std::string& vertexFile, const std::string& fragmentFile, const uint glslVersion)
{
TRACE_INFO("Loading shader from: " << vertexFile << ", " << fragmentFile, 0);
if (!GLEW_ARB_vertex_shader || !GLEW_ARB_fragment_shader)
{
TRACE_ERROR("Error: Cannot find GLEW_ARB_vertex_shader and GLEW_ARB_fragment_shader.", 0);
TRACE_ERROR("Error: Probably not initialized glew.", 0);
return;
}
//creation of shaders and program
const GLuint vertexShaderHandle = loadShaderFile(GL_VERTEX_SHADER, (const char*) vertexFile.c_str(), glslVersion);
const GLuint fragmentShaderHandle = loadShaderFile(GL_FRAGMENT_SHADER, (const char*) fragmentFile.c_str(), glslVersion);
// create the program object
m_shaderProg = glCreateProgram();
glAttachShader(m_shaderProg, vertexShaderHandle);
glAttachShader(m_shaderProg, fragmentShaderHandle);
// link the program
glLinkProgram(m_shaderProg);
// check the link status
GLint isLinked;
glGetProgramiv(m_shaderProg, GL_LINK_STATUS, &isLinked);
if (!isLinked)
{
GLint infoLen = 0;
glGetProgramiv(m_shaderProg, GL_INFO_LOG_LENGTH, &infoLen);
if (infoLen > 1)
{
char* infoLog = new char[sizeof(char) * infoLen];
glGetProgramInfoLog(m_shaderProg, infoLen, nullptr, infoLog);
TRACE_ERROR("Error: Error linking program:" << std::endl << infoLog, 0);
delete[] infoLog;
}
glDeleteProgram(m_shaderProg);
return;
}
setupCommonUniforms();
}
bool loadShaderCode(const char* vertProgramCode, GLuint &vertProgram, const char* fragmentProgramCode, GLuint &fragProgram) {
vertProgram = loadShaderFile(vertProgramCode, GL_VERTEX_SHADER);
fragProgram = loadShaderFile(fragmentProgramCode, GL_FRAGMENT_SHADER);
if (vertProgram == 0) {
std::cout << "(initShader) - Could not create vertex shader." << std::endl;
deleteShader();
return false;
}
if (fragProgram == 0) {
std::cout << "(initShader) - Could not create fragment shader." << std::endl;
deleteShader();
return false;
}
return true;
}
GLuint makeShaderFromSource(
const char* vert,
const char* frag,
const char* geom)
{
std::cout << " vs-";
GLuint vertSrc = loadShaderFile(vert, GL_VERTEX_SHADER);
printShaderInfoLog(vertSrc);
std::cout << " fs-";
GLuint fragSrc = loadShaderFile(frag, GL_FRAGMENT_SHADER);
printShaderInfoLog(fragSrc);
//std::cout << " gs: ";
GLuint geomSrc = loadShaderFile(geom, GL_GEOMETRY_SHADER_EXT);
GLuint program = glCreateProgram();
glCompileShader(vertSrc);
glCompileShader(fragSrc);
glAttachShader(program, vertSrc);
glAttachShader(program, fragSrc);
// Will be deleted when program is.
glDeleteShader(vertSrc);
glDeleteShader(fragSrc);
// Initialize Geometry shader state after creation, before linking.
if (geomSrc)
{
std::cout << " gs-";
printShaderInfoLog(geomSrc);
glCompileShader(geomSrc);
glAttachShader (program, geomSrc);
}
glLinkProgram(program);
std::cout << " prog: ";
printProgramInfoLog(program);
std::cout << std::endl;
glUseProgram(0);
return program;
}
void initShader() {
shaderProgram = glCreateProgram();
// check if operation failed //
if (shaderProgram == 0) {
std::cout << "(initShader) - Failed creating shader program." << std::endl;
return;
}
GLuint vertexShader = loadShaderFile("../shader/simple.vert", GL_VERTEX_SHADER);
if (vertexShader == 0) {
std::cout << "(initShader) - Could not create vertex shader." << std::endl;
deleteShader();
return;
}
GLuint fragmentShader = loadShaderFile("../shader/simple.frag", GL_FRAGMENT_SHADER);
if (fragmentShader == 0) {
std::cout << "(initShader) - Could not create vertex shader." << std::endl;
deleteShader();
return;
}
// successfully loaded and compiled shaders -> attach them to program //
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
// mark shaders for deletion after clean up (they will be deleted, when detached from all shader programs) //
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
// link shader program //
glLinkProgram(shaderProgram);
// set address of fragment color output //
glBindFragDataLocation(shaderProgram, 0, "color");
}
void GLWidget::loadShaders(QString file)
{
if (data.fsh) {
glDeleteShader(data.fsh);
glDetachShader(data.program, data.fsh);
}
if (!data.vsh) {
qDebug("Loading vertex shader...");
data.vsh = loadShaderFile(GL_VERTEX_SHADER, RESPFX "vertex.vsh");
}
qDebug(QString("Loading fragment shader: %1...").arg(file).toLocal8Bit());
data.fsh = loadShaderFile(GL_FRAGMENT_SHADER, file);
if (data.vsh == 0 || data.fsh == 0)
return;
glAttachShader(data.program, data.vsh);
glAttachShader(data.program, data.fsh);
qDebug() << "Linking program...";
glLinkProgram(data.program);
int logLength;
glGetProgramiv(data.program, GL_INFO_LOG_LENGTH, &logLength);
char log[logLength];
glGetProgramInfoLog(data.program, logLength, &logLength, log);
qWarning(log);
data.loc.vertex = glGetAttribLocation(data.program, "vertex");
data.loc.projection = glGetUniformLocation(data.program, "projection");
data.loc.dim = glGetUniformLocation(data.program, "DIM");
data.loc.zoom = glGetUniformLocation(data.program, "zoom");
data.loc.animation = glGetUniformLocation(data.program, "animation");
data.loc.position = glGetUniformLocation(data.program, "position");
glEnableVertexAttribArray(data.loc.vertex);
glUseProgram(data.program);
}
// this function loads only the certex and fragment programs and like the above it sets the vertex attribute locations
// in the rare case you want to set these yourself then use any number you like above lets say 5, its really 1 but i might add support for like just vertex + texture and such later on
// one thing to note is that the program is not linked, that function is lower down
unsigned int glzShaderLoad(std::string const file_vert, std::string const file_frag, glzVAOType type)
{
glzAppinitialization app;
if(!isinited_shd) ini_shd();
unsigned int program;
program = glCreateProgram();
loadShaderFile(program, file_vert, glzShadertype::VERTEX_SHADER);
loadShaderFile(program, file_frag, glzShadertype::FRAGMENT_SHADER);
if (type == glzVAOType::AUTO)
{
glBindAttribLocation(program, 0, "Position");
glBindAttribLocation(program, 1, "TexCoord");
glBindAttribLocation(program, 2, "Normal");
}
return program;
}
GLuint Shader::CreateShader(const GLenum shaderType, const GLchar* shaderPath)
{
GLuint shader = glCreateShader(shaderType);
std::string shaderCode;
loadShaderFile(shaderPath, shaderCode);
char const * shaderSource = shaderCode.c_str();
glShaderSource(shader, 1, &shaderSource, NULL);
glCompileShader(shader);
GLint result;
GLchar infoLog[512];
glGetShaderiv(shader, GL_COMPILE_STATUS, &result);
if(!result)
{
glGetShaderInfoLog(shader, 512, NULL, infoLog);
std::cout << "ERROR: " << shaderPath << std::endl;
std::cout << infoLog << std::endl;
}
return shader;
}
void initShader() {
shaderProgram = glCreateProgram();
// check if operation failed //
if (shaderProgram == 0) {
std::cout << "(initShader) - Failed creating shader program." << std::endl;
return;
}
GLuint vertexShader = loadShaderFile("../shader/texture.vert", GL_VERTEX_SHADER);
if (vertexShader == 0) {
std::cout << "(initShader) - Could not create vertex shader." << std::endl;
deleteShader();
return;
}
GLuint fragmentShader = loadShaderFile("../shader/texture.frag", GL_FRAGMENT_SHADER);
if (fragmentShader == 0) {
std::cout << "(initShader) - Could not create vertex shader." << std::endl;
deleteShader();
return;
}
// successfully loaded and compiled shaders -> attach them to program //
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
// mark shaders for deletion after clean up (they will be deleted, when detached from all shader programs) //
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
// link shader program //
glLinkProgram(shaderProgram);
// get log //
int logMaxLength;
glGetProgramiv(shaderProgram, GL_INFO_LOG_LENGTH, &logMaxLength);
char log[logMaxLength];
int logLength = 0;
glGetProgramInfoLog(shaderProgram, logMaxLength, &logLength, log);
if (logLength > 0) {
std::cout << "(initShader) - Linker log:\n------------------\n" << log << "\n------------------" << std::endl;
}
// set address of fragment color output //
glBindFragDataLocation(shaderProgram, 0, "color");
// get uniform locations for common variables //
uniformLocations["projection"] = glGetUniformLocation(shaderProgram, "projection");
uniformLocations["modelview"] = glGetUniformLocation(shaderProgram, "modelview");
// material unform locations //
uniformLocations["material.ambient"] = glGetUniformLocation(shaderProgram, "material.ambient_color");
uniformLocations["material.diffuse"] = glGetUniformLocation(shaderProgram, "material.diffuse_color");
uniformLocations["material.specular"] = glGetUniformLocation(shaderProgram, "material.specular_color");
uniformLocations["material.shininess"] = glGetUniformLocation(shaderProgram, "material.specular_shininess");
// store the uniform locations for all light source properties
for (int i = 0; i < 10; ++i) {
UniformLocation_Light lightLocation;
lightLocation.ambient_color = glGetUniformLocation(shaderProgram, getUniformStructLocStr("lightSource", "ambient_color", i).c_str());
lightLocation.diffuse_color = glGetUniformLocation(shaderProgram, getUniformStructLocStr("lightSource", "diffuse_color", i).c_str());
lightLocation.specular_color = glGetUniformLocation(shaderProgram, getUniformStructLocStr("lightSource", "specular_color", i).c_str());
lightLocation.position = glGetUniformLocation(shaderProgram, getUniformStructLocStr("lightSource", "position", i).c_str());
std::stringstream sstr("");
sstr << "light_" << i;
uniformLocations_Lights[sstr.str()] = lightLocation;
}
uniformLocations["usedLightCount"] = glGetUniformLocation(shaderProgram, "usedLightCount");
// get texture uniform location //
uniformLocations["tex"] = glGetUniformLocation(shaderProgram,"tex");
}
void initShader() {
shaderProgram = glCreateProgram();
// check if operation failed //
if (shaderProgram == 0) {
std::cout << "(initShader) - Failed creating shader program." << std::endl;
return;
}
GLuint vertexShader = loadShaderFile("../shader/material_and_light.vert", GL_VERTEX_SHADER);
if (vertexShader == 0) {
std::cout << "(initShader) - Could not create vertex shader." << std::endl;
deleteShader();
return;
}
GLuint fragmentShader = loadShaderFile("../shader/material_and_light.frag", GL_FRAGMENT_SHADER);
if (fragmentShader == 0) {
std::cout << "(initShader) - Could not create vertex shader." << std::endl;
deleteShader();
return;
}
// successfully loaded and compiled shaders -> attach them to program //
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
// mark shaders for deletion after clean up (they will be deleted, when detached from all shader programs) //
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
// link shader program //
glLinkProgram(shaderProgram);
// get log //
/*int logMaxLength;
glGetProgramiv(shaderProgram, GL_INFO_LOG_LENGTH, &logMaxLength);
char log[logMaxLength];
int logLength = 0;
glGetProgramInfoLog(shaderProgram, logMaxLength, &logLength, log);
if (logLength > 0) {
std::cout << "(initShader) - Linker log:\n------------------\n" << log << "\n------------------" << std::endl;
}*/
// set address of fragment color output //
glBindFragDataLocation(shaderProgram, 0, "color");
// get uniform locations for common variables //
uniformLocations["projection"] = glGetUniformLocation(shaderProgram, "projection");
uniformLocations["modelview"] = glGetUniformLocation(shaderProgram, "modelview");
// TODO: insert the uniform locations for all light and material properties
// - insert then into the provided map 'uniformLocations' and give them a proper identifier
// - when accessing a GLSL uniform within a struct (as used in the provided vertex shader),
// use the following technique: glGetUniformLocation(shaderID, "structName.propertyName")
// So, when having a struct
// struct MyStruct {vec3 MyVector};
// and a uniform declaration
// uniform MyStruct MyStructUniform;
// you can get the location of MyVector by passing the string "MyStructUniform.MyVector" to
// glGetUniformLocation(...)
uniformLocations["lightSource.ambient_color"] = glGetUniformLocation(shaderProgram, "lightSource.ambient_color");
uniformLocations["lightSource.diffuse_color"] = glGetUniformLocation(shaderProgram, "lightSource.diffuse_color");
uniformLocations["lightSource.specular_color"] = glGetUniformLocation(shaderProgram, "lightSource.specular_color");
uniformLocations["lightSource.position"] = glGetUniformLocation(shaderProgram, "lightSource.position");
uniformLocations["material.ambient_color"] = glGetUniformLocation(shaderProgram, "material.ambient_color");
uniformLocations["material.diffuse_color"] = glGetUniformLocation(shaderProgram, "material.diffuse_color");
uniformLocations["material.specular_color"] = glGetUniformLocation(shaderProgram, "material.specular_color");
uniformLocations["material.specular_shininess"] = glGetUniformLocation(shaderProgram, "material.specular_shininess");
}
