bool GLHelper::setUpShaders(const ShaderDesc* shaderDescs, size_t numShaders) {
mShaderPrograms = new GLuint[numShaders];
bool result = true;
for (size_t i = 0; i < numShaders && result; i++) {
GLuint vs, fs;
result = compileShaderLines(GL_VERTEX_SHADER,
shaderDescs[i].vertexShader, &vs);
if (!result) {
return false;
}
result = compileShaderLines(GL_FRAGMENT_SHADER,
shaderDescs[i].fragmentShader, &fs);
if (!result) {
glDeleteShader(vs);
return false;
}
result = linkShaderProgram(vs, fs, &mShaderPrograms[i]);
glDeleteShader(vs);
glDeleteShader(fs);
}
mNumShaders = numShaders;
mShaderDescs = shaderDescs;
return result;
}
void Shader::build()
{
m_vertexShader = compileVertexShader(m_strVertexShader->cstr());
m_fragmentShader = compileFragmentShader(m_strFragmentShader->cstr());
m_shaderProgram = linkShaderProgram(m_vertexShader, m_fragmentShader);
const SPVRTPFXUniformSemantic* semantics = PVRTPFXSemanticsGetSemanticList();
for (int i = 0; i < m_uniforms->count(); ++i)
{
SPVRTPFXUniform& uniform = m_uniforms->get(i);
const SPVRTPFXUniformSemantic& semantic = semantics[uniform.nSemantic];
if (semantic.isAttrib)
{
uniform.nLocation = glGetAttribLocation(m_shaderProgram, uniform.sValueName->cstr());
m_isAttributeRequired[semantic.n] = true;
++m_numAttributesRequired;
}
else
{
uniform.nLocation = glGetUniformLocation(m_shaderProgram, uniform.sValueName->cstr());
// Check for array. Workaround for some OpenGL:ES implementations which require array element appended to uniform name
// in order to return the correct location.
if (uniform.nLocation == -1)
{
ByteArray* szTmpUniformName = ByteArray::create(uniform.sValueName->cstr());
szTmpUniformName->append("[0]");
uniform.nLocation = glGetUniformLocation(m_shaderProgram, szTmpUniformName->cstr());
}
}
}
}
inline GLuint makeShaderProgram(const std::string &profile, const std::vector<GLenum> &stypes, const std::string &source) {
GLuint prog = glCreateProgram();
auto get_define = [](GLenum stype) {
switch (stype) {
case GL_VERTEX_SHADER:
return "_VERTEX_";
case GL_GEOMETRY_SHADER:
return "_GEOMETRY_";
case GL_TESS_CONTROL_SHADER:
return "_TESS_CONTROL_";
case GL_TESS_EVALUATION_SHADER:
return "_TESS_EVALUATION_";
case GL_FRAGMENT_SHADER:
return "_FRAGMENT_";
default:
return "_INVALID_SHADER_TYPE_";
}
};
for (auto stype : stypes) {
std::ostringstream oss;
oss << "#version " << profile << std::endl;
oss << "#define " << get_define(stype) << std::endl;
oss << source;
auto shader = compileShader(stype, oss.str());
glAttachShader(prog, shader);
}
linkShaderProgram(prog);
std::cout << "SimpleShader : " << "Shader program compiled and linked successfully" << std::endl;
return prog;
}
MyAppView::MyAppView(const MyAppModel& model, const MyAppSharedContext& sharedContext, const VRGraphicsState &renderState) : model(model), sharedContext(sharedContext) {
// Init GL
glEnable(GL_DEPTH_TEST);
glClearDepth(1.0f);
glDepthFunc(GL_LEQUAL);
glClearColor(0, 0, 0, 1);
// Create vao
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glBindBuffer(GL_ARRAY_BUFFER, sharedContext.getVbo());
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (char*)0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (char*)0 + sizeof(GLfloat)*model.vertices.size());
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (char*)0 + sizeof(GLfloat)*model.vertices.size() + sizeof(GLfloat)*model.normals.size());
// Create shader
std::string vertexShader =
"#version 330 \n"
"layout(location = 0) in vec3 position; "
"layout(location = 1) in vec3 normal; "
"layout(location = 2) in vec3 color; "
""
"uniform mat4 ProjectionMatrix; "
"uniform mat4 ViewMatrix; "
"uniform mat4 ModelMatrix; "
"uniform mat4 NormalMatrix; "
""
"out vec3 col;"
""
"void main() { "
" gl_Position = ProjectionMatrix*ViewMatrix*ModelMatrix*vec4(position, 1.0); "
" col = color;"
"}";
vshader = compileShader(vertexShader, GL_VERTEX_SHADER);
std::string fragmentShader =
"#version 330 \n"
"in vec3 col;"
"out vec4 colorOut;"
""
"void main() { "
" colorOut = vec4(col, 1.0); "
"}";
fshader = compileShader(fragmentShader, GL_FRAGMENT_SHADER);
// Create shader program
shaderProgram = glCreateProgram();
glAttachShader(shaderProgram, vshader);
glAttachShader(shaderProgram, fshader);
linkShaderProgram(shaderProgram);
}
inline GLuint makeShaderProgram(const std::vector<GLenum> &stypes, const std::vector<std::string> &sources) {
if (stypes.size() != sources.size()) {
throw std::runtime_error("Error: stypes and shader sources, vector size mismatch");
}
GLuint prog = glCreateProgram();
for (size_t i = 0; i < stypes.size(); ++i) {
auto shader = compileShader(stypes[i], sources[i]);
glAttachShader(prog, shader);
}
linkShaderProgram(prog);
std::cout << "SimpleShader : " << "Shader program compiled and linked successfully" << std::endl;
return prog;
}
// Takes the shader paths for better error logs
Shader::Shader(const std::string& name,
const std::string& vertexShaderPath,
const std::string& fragmentShaderPath)
{
mName = name;
std::string vertexShaderCode = Utils::getFileContents(vertexShaderPath);
std::string fragmentShaderCode = Utils::getFileContents(fragmentShaderPath);
GLuint vertexShader = compileShader(vertexShaderPath, vertexShaderCode, GL_VERTEX_SHADER); // Is this length stuff right?
GLuint fragmentShader = compileShader(fragmentShaderPath, fragmentShaderCode, GL_FRAGMENT_SHADER);
if(vertexShader!=0 && fragmentShader!=0) // Valid shaders
mID = linkShaderProgram(mName, vertexShader, fragmentShader);
else
mID = 0; // Make sure it doesn't blow up. Error messages should have already been sent.
}
