asteroidgen/vendor/gl/GlShaders.h

330 lines
8.3 KiB
C
Raw Normal View History

/************************************************************************************
Authors : Bradley Austin Davis <bdavis@saintandreas.org>
Copyright : Copyright Brad Davis. All Rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
************************************************************************************/
#pragma once
#ifndef GL_ZERO
#error "You must include the gl headers before including this file"
#endif
#include <glm/glm.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <string>
#include <map>
#include <algorithm>
#include <stdexcept>
#include <set>
#include <memory>
namespace gl {
struct Var {
std::string name;
GLint size;
GLenum type;
GLuint id;
GLint location;
// for map usage
Var()
: location(0), type(0), size(0), id(0) {
}
Var(bool uniform, GLuint program, GLuint id) {
this->id = id;
static GLchar MY_BUFFER[8192];
GLsizei bufSize = 8192;
if (uniform) {
glGetActiveUniform(program, id, bufSize, &bufSize, &size, &type,
MY_BUFFER);
} else {
glGetActiveAttrib(program, id, bufSize, &bufSize, &size, &type,
MY_BUFFER);
}
name = std::string(MY_BUFFER, bufSize);
if (uniform) {
location = glGetUniformLocation(program, name.c_str());
} else {
location = glGetAttribLocation(program, name.c_str());
}
}
};
class Shader {
friend class Program;
GLenum type;
GLuint shader;
std::string source;
public:
Shader(GLenum type, const std::string & source)
: type(type), shader(0), source(source) {
// Create the shader object
GLuint newShader = glCreateShader(type);
if (newShader == 0) {
throw std::runtime_error("Unable to create shader object");
}
{
static const char * c_str;
// std::string shaderSrc = Files::read(fileName);
// Load the shader source
glShaderSource(newShader, 1, &(c_str = source.c_str()), NULL);
}
// Compile the shader
glCompileShader(newShader);
// Check the compile status
GLint compiled;
glGetShaderiv(newShader, GL_COMPILE_STATUS, &compiled);
if (!compiled) {
std::string log = getLog(newShader);
throw shader_error(shader, log);
}
if (0 != shader) {
glDeleteShader(shader);
}
shader = newShader;
}
virtual ~Shader() {
glDeleteShader(shader);
}
static std::string getLog(GLuint shader) {
std::string log;
GLint infoLen = 0;
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
if (infoLen > 1) {
char* infoLog = new char[infoLen];
glGetShaderInfoLog(shader, infoLen, NULL, infoLog);
log = std::string(infoLog);
delete[] infoLog;
}
return log;
}
};
typedef std::shared_ptr<Shader> ShaderPtr;
namespace Attribute {
enum {
Position = 0,
TexCoord0 = 1,
Normal = 2,
Color = 3,
TexCoord1 = 4,
};
}
class Program {
typedef std::map<std::string, Var> Map;
typedef std::set<std::string> Set;
ShaderPtr vs;
ShaderPtr fs;
GLuint program;
Map uniforms;
Map attributes;
Set configuredUniforms;
public:
GLint getUniformLocation(const std::string & name) const {
return uniforms.count(name) ? uniforms.at(name).location : -1;
}
GLint getAttributeLocation(const std::string & name) const {
return attributes.count(name) ? attributes.at(name).location : -1;
}
public:
static std::string getLog(GLuint program) {
std::string log;
GLint infoLen = 0;
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLen);
if (infoLen > 1) {
char* infoLog = new char[infoLen];
glGetProgramInfoLog(program, infoLen, NULL, infoLog);
log = std::string(infoLog);
delete[] infoLog;
}
return log;
}
public:
Program(const ShaderPtr & vs, const ShaderPtr & fs)
: vs(vs), fs(fs), program(0) {
if (0 != program) {
glDeleteProgram(program);
program = 0;
}
// Create the program object
program = glCreateProgram();
if (program == 0)
throw std::runtime_error("Failed to allocate gl program");
glAttachShader(program, vs->shader);
glAttachShader(program, fs->shader);
// Bind vPosition to attribute 0
glBindAttribLocation(program, 0, "vPosition");
// Link the newProgram
glLinkProgram(program);
// Check the link status
GLint linked;
glGetProgramiv(program, GL_LINK_STATUS, &linked);
if (!linked) {
std::string log = getLog(program);
throw std::runtime_error(log);
}
int numVars;
glGetProgramiv(program, GL_ACTIVE_ATTRIBUTES, &numVars);
for (int i = 0; i < numVars; ++i) {
Var var(false, program, i);
// SAY("Found attribute %s at location %d", var.name.c_str(), var.location);
attributes[var.name] = var;
}
glGetProgramiv(program, GL_ACTIVE_UNIFORMS, &numVars);
for (int i = 0; i < numVars; ++i) {
Var var(true, program, i);
//SAY("Found uniform %s at location %d", var.name.c_str(), var.location);
uniforms[var.name] = var;
}
}
virtual ~Program() {
glDeleteProgram(program);
}
void setUniform(const std::string & name, GLfloat a) {
configuredUniforms.insert(name);
GLint location = getUniformLocation(name);
glUniform1f(location, a);
}
void setUniform(const std::string & name, GLint a) {
configuredUniforms.insert(name);
GLint location = getUniformLocation(name);
glUniform1i(location, a);
}
void setUniform(const std::string & name, bool a) {
configuredUniforms.insert(name);
GLint location = getUniformLocation(name);
glUniform1i(location, a ? 1 : 0);
}
void setUniform(const std::string & name, const glm::vec2 & a) {
configuredUniforms.insert(name);
GLint location = getUniformLocation(name);
glUniform2f(location, a.x, a.y);
}
void setUniform(const std::string & name, const glm::vec3 & a) {
configuredUniforms.insert(name);
GLint location = getUniformLocation(name);
glUniform3f(location, a.x, a.y, a.z);
}
void setUniform(const std::string & name, const glm::vec4 & a) {
configuredUniforms.insert(name);
GLint location = getUniformLocation(name);
glUniform4f(location, a.x, a.y, a.z, a.w);
}
void setUniform(const std::string & name, const std::vector<glm::vec4> & a) {
configuredUniforms.insert(name);
GLint location = getUniformLocation(name);
glUniform4fv(location, (GLsizei) a.size(), &(a[0][0]));
}
void setUniform(const std::string & name, const glm::mat4 & a) {
configuredUniforms.insert(name);
GLint location = getUniformLocation(name);
glUniformMatrix4fv(location, 1, GL_FALSE, glm::value_ptr(a));
}
inline void setUniform1f(const std::string & name, GLfloat a) {
setUniform(name, a);
}
inline void setUniform1i(const std::string & name, GLint a) {
setUniform(name, a);
}
inline void setUniform2f(const std::string & name, const glm::vec2 & a) {
setUniform(name, a);
}
inline void setUniform4f(const std::string & name, const glm::vec4 & a) {
setUniform(name, a);
}
inline void setUniform3f(const std::string & name, const glm::vec3 & a) {
setUniform(name, a);
}
inline void setUniform4fv(const std::string & name, const std::vector<glm::vec4> & a) {
setUniform(name, a);
}
inline void setUniform4x4f(const std::string & name, const glm::mat4 & a) {
setUniform(name, a);
}
void checkConfigured() {
Set existingUniforms;
// Option #2
std::for_each(std::begin(uniforms), std::end(uniforms),
[&] (Map::const_reference element)
{
existingUniforms.insert(element.first);
});
std::for_each(std::begin(configuredUniforms),
std::end(configuredUniforms), [&] (Set::const_reference element)
{
existingUniforms.erase(element);
});
// assert(existingUniforms.size() == 0);
}
void use() {
glUseProgram(program);
}
static void clear() {
glUseProgram(0);
}
};
typedef std::shared_ptr<Program> ProgramPtr;
} // gl