int ProgramGLSL::insertVertexShader(std::string _vsPath)
{
//TODO: Check if vertex shader is already compiled
if(_vsPath == "")
return -1;
//create vertex shader
GLuint vs = glCreateShader(GL_VERTEX_SHADER);
//read vertex shader code from file
std::string vertexShaderCode;
std::ifstream vertexShaderStream(_vsPath, std::ios::in);
if(vertexShaderStream.is_open())
{
std::string line = "";
while(getline(vertexShaderStream, line))
vertexShaderCode += "\n" + line;
vertexShaderStream.close();
}
else
{
printf("file %s not found\n", _vsPath.c_str());
}
GLint result = GL_FALSE;
int infoLogLength;
//Compile vertex shader
printf("Compiling vertex shader: %s\n", _vsPath.c_str());
const char *vertexSourcePtr = vertexShaderCode.c_str();
glShaderSource(vs, 1, &vertexSourcePtr, NULL);
glCompileShader(vs);
//check vertex shader
glGetShaderiv(vs, GL_COMPILE_STATUS, &result);
glGetShaderiv(vs, GL_INFO_LOG_LENGTH, &infoLogLength);
std::vector<char> vertexShaderErrorMessage(infoLogLength);
fprintf(stdout, "Shader Message: %s\n", &vertexShaderErrorMessage[0]);
if(result == GL_TRUE)
{
VSstruct v;
v.name = _vsPath;
v.vertexShader = vs;
vertexShaders->push_back(v);
printf("successfully compiled vertex shader: %s\n\n", _vsPath.c_str());
return (int)vs;
}
else
{
printf("failed to compile vertex shader %s\n\n", _vsPath.c_str());
}
//return something else if failed? or maybe throw exeption... we'll see
return -1;
}
char* Renderer::LoadShaderFromAssets(const string * path)
{
string prefix = "shaders/";
string suffix = ".glsl";
string fPath = prefix + *path + suffix;
// f**k you, assetmanager
#ifdef PLATFORM_WINDOWS
fPath = Renderer::GetInstance()->ASSET_PATH + fPath;
string sCode;
ifstream vertexShaderStream(fPath.c_str(), ios::in);
if (vertexShaderStream.is_open())
{
string Line = "";
while (getline(vertexShaderStream, Line))
{
if (Line == "#version 300 es")
{
Line = "#version 330 core";
}
sCode += "\n" + Line;
}
vertexShaderStream.close();
}
int length = sCode.length();
char* ret = new char[length + 1];
strcpy(ret, sCode.c_str());
ret[length] = '\0';
return ret;
#else
AAssetManager* mgr = System::GetInstance()->GetEngineData()->app->activity->assetManager;
AAsset* shaderAsset = AAssetManager_open(mgr, fPath.c_str(), AASSET_MODE_UNKNOWN);
unsigned int length = AAsset_getLength(shaderAsset);
char * code = new char[length + 1];
AAsset_read(shaderAsset, (void*)code, length);
code[length] = '\0';
return code;
#endif
}
void Shader::createShader(const std::string& shaderFile)
{
_vertexShaderID = glCreateShader(GL_VERTEX_SHADER);
_fragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
std::string vertexShaderCode;
std::ifstream vertexShaderStream(shaderFile+".vert", std::ios::in);
if (vertexShaderStream.is_open())
{
std::string line = "";
while (std::getline(vertexShaderStream, line))
vertexShaderCode += "\n" + line;
vertexShaderStream.close();
}
std::string fragmentShaderCode;
std::ifstream fragmentShaderStream(shaderFile + ".frag", std::ios::in);
if (fragmentShaderStream.is_open())
{
std::string line = "";
while (std::getline(fragmentShaderStream, line))
fragmentShaderCode += "\n" + line;
fragmentShaderStream.close();
}
compileShader(vertexShaderCode, fragmentShaderCode);
checkShaderError();
linkShader();
glDeleteShader(_vertexShaderID);
glDeleteShader(_fragmentShaderID);
}
GLuint loadShaders(const std::string & vertexFilePath,
const std::string & fragmentFilePath)
{
// Create the shaders
GLuint vertexShaderID = glCreateShader(GL_VERTEX_SHADER);
GLuint fragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
// Read the Vertex Shader code from the file
std::ifstream vertexShaderStream(vertexFilePath);
if(!vertexShaderStream.is_open()) {
std::cerr << "Impossible to open " << vertexFilePath << '\n';
return 0;
}//if
std::string vertexShaderCode(
(std::istreambuf_iterator<char>(vertexShaderStream)),
std::istreambuf_iterator<char>());
// Read the Fragment Shader code from the file
std::ifstream fragmentShaderStream(fragmentFilePath);
if(!fragmentShaderStream.is_open()) {
std::cerr << "Impossible to open " << fragmentFilePath << '\n';
return 0;
}//if
std::string fragmentShaderCode(
(std::istreambuf_iterator<char>(fragmentShaderStream)),
std::istreambuf_iterator<char>());
GLint status = GL_FALSE;
int infoLogLength;
// Compile Vertex Shader
std::cout << "Compiling Vertex Shader: " << vertexFilePath << '\n';
const char * vertexSourcePointer = vertexShaderCode.c_str();
glShaderSource(vertexShaderID, 1, &vertexSourcePointer , nullptr);
glCompileShader(vertexShaderID);
// Check Vertex Shader
glGetShaderiv(vertexShaderID, GL_COMPILE_STATUS, &status);
glGetShaderiv(vertexShaderID, GL_INFO_LOG_LENGTH, &infoLogLength);
if(infoLogLength > 0){
std::string vertexShaderErrorMessage(infoLogLength + 1, '\0');
glGetShaderInfoLog(vertexShaderID, infoLogLength, nullptr,
(GLchar *)(vertexShaderErrorMessage.data()));
std::cerr << vertexShaderErrorMessage << '\n';
}//if
// Compile Fragment Shader
std::cout << "Compiling Fragment Shader: " << fragmentFilePath << '\n';
char const * fragmentSourcePointer = fragmentShaderCode.c_str();
glShaderSource(fragmentShaderID, 1, &fragmentSourcePointer, nullptr);
glCompileShader(fragmentShaderID);
// Check Fragment Shader
glGetShaderiv(fragmentShaderID, GL_COMPILE_STATUS, &status);
glGetShaderiv(fragmentShaderID, GL_INFO_LOG_LENGTH, &infoLogLength);
if(infoLogLength > 0){
std::string fragmentShaderErrorMessage(infoLogLength + 1, '\0');
glGetShaderInfoLog(fragmentShaderID, infoLogLength, nullptr,
(GLchar *)(fragmentShaderErrorMessage.data()));
std::cerr << fragmentShaderErrorMessage << '\n';
}//if
// Link the program
std::cout << "Linking program: " << vertexFilePath << " & "
<< fragmentFilePath << '\n';
GLuint programID = glCreateProgram();
glAttachShader(programID, vertexShaderID);
glAttachShader(programID, fragmentShaderID);
glLinkProgram(programID);
// Check the program
glGetProgramiv(programID, GL_LINK_STATUS, &status);
glGetProgramiv(programID, GL_INFO_LOG_LENGTH, &infoLogLength);
if(infoLogLength > 0){
std::string programErrorMessage(infoLogLength + 1, '\0');
glGetProgramInfoLog(programID, infoLogLength, nullptr,
(GLchar *)(programErrorMessage.data()));
std::cerr << programErrorMessage << '\n';
}//if
glDeleteShader(vertexShaderID);
glDeleteShader(fragmentShaderID);
return programID;
}//loadShaders(vertexShaderStream, fragmentFilePath)
GLuint initProgram(string vertexFile, string fragmentFile)
{
// Create shaders
GLuint vertexShaderID = glCreateShader(GL_VERTEX_SHADER);
GLuint fragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
string tempV = getAeonDir()+vertexFile;
string tempF = getAeonDir()+fragmentFile;
string vertexCode;
string fragmentCode;
// Read vertex shader from file
ifstream vertexShaderStream(tempV.c_str(), std::ios::in);
if(vertexShaderStream.is_open())
{
string vLine = "";
while(getline(vertexShaderStream, vLine))
vertexCode += "\n" + vLine;
vertexShaderStream.close();
}
else
{
log("Failed to open vertex shader at: \""+tempV+"\"", AEON_ERROR);
return 0;
}
// Read fragment shader from file
ifstream fragmentShaderStream(tempF.c_str(), std::ios::in);
if(fragmentShaderStream.is_open())
{
string fLine = "";
while(getline(fragmentShaderStream, fLine))
fragmentCode += "\n" + fLine;
fragmentShaderStream.close();
}
else
{
log("Failed to open fragment shader at: \""+tempF+"\"", AEON_ERROR);
return 0;
}
GLint result = GL_FALSE;
int infoLogLength;
// Compile Vertex Shader
log("Compiling vertex shader: \""+vertexFile+"\"", AEON_INFO);
char const * vertexSourcePointer = vertexCode.c_str();
glShaderSource(vertexShaderID, 1, &vertexSourcePointer, NULL);
glCompileShader(vertexShaderID);
// Check Vertex Shader
glGetShaderiv(vertexShaderID, GL_COMPILE_STATUS, &result);
glGetShaderiv(vertexShaderID, GL_INFO_LOG_LENGTH, &infoLogLength);
if ( infoLogLength > 0 )
{
std::vector<char> vertexShaderErrorMessage(infoLogLength+1);
glGetShaderInfoLog(vertexShaderID, infoLogLength, NULL, &vertexShaderErrorMessage[0]);
if(vertexShaderErrorMessage.size() > 2)
log(vertexShaderErrorMessage, AEON_ERROR);
}
// Compile Fragment Shader
log("Compiling fragment shader: \""+fragmentFile+"\"", AEON_INFO);
char const * fragmentSourcePointer = fragmentCode.c_str();
glShaderSource(fragmentShaderID, 1, &fragmentSourcePointer, NULL);
glCompileShader(fragmentShaderID);
// Check Vertex Shader
glGetShaderiv(fragmentShaderID, GL_COMPILE_STATUS, &result);
glGetShaderiv(fragmentShaderID, GL_INFO_LOG_LENGTH, &infoLogLength);
if ( infoLogLength > 0 )
{
std::vector<char> fragmentShaderErrorMessage(infoLogLength+1);
glGetShaderInfoLog(fragmentShaderID, infoLogLength, NULL, &fragmentShaderErrorMessage[0]);
if(fragmentShaderErrorMessage.size() > 2)
log(fragmentShaderErrorMessage, AEON_ERROR);
}
// Link program
log("Linking program.", AEON_INFO);
GLuint programID = glCreateProgram();
glAttachShader(programID, vertexShaderID);
glAttachShader(programID, fragmentShaderID);
glLinkProgram(programID);
// Check the program
glGetProgramiv(programID, GL_LINK_STATUS, &result);
glGetProgramiv(programID, GL_INFO_LOG_LENGTH, &infoLogLength);
if ( infoLogLength > 0 )
{
std::vector<char> programErrorMessage(infoLogLength+1);
glGetProgramInfoLog(programID, infoLogLength, NULL, &programErrorMessage[0]);
if(programErrorMessage.size() > 2)
log(programErrorMessage, AEON_ERROR);
}
// Clean up
glDeleteShader(vertexShaderID);
glDeleteShader(fragmentShaderID);
return programID;
}
int Mesh::loadShaders(const char* vertexFile, const char* fragmentFile)
{
GLint result = GL_FALSE;
int infoLogLength;
GLuint vertexShaderID = glCreateShader(GL_VERTEX_SHADER);
GLuint fragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
std::ofstream outputLog("output.txt", std::ios::out);
std::string vertexShaderCode;
std::ifstream vertexShaderStream(vertexFile, std::ios::in);
if(vertexShaderStream.is_open())
{
char line[256];
while(vertexShaderStream.getline(line, 256))
{
vertexShaderCode += std::string("\n");
vertexShaderCode += std::string(line);
}
vertexShaderStream.close();
}
const char* vertexShaderSource = vertexShaderCode.c_str();
// Compile vertex shader
glShaderSource(vertexShaderID, 1, &vertexShaderSource, NULL);
glCompileShader(vertexShaderID);
// Check vertex shader
glGetShaderiv(vertexShaderID, GL_COMPILE_STATUS, &result);
glGetShaderiv(vertexShaderID, GL_INFO_LOG_LENGTH, &infoLogLength);
std::vector<char> vertexShaderErrorMessage(infoLogLength);
glGetShaderInfoLog(vertexShaderID, infoLogLength, NULL, &vertexShaderErrorMessage[0]);
if(outputLog.is_open())
{
outputLog<<&vertexShaderErrorMessage[0]<<std::endl;
}
std::string fragmentShaderCode;
std::ifstream fragmentShaderStream(fragmentFile, std::ios::in);
if(fragmentShaderStream.is_open())
{
char line[256];
while(fragmentShaderStream.getline(line, 256))
{
fragmentShaderCode += std::string("\n");
fragmentShaderCode += std::string(line);
}
fragmentShaderStream.close();
}
const char* fragmentShaderSource = fragmentShaderCode.c_str();
// Compile fragment shader
glShaderSource(fragmentShaderID, 1, &fragmentShaderSource, NULL);
glCompileShader(fragmentShaderID);
// Check fragment shader
glGetShaderiv(fragmentShaderID, GL_COMPILE_STATUS, &result);
glGetShaderiv(fragmentShaderID, GL_INFO_LOG_LENGTH, &infoLogLength);
std::vector<char> fragmentShaderErrorMessage(infoLogLength);
glGetShaderInfoLog(fragmentShaderID, infoLogLength, NULL, &fragmentShaderErrorMessage[0]);
if(outputLog.is_open())
{
outputLog<<&fragmentShaderErrorMessage[0]<<std::endl;
}
// Create and link a program
GLuint programID = glCreateProgram();
glAttachShader(programID, vertexShaderID);
glAttachShader(programID, fragmentShaderID);
glLinkProgram(programID);
// Check the program
glGetProgramiv(programID, GL_LINK_STATUS, &result);
glGetProgramiv(programID, GL_INFO_LOG_LENGTH, &infoLogLength);
std::vector<char> programErrorMessage(infoLogLength);
glGetProgramInfoLog(programID, infoLogLength, NULL, &programErrorMessage[0]);
if(outputLog.is_open())
{
outputLog<<&programErrorMessage[0]<<std::endl;
}
outputLog.close();
glDeleteShader(vertexShaderID);
glDeleteShader(fragmentShaderID);
return programID;
}
GLboolean Program::loadShaders(std::string vertex_file_path, std::string fragment_file_path)
{
GLuint vertexShaderId = glCreateShader(GL_VERTEX_SHADER);
GLuint fragmentShaderId = glCreateShader(GL_FRAGMENT_SHADER);
std::string vertexShaderCode;
std::ifstream vertexShaderStream(vertex_file_path, std::ios::in);
if(vertexShaderStream.is_open())
{
std::string line = "";
while(getline(vertexShaderStream, line))
vertexShaderCode += "\n" + line;
vertexShaderStream.close();
}
else
{
std::cerr << clog::err << "Cannot open " << vertex_file_path << "." << std::endl;
std::cin.get();
return GL_FALSE;
}
std::string fragmentShaderCode;
std::ifstream fragmentShaderStream(fragment_file_path, std::ios::in);
if(fragmentShaderStream.is_open())
{
std::string line = "";
while(getline(fragmentShaderStream, line))
fragmentShaderCode += "\n" + line;
fragmentShaderStream.close();
}
GLint result = GL_FALSE;
GLint infoLogLength;
//compile vertex shader
std::cout << clog::inf << "Compiling shader (" << vertex_file_path << ")..." << std::endl;
char const* vertexSourcePointer = vertexShaderCode.c_str();
glShaderSource(vertexShaderId, 1, &vertexSourcePointer , NULL);
glCompileShader(vertexShaderId);
//check vertex shader
glGetShaderiv(vertexShaderId, GL_COMPILE_STATUS, &result);
glGetShaderiv(vertexShaderId, GL_INFO_LOG_LENGTH, &infoLogLength);
if(infoLogLength > 0)
{
std::vector<char> vertexShaderErrorMessage(infoLogLength + 1);
glGetShaderInfoLog(vertexShaderId, infoLogLength, NULL, &vertexShaderErrorMessage[0]);
std::cerr << clog::err << &vertexShaderErrorMessage[0] << std::endl;
}
//compile fragment shader
std::cout << clog::inf << "Compiling shader (" << fragment_file_path << ")..." << std::endl;
char const* fragmentSourcePointer = fragmentShaderCode.c_str();
glShaderSource(fragmentShaderId, 1, &fragmentSourcePointer , NULL);
glCompileShader(fragmentShaderId);
//check fragment shader
glGetShaderiv(fragmentShaderId, GL_COMPILE_STATUS, &result);
glGetShaderiv(fragmentShaderId, GL_INFO_LOG_LENGTH, &infoLogLength);
if(infoLogLength > 0)
{
std::vector<char> fragmentShaderErrorMessage(infoLogLength + 1);
glGetShaderInfoLog(fragmentShaderId, infoLogLength, NULL, &fragmentShaderErrorMessage[0]);
std::cerr << clog::err << &fragmentShaderErrorMessage[0] << std::endl;
}
//link the program
std::cout << clog::inf << "Linking program..." << std::endl;
instance = glCreateProgram();
glAttachShader(instance, vertexShaderId);
glAttachShader(instance, fragmentShaderId);
glLinkProgram(instance);
//check the program
glGetProgramiv(instance, GL_LINK_STATUS, &result);
glGetProgramiv(instance, GL_INFO_LOG_LENGTH, &infoLogLength);
if(infoLogLength > 0)
{
std::vector<char> programErrorMessage(infoLogLength + 1);
glGetProgramInfoLog(instance, infoLogLength, NULL, &programErrorMessage[0]);
std::cerr << clog::err << &programErrorMessage[0] << std::endl;
}
glDeleteShader(vertexShaderId);
glDeleteShader(fragmentShaderId);
return GL_TRUE;
}
