bool ParticleSystem::checkProgram(std::string pathName, std::string vertexPath, std::string fragPath){
GLuint shaderProg, vertexShader, fragmentShader;
vertexShader = glCreateShader(GL_VERTEX_SHADER);
fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
const GLchar* adapter[1];
std::string temp = readShaderCode((pathName + vertexPath).c_str());
adapter[0] = temp.c_str();
glShaderSource(vertexShader, 1, adapter, 0);
temp = readShaderCode((pathName + fragPath).c_str());
adapter[0] = temp.c_str();
glShaderSource(fragmentShader, 1, adapter, 0);
glCompileShader(vertexShader);
glCompileShader(fragmentShader);
if(!checkShaderStatus(vertexShader) || !checkShaderStatus(fragmentShader))
return false;
shaderProg = glCreateProgram();
glAttachShader(shaderProg, vertexShader);
glAttachShader(shaderProg, fragmentShader);
glLinkProgram(shaderProg);
if(!checkPogramStatus(shaderProg))
return false;
return true;
}
void BasicTexturedShader::installShader(){
vertexShaderID = glCreateShader(GL_VERTEX_SHADER);
fragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
const GLchar* adapter[1];
std::string temp = readShaderCode("src/Engine/Shader/GLSL/BasicTexturedShaderVertexShader.glsl").c_str();
adapter[0] = temp.c_str();
glShaderSource(vertexShaderID, 1, adapter, 0);
temp = readShaderCode("src/Engine/Shader/GLSL/BasicTexturedShaderFragmentShader.glsl").c_str();
adapter[0] = temp.c_str();
glShaderSource(fragmentShaderID, 1, adapter, 0);
glCompileShader(vertexShaderID);
glCompileShader(fragmentShaderID);
if (!checkShaderStatus(vertexShaderID) | !checkShaderStatus(fragmentShaderID)){
return;
}
programID = glCreateProgram();
glAttachShader(programID, vertexShaderID);
glAttachShader(programID, fragmentShaderID);
glLinkProgram(programID);
glValidateProgram(programID);
if (!checkProgramStatus(programID)){
return;
}
getAllUniformLocations();
}
void
ShaderProgram::createFragmentShader (const std::string& filename)
{
m_fragmentShader = glCreateShader (GL_FRAGMENT_SHADER);
getShaderInformation (filename,m_fragmentShader, false);
glCompileShader (m_fragmentShader);
checkShaderStatus (m_fragmentShader, filename);
}
void
ShaderProgram::createVertexShader (const std::string& filename)
{
m_vertexShader= glCreateShader (GL_VERTEX_SHADER);
getShaderInformation (filename, m_vertexShader, true);
glCompileShader (m_vertexShader);
checkShaderStatus (m_vertexShader, filename);
}
void ParticleSystem::createTransformProgram(std::string pathName){
std::string vertexPath = std::string("/resources/transform.vert");
// shaderTransform.CreateProgramFromFile(vsTransform.c_str());
GLuint vertexShader;
vertexShader = glCreateShader(GL_VERTEX_SHADER);
const GLchar* adapter[1];
std::string temp = readShaderCode((pathName + vertexPath).c_str());
adapter[0] = temp.c_str();
glShaderSource(vertexShader, 1, adapter, 0);
glCompileShader(vertexShader);
if(!checkShaderStatus(vertexShader)){
std::cout.flush();
std::cout << "******** shader error ********" <<std::endl;
exit(0);
}
program_transform = glCreateProgram();
glProgramParameteri(program_transform, GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(program_transform, vertexShader);
//feedback transform
const GLchar* feedbackVaryings[] = { "Position"};
glTransformFeedbackVaryings(program_transform, 1, feedbackVaryings, GL_INTERLEAVED_ATTRIBS);
glLinkProgram(program_transform);
if(!checkPogramStatus(program_transform)){
std::cout.flush();
std::cout << "******** shader error ********" <<std::endl;
exit(0);
}
return true;
}
Shader::Shader(const char *vertexFilename,
const char *fragmentFilename,
const char *geometryFilename,
const char *tesselationCTRLFilename,
const char *tesselationEVALFilename,
const char *computeFilename,
std::vector<std::string> &dynamicDefines)
{
bool errorTrigger = true;
std::string source;
if(computeFilename != NULL)//compute shader
{
computeShader = glCreateShader(GL_COMPUTE_SHADER);
if(!loadShaderSource(computeFilename, source, dynamicDefines))
{
glDeleteShader(computeShader);
return;
}
const char *src = source.c_str();
glShaderSource( computeShader, 1, &src, NULL );
source.clear();
glCompileShader(computeShader);
if(!checkShaderStatus(computeShader, computeFilename))
{
glDeleteShader(computeShader);
return;
}
program = glCreateProgram();
glAttachShader(program, computeShader);
glDeleteShader(computeShader);
}
else//no compute shader
{
if(vertexFilename!=NULL)
{
vertexShader = glCreateShader(GL_VERTEX_SHADER);
if(!loadShaderSource(vertexFilename, source, dynamicDefines))
{
errorTrigger = false;
}
const char *src = source.c_str();
glShaderSource(vertexShader, 1, &src, NULL);
source.clear();
}
if(fragmentFilename != NULL)
{
fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
if(!loadShaderSource(fragmentFilename, source, dynamicDefines))
{
errorTrigger = false;
}
const char *src = source.c_str();
glShaderSource(fragmentShader, 1, &src, NULL);
source.clear();
}
if(geometryFilename != NULL)
{
geometryShader = glCreateShader(GL_GEOMETRY_SHADER);
if(!loadShaderSource(geometryFilename, source, dynamicDefines))
{
errorTrigger = false;
}
const char *src = source.c_str();
glShaderSource(geometryShader, 1, &src, NULL);
source.clear();
}
if(tesselationEVALFilename != NULL)
{
tesselationControlShader = glCreateShader(GL_TESS_CONTROL_SHADER);
tesselationEvaluationShader = glCreateShader(GL_TESS_EVALUATION_SHADER);
if(!loadShaderSource(tesselationCTRLFilename, source, dynamicDefines))
{
errorTrigger = false;
}
const char *src = source.c_str();
glShaderSource(tesselationControlShader, 1, &src, NULL);
source.clear();
if(!loadShaderSource(tesselationEVALFilename, source, dynamicDefines))
errorTrigger=false;
src=source.c_str();
glShaderSource(tesselationEvaluationShader, 1, &src, NULL);
source.clear();
}
if(!errorTrigger)
{
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
glDeleteShader(geometryShader);
glDeleteShader(tesselationControlShader);
glDeleteShader(tesselationEvaluationShader);
return;
}
glCompileShader(vertexShader);
if(fragmentFilename != NULL)
{
glCompileShader(fragmentShader);
}
if(geometryFilename != NULL)
{
glCompileShader(geometryShader);
}
if(tesselationEVALFilename != NULL)
{
glCompileShader(tesselationControlShader);
glCompileShader(tesselationEvaluationShader);
}
if(!checkShaderStatus(vertexShader, vertexFilename))
{
errorTrigger = false;
}
if(fragmentFilename != NULL && !checkShaderStatus(fragmentShader,fragmentFilename))
{
errorTrigger = false;
}
if(geometryFilename != NULL && !checkShaderStatus(geometryShader,geometryFilename))
{
errorTrigger = false;
}
if(tesselationEVALFilename != NULL && !checkShaderStatus(tesselationEvaluationShader, tesselationEVALFilename) && !checkShaderStatus(tesselationControlShader, tesselationCTRLFilename))
{
errorTrigger = false;
}
if(!errorTrigger)
{
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
glDeleteShader(geometryShader);
glDeleteShader(tesselationEvaluationShader);
glDeleteShader(tesselationControlShader);
return;
}
program = glCreateProgram();
glAttachShader(program,vertexShader);
if(fragmentFilename!=NULL)
{
glAttachShader(program,fragmentShader);
}
if(geometryFilename!=NULL)
{
glAttachShader(program,geometryShader);
}
if(tesselationEVALFilename!=NULL)
{
glAttachShader(program, tesselationControlShader);
glAttachShader(program, tesselationEvaluationShader);
}
glDeleteShader(vertexShader);
if(fragmentFilename != NULL)
{
glDeleteShader(fragmentShader);
}
if(geometryFilename != NULL)
{
glDeleteShader(geometryShader);
}
if(tesselationEVALFilename != NULL)
{
glDeleteShader(tesselationControlShader);
glDeleteShader(tesselationEvaluationShader);
}
}
//equal for normal and compute shader
glLinkProgram(program);
GLint testVal;
glGetProgramiv(program, GL_LINK_STATUS,&testVal);
if(testVal == GL_FALSE)
{
char errorLog[1024];
glGetProgramInfoLog(program, 1024, NULL, errorLog);
if(vertexFilename != NULL)
{
QLOG_ERROR_NOCONTEXT() << "Error linking shader program " << vertexFilename << " because of:\n "<< errorLog;
}
else
{
QLOG_ERROR_NOCONTEXT() << "Error linking shader program " << computeFilename << " because of:\n "<< errorLog;
}
glDeleteProgram(program);
}
}
