//--------------------------------------------------------------
void ofApp::update()
{
if(timerCheckTimestamp.tick())
{
ofFile fragFile(fileName);
Poco::Timestamp PCBTimestamp = fragFile.getPocoFile().getLastModified();
if(PCBTimestamp != lastPCBTimestamp)
{
loadAndProcessPCB();
lastPCBTimestamp = PCBTimestamp;
}
}
}
/*
* INITIALIZE Shader Program
*
* This function reads in the source code for shaders,
* compiles each shader, and links the shaders into
* a shader program.
* ShaderException is thrown if an error occurs in any
* of the previous steps.
*/
void shader::init() {
QFile vertFile(vertSrcPath);
QFile fragFile(fragSrcPath);
// Test if Vertex File can be Opened
if (!vertFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
ShaderException exc("Failed to Open Vertex Shader File");
throw exc;
}
// Test if Fragment File can be Opened
if (!fragFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
ShaderException exc("Failed to Open Fragment Shader File");
throw exc;
}
// Get data from Vertex file and close
QByteArray vertFileData = vertFile.readAll();
vertFile.close();
// Get data from Fragment file and close
QByteArray fragFileData = fragFile.readAll();
fragFile.close();
// Nothing Read from Vertex Shader
if (!vertFileData.data()) {
ShaderException exc("Failed to Read Vertex Shader File");
throw exc;
}
// Nothing Read from Fragment Shader
if (!fragFileData.data()) {
ShaderException exc("Failed to Read Fragment Shader File");
throw exc;
}
// Otherwise, create shaders! //
// Create Shaders //
createShader(Vertex_Shader, vertexShader, vertFileData.data());
createShader(Fragment_Shader, fragShader, fragFileData.data());
// Create Program //
createShaderProgram();
}
Shader::Shader(std::string vertFilename, std::string fragFilename)
{
// Find path to shader
std::string vertPath = WolfEngine::FindAssetFolder() + "Shaders/" + vertFilename;
std::string fragPath = WolfEngine::FindAssetFolder() + "Shaders/" + fragFilename;
GLuint vertexShaderID = glCreateShader(GL_VERTEX_SHADER);
GLuint fragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
// Load vertex code
std::ifstream vertFile(vertPath);
if(!vertFile.is_open())
{
printf("Could not open file %s", vertPath.c_str());
return;
}
vertFile.seekg(0, std::ios::end);
size_t size = vertFile.tellg();
std::string vertShaderCode(size, ' ');
vertFile.seekg(0);
vertFile.read(&vertShaderCode[0], size);
// Load fragment code
std::ifstream fragFile(fragPath);
if(!fragFile.is_open())
{
printf("Could not open file %s", fragPath.c_str());
return;
}
fragFile.seekg(0, std::ios::end);
size = fragFile.tellg();
std::string fragShaderCode(size, ' ');
fragFile.seekg(0);
fragFile.read(&fragShaderCode[0], size);
GLint result = GL_FALSE;
int infoLogLength;
// Compile vertex shader
printf("Compiling shader : %s\n", vertPath.c_str());
char const * vertexSourcePointer = vertShaderCode.c_str();
glShaderSource(vertexShaderID, 1, &vertexSourcePointer , NULL);
glCompileShader(vertexShaderID);
// Error check vertex Shader
glGetShaderiv(vertexShaderID, GL_COMPILE_STATUS, &result);
glGetShaderiv(vertexShaderID, GL_INFO_LOG_LENGTH, &infoLogLength);
if (infoLogLength > 0)
{
std::vector<char> errorMessage(infoLogLength+1);
glGetShaderInfoLog(vertexShaderID, infoLogLength, NULL, &errorMessage[0]);
printf("%s\n", &errorMessage[0]);
}
// Compile fragment Shader
printf("Compiling shader : %s\n", fragPath.c_str());
char const * fragmentSourcePointer = fragShaderCode.c_str();
glShaderSource(fragmentShaderID, 1, &fragmentSourcePointer , NULL);
glCompileShader(fragmentShaderID);
// Error check fragment Shader
glGetShaderiv(fragmentShaderID, GL_COMPILE_STATUS, &result);
glGetShaderiv(fragmentShaderID, GL_INFO_LOG_LENGTH, &infoLogLength);
if (infoLogLength > 0)
{
std::vector<char> errorMessage(infoLogLength+1);
glGetShaderInfoLog(fragmentShaderID, infoLogLength, NULL, &errorMessage[0]);
printf("%s\n", &errorMessage[0]);
}
// Link the shader program
id = glCreateProgram();
glAttachShader(id, vertexShaderID);
glAttachShader(id, fragmentShaderID);
glLinkProgram(id);
// Error check the program
glGetProgramiv(id, GL_LINK_STATUS, &result);
glGetProgramiv(id, GL_INFO_LOG_LENGTH, &infoLogLength);
if ( infoLogLength > 0 )
{
std::vector<char> errorMessage(infoLogLength+1);
glGetProgramInfoLog(id, infoLogLength, NULL, &errorMessage[0]);
printf("%s\n", &errorMessage[0]);
}
// Clean up
glDetachShader(id, vertexShaderID);
glDetachShader(id, fragmentShaderID);
glDeleteShader(vertexShaderID);
glDeleteShader(fragmentShaderID);
}
