GLuint setShaders(char * vert, char * frag)
{
GLuint v, f, pro;
char *vs, *fs;
v = glCreateShader(GL_VERTEX_SHADER);
f = glCreateShader(GL_FRAGMENT_SHADER);
vs = textFileRead(vert);
fs = textFileRead(frag);
const char * vv = vs;
const char * ff = fs;
glShaderSource(v, 1, &vv, NULL);
glShaderSource(f, 1, &ff, NULL);
free(vs); free(fs);
glCompileShader(v);
glCompileShader(f);
printShaderLog(v);
printShaderLog(f);
pro = glCreateProgram();
glAttachShader(pro, v);
glAttachShader(pro, f);
glLinkProgram(pro);
printProgramLog(pro);
return(pro);
}
void setupShaders()
{
v = glCreateShader(GL_VERTEX_SHADER);
f = glCreateShader(GL_FRAGMENT_SHADER);
vs = textFileRead("shader.vert");
fs = textFileRead("shader.frag");
const char * ff = fs;
const char * vv = vs;
glShaderSource(v, 1, &vv, NULL);
glShaderSource(f, 1, &ff, NULL);
free(vs); free(fs);
glCompileShader(v);
glCompileShader(f);
printShaderLog(v);
printShaderLog(f);
p = glCreateProgram();
glAttachShader(p, f);
glAttachShader(p, v);
glLinkProgram(p);
printProgramLog(p);
}
/**
* Compiles all GLSL shaders
*/
void Resources::compileShaders() {
GLuint vert, frag; // Vertex and fragment shader handles
for(int i = 0; i < NUM_SHADERS; i++) {
// Create handles for program and shaders
programs[i] = glCreateProgram();
vert = glCreateShader(GL_VERTEX_SHADER);
frag = glCreateShader(GL_FRAGMENT_SHADER);
// Read shaders from files
char *vs_source = readShader(vertex_shaders[i]);
char *fs_source = readShader(fragment_shaders[i]);
// Loader shader sources
glShaderSource(vert, 1, (const char**)&vs_source, NULL);
glShaderSource(frag, 1, (const char**)&fs_source, NULL);
// Compile shaders
glCompileShader(vert);
printShaderLog(vert);
glCompileShader(frag);
printShaderLog(frag);
// Attach shaders to program
glAttachShader(programs[i], vert);
glAttachShader(programs[i], frag);
// Link program
glLinkProgram(programs[i]);
printProgramLog(programs[i]);
// Free memory from shader files
delete[] vs_source;
delete[] fs_source;
}
}
GLuint Shader::linkProgram(GLuint vert_handle, GLuint frag_handle)
{
GLuint program = glCreateProgram();
glAttachShader(program, vert_handle);
glAttachShader(program, frag_handle);
glLinkProgram(program);
printProgramLog(program);
return program;
}
bool shaderProgram::bindProgram() {
glUseProgram(programID);
GLenum error = glGetError();
if (error != GL_NO_ERROR) {
printProgramLog(programID);
return false;
}
return true;
}
void GLSLShader::load(const string& name)
{
vs_object = createShader(GL_VERTEX_SHADER, name+string(".vert"));
fs_object = createShader(GL_FRAGMENT_SHADER, name+string(".frag"));
prog_object = glCreateProgram();
if(vs_object)glAttachShader(prog_object, vs_object);
if(fs_object)glAttachShader(prog_object, fs_object);
glLinkProgram(prog_object);
printProgramLog(prog_object);
}
void GLSLShader::compileFromSource(const char* vertexShaderSource, const char* fragmentShaderSource)
{
vs_object = createShaderFromSource(GL_VERTEX_SHADER, string(vertexShaderSource));
fs_object = createShaderFromSource(GL_FRAGMENT_SHADER, string(fragmentShaderSource));
prog_object = glCreateProgram();
if (vs_object)
glAttachShader(prog_object, vs_object);
if (fs_object)
glAttachShader(prog_object, fs_object);
glLinkProgram(prog_object);
printProgramLog(prog_object);
}
void Shader::CompileShader()
{
//compile is already taken care of in addProgram
glLinkProgram(gProgramID);
//Check for errors
GLint programSuccess = GL_TRUE;
glGetProgramiv(gProgramID, GL_LINK_STATUS, &programSuccess);
if (programSuccess != GL_TRUE)
{
printf("Error linking program %d!\n", gProgramID);
printProgramLog(gProgramID);
//success = false;
}
glValidateProgram(gProgramID);
}
Color3DShader::Color3DShader() {
/*}
void SpriteShader::loadFromFiles(const char* vertexShader, const char* fragmentShader) {*/
GLuint vertexShaderId = loadShader("Calamity/Shader/color3D.vert", GL_VERTEX_SHADER);
GLuint fragmentShaderId = loadShader("Calamity/Shader/color3D.frag", GL_FRAGMENT_SHADER);
/*GLuint vertexShaderId = loadShader(vertexShader, GL_VERTEX_SHADER);
GLuint fragmentShaderId = loadShader(fragmentShader, GL_FRAGMENT_SHADER);*/
programId = glCreateProgram();
glAttachShader(programId, vertexShaderId);
glAttachShader(programId, fragmentShaderId);
glLinkProgram(programId);
// Check for errors
GLint programSuccess = GL_TRUE;
glGetProgramiv(programId, GL_LINK_STATUS, &programSuccess);
if (programSuccess != GL_TRUE) {
printf("Error linking program %d!\n", programId);
printProgramLog(programId);
glDeleteProgram(programId);
programId = 0;
glDetachShader(programId, vertexShaderId);
glDetachShader(programId, fragmentShaderId);
glDeleteShader(vertexShaderId);
glDeleteShader(fragmentShaderId);
return;
}
glDetachShader(programId, vertexShaderId);
glDetachShader(programId, fragmentShaderId);
glDeleteShader(vertexShaderId);
glDeleteShader(fragmentShaderId);
positionLocation = getAttribLocation("in_Position");
colorLocation = getAttribLocation("in_Color");
projectionMatrixLocation = getUniformLocation("projectionMatrix");
modelViewMatrixLocation = getUniformLocation("modelViewMatrix");
}
//loades the shaders into a program, retruning the programs id
GLuint glslLoadShaderProgram( std::string vertex, std::string fragment ){
//a quick check
if( vertex.empty() || fragment.empty() ){
printf( "ERROR: Unable to load programs, program defined as NULL" );
return 0;
}
printf( "INFO: Loading Shaders %s %s\n", vertex.c_str(), fragment.c_str());
//temp ids
GLuint vsID, fsID, program;
//make the vertex shader
const char* vertex_data = ReadShaderFile( vertex );
vsID = glCreateShader( GL_VERTEX_SHADER );
glShaderSource( vsID, 1, &vertex_data, NULL );
glCompileShader( vsID );
printShaderLog( vsID );
delete [] vertex_data;
//make the fragment shader
const char * fragment_data = ReadShaderFile( fragment );
fsID = glCreateShader( GL_FRAGMENT_SHADER );
glShaderSource( fsID, 1, &fragment_data, NULL );
glCompileShader( fsID );
printShaderLog( fsID );
delete [] fragment_data;
//make and link the program
program = glCreateProgram();
glAttachShader( program, vsID );
glAttachShader( program, fsID );
glBindFragDataLocationEXT( program, 0, "pixelColor" );
glLinkProgram( program );
printProgramLog( program );
//and return, best of luck
return program;
}
SimpleShader::SimpleShader() {
GLuint vertexShaderId = loadShader("Calamity/Shader/simple.vert", GL_VERTEX_SHADER);
GLuint fragmentShaderId = loadShader("Calamity/Shader/simple.frag", GL_FRAGMENT_SHADER);
programId = glCreateProgram();
glAttachShader(programId, vertexShaderId);
glAttachShader(programId, fragmentShaderId);
glLinkProgram(programId);
// Check for errors
GLint programSuccess = GL_TRUE;
glGetProgramiv(programId, GL_LINK_STATUS, &programSuccess);
if (programSuccess != GL_TRUE) {
printf("Error linking program %d!\n", programId);
printProgramLog(programId);
glDeleteProgram(programId);
programId = 0;
}
glDetachShader(programId, vertexShaderId);
glDetachShader(programId, fragmentShaderId);
glDeleteShader(vertexShaderId);
glDeleteShader(fragmentShaderId);
positionLocation = getAttribLocation("in_Position");
//texCoordLocation = getAttribLocation("in_TexCoord");
colorLocation = getAttribLocation("in_Color");
projectionMatrixLocation = getUniformLocation("projectionMatrix");
/*modelViewMatrixLocation = getUniformLocation("modelViewMatrix");*/
/*useTextureLocation = getUniformLocation("useTexture");*/
/*GLint textureLocation = getUniformLocation("tex");
glUniform1i(textureLocation, 0);*/
}
bool InitializeShader(Shader_T *s, const char *vsfile, const char *fsfile)
{
bool success = true;
GLuint vertexShader;
GLuint fragmentShader;
GLint vShaderCompiled = GL_FALSE;
GLint fShaderCompiled = GL_FALSE;
GLint programSuccess = GL_TRUE;
GLchar *txt;
unsigned long len;
//Generate program
s->id = glCreateProgram();
s->vertex_attrib = -1;
s->uv_attrib = -1;
//Create vertex shader
vertexShader = glCreateShader( GL_VERTEX_SHADER );
//Set vertex source
LoadShaderSource(vsfile, &txt, &len);
glShaderSource( vertexShader, 1, &txt, NULL );
//Compile vertex source
glCompileShader( vertexShader );
ValidateShader(vertexShader, vsfile);
UnloadShaderSource(&txt);
//Check vertex shader for errors
glGetShaderiv( vertexShader, GL_COMPILE_STATUS, &vShaderCompiled );
if( vShaderCompiled != GL_TRUE )
{
printf( "Unable to compile vertex shader %d!\n", vertexShader );
printShaderLog( vertexShader );
success = false;
}
else
{
//Attach vertex shader to program
glAttachShader( s->id, vertexShader );
//Create fragment shader
LoadShaderSource(fsfile, &txt, &len);
fragmentShader = glCreateShader( GL_FRAGMENT_SHADER );
//Set fragment source
glShaderSource( fragmentShader, 1, &txt, NULL );
//Compile fragment source
glCompileShader( fragmentShader );
ValidateShader(fragmentShader, fsfile);
UnloadShaderSource(&txt);
//Check fragment shader for errors
glGetShaderiv( fragmentShader, GL_COMPILE_STATUS, &fShaderCompiled );
if( fShaderCompiled != GL_TRUE )
{
printf( "Unable to compile fragment shader %d!\n", fragmentShader );
printShaderLog( fragmentShader );
success = false;
}
else
{
//Attach fragment shader to program
glAttachShader( s->id, fragmentShader );
//Link program
glLinkProgram( s->id );
//Check for errors
glGetProgramiv( s->id, GL_LINK_STATUS, &programSuccess );
if( programSuccess != GL_TRUE )
{
printf( "Error linking program %d!\n", s->id );
printProgramLog( s->id );
success = false;
}
else
{
//Get vertex attribute location
s->uv_attrib = glGetAttribLocation( s->id, "vertexUV" );
s->vertex_attrib = glGetAttribLocation( s->id, "vertexPosition" );
if( s->vertex_attrib == -1 )
{
printf( "vertexPosition is not a valid glsl program variable!\n" );
success = false;
}
if(s->uv_attrib == -1 )
{
printf( "vertexTex is not a valid glsl program variable!\n" );
success = false;
}
}
}
}
return success;
}
DeferredShader::DeferredShader() {
/*}
void SpriteShader::loadFromFiles(const char* vertexShader, const char* fragmentShader) {*/
GLuint vertexShaderId = loadShader("Calamity/Shader/pointLight.vert", GL_VERTEX_SHADER);
GLuint fragmentShaderId = loadShader("Calamity/Shader/pointLight.frag", GL_FRAGMENT_SHADER);
/*GLuint vertexShaderId = loadShader(vertexShader, GL_VERTEX_SHADER);
GLuint fragmentShaderId = loadShader(fragmentShader, GL_FRAGMENT_SHADER);*/
programId = glCreateProgram();
glAttachShader(programId, vertexShaderId);
glAttachShader(programId, fragmentShaderId);
glLinkProgram(programId);
// Check for errors
GLint programSuccess = GL_TRUE;
glGetProgramiv(programId, GL_LINK_STATUS, &programSuccess);
if (programSuccess != GL_TRUE) {
printf("Error linking program %d!\n", programId);
printProgramLog(programId);
glDeleteProgram(programId);
programId = 0;
glDetachShader(programId, vertexShaderId);
glDetachShader(programId, fragmentShaderId);
glDeleteShader(vertexShaderId);
glDeleteShader(fragmentShaderId);
return;
}
glDetachShader(programId, vertexShaderId);
glDetachShader(programId, fragmentShaderId);
glDeleteShader(vertexShaderId);
glDeleteShader(fragmentShaderId);
positionLocation = getAttribLocation("in_Position");
projectionMatrixLocation = getUniformLocation("projectionMatrix");
modelViewMatrixLocation = getUniformLocation("modelViewMatrix");
/*dirLightColorLocation = getUniformLocation("directionalLight.color");
dirLightDirectionLocation = getUniformLocation("directionalLight.direction");
dirLightAmbientIntensityLocation = getUniformLocation("directionalLight.ambientIntensity");
dirLightDiffuseIntensityLocation = getUniformLocation("directionalLight.diffuseIntensity");*/
/*dirLightLocation.color = getUniformLocation("directionalLight.base.color");
dirLightLocation.ambientIntensity = getUniformLocation("directionalLight.base.ambientIntensity");
dirLightLocation.diffuseIntensity = getUniformLocation("directionalLight.base.diffuseIntensity");
dirLightLocation.direction = getUniformLocation("directionalLight.direction");*/
pointLightLocation.color = getUniformLocation("pointLight.base.color");
pointLightLocation.ambientIntensity = getUniformLocation("pointLight.base.ambientIntensity");
pointLightLocation.diffuseIntensity = getUniformLocation("pointLight.base.diffuseIntensity");
pointLightLocation.position = getUniformLocation("pointLight.position");
pointLightLocation.attConstant = getUniformLocation("pointLight.attConstant");
pointLightLocation.attLinear = getUniformLocation("pointLight.attLinear");
pointLightLocation.attExponential = getUniformLocation("pointLight.attExponential");
eyeWorldPosLocation = getUniformLocation("eyeWorldPos");
matSpecularIntensityLocation = getUniformLocation("matSpecularIntensity");
matSpecularPowerLocation = getUniformLocation("matSpecularPower");
screenSizeLocation = getUniformLocation("screenSize");
GLint positionTextureLocation = getUniformLocation("positionTexture");
GLint colorTextureLocation = getUniformLocation("colorTexture");
GLint normalTextureLocation = getUniformLocation("normalTexture");
bind();
glUniform1i(positionTextureLocation, 0);
glUniform1i(colorTextureLocation, 1);
glUniform1i(normalTextureLocation, 2);
unbind();
}
bool AntSim::init()// Set up window and graphics
{
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
std::cout << "SDL failed to initialse, error: " << SDL_GetError() << std::endl;
return false;
}
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
windowGraphics = SDL_CreateWindow("AntSim", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN);
if (windowGraphics == NULL) {
std::cout << "Window could not be created, error: " << SDL_GetError() << std::endl;
return false;
}
SDL_HideWindow(windowGraphics);
context = SDL_GL_CreateContext(windowGraphics);
if (context == NULL) {
std::cout << "OpenGL context could not be created, error: " << SDL_GetError() << std::endl;
return false;
}
windowUI = new Fl_Window(SCREEN_WIDTH, SCREEN_HEIGHT);
#define INPUTFIELD_HEIGHT 20
#define INPUTFIELD_WIDTH 50
#define INPUTFIELD_X (SCREEN_WIDTH - INPUTFIELD_WIDTH - 20)
inputAlpha = new Fl_Input(INPUTFIELD_X, 20, INPUTFIELD_WIDTH, INPUTFIELD_HEIGHT, "Pheromone importance");//50, 605, 50, 20
inputAlpha->value("1.0");
inputBeta = new Fl_Input(INPUTFIELD_X, 50, INPUTFIELD_WIDTH, INPUTFIELD_HEIGHT, "Distance importance");
inputBeta->value("5.0");
inputEvapRate = new Fl_Input(INPUTFIELD_X, 80, INPUTFIELD_WIDTH, INPUTFIELD_HEIGHT, "Evaporation rate");
inputEvapRate->value("0.01");
inputPheroNumerator = new Fl_Input(INPUTFIELD_X, 110, INPUTFIELD_WIDTH, INPUTFIELD_HEIGHT, "Pheromone numerator");
inputPheroNumerator->value("100.0");
inputElitistAnts = new Fl_Input(INPUTFIELD_X, 150, INPUTFIELD_WIDTH, INPUTFIELD_HEIGHT, "No. elitist ants");
inputElitistAnts->value("7");
inputRankedAnts = new Fl_Input(INPUTFIELD_X, 180, INPUTFIELD_WIDTH, INPUTFIELD_HEIGHT, "No. ranked ants");
inputRankedAnts->value("5");
inputMaxPheromone = new Fl_Input(INPUTFIELD_X, 210, INPUTFIELD_WIDTH, INPUTFIELD_HEIGHT, "Max. pheromone");
inputMaxPheromone->value("20.0");
inputMinPhermone = new Fl_Input(INPUTFIELD_X, 240, INPUTFIELD_WIDTH, INPUTFIELD_HEIGHT, "Min. pheromone");
inputMinPhermone->value("0.005");
buttonUpdateParams = new Fl_Button(INPUTFIELD_X - 70, 270, 120, 30, "Update");
buttonUpdateParams->callback((Fl_Callback *) push_updateParams, this);
inputNoOfNodes = new Fl_Input(INPUTFIELD_X, 310, INPUTFIELD_WIDTH, INPUTFIELD_HEIGHT, "No. nodes");
inputNoOfNodes->value("20");
buttonTSP = new Fl_Round_Button(INPUTFIELD_X - 70, 350, INPUTFIELD_WIDTH, 10, "TSP type map");
buttonTSP->type(FL_RADIO_BUTTON);
buttonMaze = new Fl_Round_Button(INPUTFIELD_X - 70, 375, INPUTFIELD_WIDTH, 10, "Maze type map");
buttonMaze->type(FL_RADIO_BUTTON);
buttonTSP->setonly();
buttonGenerateMap = new Fl_Button(INPUTFIELD_X - 70, 400, 120, 30, "Generate map");
buttonGenerateMap->callback((Fl_Callback *) push_generateMap, this);
buttonLoadMap = new Fl_Button(INPUTFIELD_X - 70, 440, 120, 30, "Load map");
buttonLoadMap->callback((Fl_Callback *) push_loadMap, this);
inputIterations = new Fl_Input(INPUTFIELD_X, 490, INPUTFIELD_WIDTH, INPUTFIELD_HEIGHT, "Max. iterations");
inputIterations->value("1000");
buttonRunIteration = new Fl_Button(INPUTFIELD_X - 70, 525, 120, 30, "Run iteration");
buttonRunIteration->callback((Fl_Callback *) push_runIteration, this);
buttonRun = new Fl_Button(INPUTFIELD_X - 70, 565, 120, 30, "Run");
buttonRun->callback((Fl_Callback *) push_run, this);
menuAntMoveBeh = new Fl_Choice(90, 30, 120, 30, "Move beh");
menuAntMoveBeh->callback((Fl_Callback *) push_updateMoveBehaviour, this);
menuAntMoveBeh->add("Ant System", 0, 0);
menuAntMoveBeh->value(0);
menuAntPheroBeh = new Fl_Choice(90, 80, 120, 30, "Phero beh");
menuAntPheroBeh->callback((Fl_Callback *) push_updatePheromoneBehaviour, this);
menuAntPheroBeh->add("Ant System", 0, 0);
menuAntPheroBeh->add("Max-min AS", 0, 0);
menuAntPheroBeh->value(0);
menuEnviroBeh = new Fl_Choice(90, 130, 120, 30, "Enviro beh");
menuEnviroBeh->callback((Fl_Callback *) push_updateEnvironmentBehaviour, this);
menuEnviroBeh->add("Ant System", 0, 0);
menuEnviroBeh->add("Max-min AS", 0, 0);
menuEnviroBeh->add("Rank Based AS", 0, 0);
menuEnviroBeh->value(0);
windowUI->end();
windowUI->show();
glewExperimental = GL_TRUE;
GLenum glewError = glewInit();
if (glewError != GLEW_OK) {
std::cout << "GLEW could not be initialised, error : " << glewGetErrorString(glewError) << std::endl;
}
if (SDL_GL_SetSwapInterval(1) < 0) {
std::cout << "Unable to set vsync, error: " << SDL_GetError() << std::endl;
}
programID = glCreateProgram();
GLuint vertexShader = shaderLoadFromFile("antsimshader.vs", GL_VERTEX_SHADER);
if (vertexShader == 0)
{
glDeleteProgram(programID);
programID = 0;
return false;
}
glAttachShader(programID, vertexShader);
GLuint fragmentShader = shaderLoadFromFile("antsimshader.fs", GL_FRAGMENT_SHADER);
if (fragmentShader == 0)
{
glDeleteProgram(programID);
return false;
}
glAttachShader(programID, fragmentShader);
glLinkProgram(programID);
GLint linked;
glGetProgramiv(programID, GL_LINK_STATUS, &linked);
GLint programSuccess = GL_TRUE;
glGetProgramiv(programID, GL_LINK_STATUS, &programSuccess);
if (programSuccess != GL_TRUE) {
std::cout << "Could not link program" << std::endl;
printProgramLog(programID);
return false;
}
glViewport(0.0f, 0.0f, SCREEN_WIDTH, SCREEN_HEIGHT);
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
/*GLenum error = glGetError();
if (error != GL_NO_ERROR) {
std::cout << "Failed to initialise OpenGL, error - " << gluErrorString(error);
}*///Doesn't work, don't know why
projectionMatrix = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.0f);
viewMatrix = glm::lookAt(glm::vec3(0.0f, 20.0f, 0.1f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0, 1, 0));// Look from, look to
//(for some reason looking at straight down means nothing renders and looking from 0 to 0.1f makes everything backwards)
modelMatrix = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, 0.0f));
mvpMatrix = projectionMatrix * viewMatrix * modelMatrix;
uniformMatrix = glGetUniformLocation(programID, "matrixTransform");
if (uniformMatrix == -1) {
std::cout << "Could not bind uniform " << uniformMatrix << std::endl;
return false;
}
glUseProgram(programID);
glUniformMatrix4fv(uniformMatrix, 1, GL_FALSE, glm::value_ptr(mvpMatrix));
glUseProgram(0);
controller = new Controller(3, 0, 30, MAPTYPE_MAZE, MAP_GENERATE);
return true;
}
RadialBlurShader::RadialBlurShader(int screenWidth, int screenHeight) {
this->screenWidth = screenWidth;
this->screenHeight = screenHeight;
GLuint vertexShaderId = loadShader("Calamity/Shader/radialBlur.vert", GL_VERTEX_SHADER);
GLuint fragmentShaderId = loadShader("Calamity/Shader/radialBlur.frag", GL_FRAGMENT_SHADER);
programId = glCreateProgram();
glAttachShader(programId, vertexShaderId);
glAttachShader(programId, fragmentShaderId);
glLinkProgram(programId);
// Check for errors
GLint programSuccess = GL_TRUE;
glGetProgramiv(programId, GL_LINK_STATUS, &programSuccess);
if (programSuccess != GL_TRUE) {
printf("Error linking program %d!\n", programId);
printProgramLog(programId);
glDeleteProgram(programId);
programId = 0;
}
glDetachShader(programId, vertexShaderId);
glDetachShader(programId, fragmentShaderId);
glDeleteShader(vertexShaderId);
glDeleteShader(fragmentShaderId);
positionLocation = getAttribLocation("in_Position");
texCoordLocation = getAttribLocation("in_TexCoord");
colorLocation = getAttribLocation("in_Color");
projectionMatrixLocation = getUniformLocation("projectionMatrix");
modelViewMatrixLocation = getUniformLocation("modelViewMatrix");
//useTextureLocation = getUniformLocation("useTexture");
GLint textureLocation = getUniformLocation("tex");
/*vec2 radialSize; // texel size
float radialBlur; // blur factor
float radialBright; // bright factor
vec2 radialOrigin;*/
GLint radialSizeLocation = getUniformLocation("radialSize");
GLint radialBlurLocation = getUniformLocation("radialBlur");
GLint radialBrightLocation = getUniformLocation("radialBright");
GLint radialOriginLocation = getUniformLocation("radialOrigin");
// for moon
/*bind();
glUniform1i(textureLocation, 0);
glUniform2f(radialSizeLocation, 1.0f/800, 1.0f/600);
//glUniform1f(radialBlurLocation, 0.99f);
glUniform1f(radialBlurLocation, 0.8f);
//glUniform1f(radialBrightLocation, 0.1f);
glUniform1f(radialBrightLocation, 0.06f);
//glUniform2f(radialOriginLocation, 0.45f, 0.8f);
glUniform2f(radialOriginLocation, 0.45f, 0.7f);
unbind();*/
// for sun
bind();
glUniform1i(textureLocation, 0);
glUniform2f(radialSizeLocation, 1.0f/screenWidth, 1.0f/screenHeight);
//glUniform2f(radialSizeLocation, 1.0f/800, 1.0f/600);
//glUniform1f(radialBlurLocation, 0.99f);
glUniform1f(radialBlurLocation, 0.8f);
//glUniform1f(radialBrightLocation, 0.1f);
glUniform1f(radialBrightLocation, 0.05f);
//glUniform2f(radialOriginLocation, 0.45f, 0.8f);
glUniform2f(radialOriginLocation, 0.45f, 0.7f);
unbind();
}
bool LDoubleMultiColorPolygonProgram2D::loadProgram()
{
//Generate program
mProgramID = glCreateProgram();
//Load vertex shader
GLuint vertexShader = loadShaderFromFile( "36_vertex_array_objects/LDoubleMultiColorPolygonProgram2D.glvs", GL_VERTEX_SHADER );
//Check for errors
if( vertexShader == 0 )
{
glDeleteProgram( mProgramID );
mProgramID = 0;
return false;
}
//Attach vertex shader to program
glAttachShader( mProgramID, vertexShader );
//Create fragment shader
GLuint fragmentShader = loadShaderFromFile( "36_vertex_array_objects/LDoubleMultiColorPolygonProgram2D.glfs", GL_FRAGMENT_SHADER );
//Check for errors
if( fragmentShader == 0 )
{
glDeleteProgram( mProgramID );
mProgramID = 0;
return false;
}
//Attach fragment shader to program
glAttachShader( mProgramID, fragmentShader );
//Link program
glLinkProgram( mProgramID );
//Check for errors
GLint programSuccess = GL_TRUE;
glGetProgramiv( mProgramID, GL_LINK_STATUS, &programSuccess );
if( programSuccess != GL_TRUE )
{
printf( "Error linking program %d!\n", mProgramID );
printProgramLog( mProgramID );
glDeleteProgram( mProgramID );
mProgramID = 0;
return false;
}
//Get variable locations
mVertexPos2DLocation = glGetAttribLocation( mProgramID, "LVertexPos2D" );
if( mVertexPos2DLocation == -1 )
{
printf( "%s is not a valid glsl program variable!\n", "LVertexPos2D" );
}
mMultiColor1Location = glGetAttribLocation( mProgramID, "LMultiColor1" );
if( mMultiColor1Location == -1 )
{
printf( "%s is not a valid glsl program variable!\n", "LMultiColor1" );
}
mMultiColor2Location = glGetAttribLocation( mProgramID, "LMultiColor2" );
if( mMultiColor2Location == -1 )
{
printf( "%s is not a valid glsl program variable!\n", "LMultiColor2" );
}
mProjectionMatrixLocation = glGetUniformLocation( mProgramID, "LProjectionMatrix" );
if( mProjectionMatrixLocation == -1 )
{
printf( "%s is not a valid glsl program variable!\n", "LProjectionMatrix" );
}
mModelViewMatrixLocation = glGetUniformLocation( mProgramID, "LModelViewMatrix" );
if( mModelViewMatrixLocation == -1 )
{
printf( "%s is not a valid glsl program variable!\n", "LModelViewMatrix" );
}
return true;
}
void Shader::TestRemove()
{
//Success flag
bool success = true;
//Generate program
gProgramID = glCreateProgram();
//Create vertex shader
GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
//Get vertex source
const GLchar* vertexShaderSource[] =
{
"#version 140\nin vec2 LVertexPos2D; void main() { gl_Position = vec4( LVertexPos2D.x, LVertexPos2D.y, 0, 1 ); }"
};
//Set vertex source
glShaderSource(vertexShader, 1, vertexShaderSource, NULL);
//Compile vertex source
glCompileShader(vertexShader);
//Check vertex shader for errors
GLint vShaderCompiled = GL_FALSE;
glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &vShaderCompiled);
if (vShaderCompiled != GL_TRUE)
{
printf("Unable to compile vertex shader %d!\n", vertexShader);
printShaderLog(vertexShader);
success = false;
}
//Attach vertex shader to program
glAttachShader(gProgramID, vertexShader);
//Create fragment shader
GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
//Get fragment source
const GLchar* fragmentShaderSource[] =
{
"#version 140\nout vec4 LFragment; void main() { LFragment = vec4( 1.0, 0.0, 1.0, 1.0 ); }"
};
//Set fragment source
glShaderSource(fragmentShader, 1, fragmentShaderSource, NULL);
//Compile fragment source
glCompileShader(fragmentShader);
//Check fragment shader for errors
GLint fShaderCompiled = GL_FALSE;
glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &fShaderCompiled);
if (fShaderCompiled != GL_TRUE)
{
printf("Unable to compile fragment shader %d!\n", fragmentShader);
printShaderLog(fragmentShader);
success = false;
}
//Attach fragment shader to program
glAttachShader(gProgramID, fragmentShader);
//Link program
glLinkProgram(gProgramID);
//Check for errors
GLint programSuccess = GL_TRUE;
glGetProgramiv(gProgramID, GL_LINK_STATUS, &programSuccess);
if (programSuccess != GL_TRUE)
{
printf("Error linking program %d!\n", gProgramID);
printProgramLog(gProgramID);
success = false;
}
//Initialize clear color
glClearColor(1.f, 0.f, 0.f, 1.f);
}
bool BSTexturedPolygonProgram2D::loadProgram(std::string _path_vertex_shader, std::string _path_fragment_shader)
{
//Generate program
BSProgramID = glCreateProgram();
//Load vertex shader
GLuint vertexShader = loadShaderFromFile( _path_vertex_shader, GL_VERTEX_SHADER );
//Check for errors
if( vertexShader == 0 )
{
glDeleteProgram( BSProgramID );
BSProgramID = 0;
return false;
}
//Attach vertex shader to program
glAttachShader( BSProgramID, vertexShader );
//Create fragment shader
GLuint fragmentShader = loadShaderFromFile( _path_fragment_shader, GL_FRAGMENT_SHADER );
//Check for errors
if( fragmentShader == 0 )
{
glDeleteProgram( BSProgramID );
BSProgramID = 0;
return false;
}
//Attach fragment shader to program
glAttachShader( BSProgramID, fragmentShader );
//Link program
glLinkProgram( BSProgramID );
//Check for errors
GLint programSuccess = GL_TRUE;
glGetProgramiv( BSProgramID, GL_LINK_STATUS, &programSuccess );
if( programSuccess != GL_TRUE )
{
printf( "Error linking program %d!\n", BSProgramID );
printProgramLog( BSProgramID );
glDeleteProgram( BSProgramID );
BSProgramID = 0;
return false;
}
load_Shader_Attributes_Location(BS_Available_Shaders::vertex_position());
load_Shader_Attributes_Location(BS_Available_Shaders::texture_coordinates());
load_Shader_Uniforms_Location(BS_Available_Shaders::scale_size());
load_Shader_Uniforms_Location(BS_Available_Shaders::is_flake());
load_Shader_Uniforms_Location(BS_Available_Shaders::is_circle());
load_Shader_Uniforms_Location(BS_Available_Shaders::is_dark());
load_Shader_Uniforms_Location(BS_Available_Shaders::circle_radius());
load_Shader_Uniforms_Location(BS_Available_Shaders::time());
load_Shader_Uniforms_Location(BS_Available_Shaders::texture_color());
load_Shader_Uniforms_Location(BS_Available_Shaders::texture_unit());
load_Shader_Uniforms_Location(BS_Available_Shaders::projection_matrix());
load_Shader_Uniforms_Location(BS_Available_Shaders::model_view_matrix());
return true;
}
bool initGL()
{
bool success = true;
//Generate program
gProgramID = glCreateProgram();
//Create vertex shader
GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
//Get vertex source
const GLchar* vertexShaderSource[] =
{
"#version 140\nin vec2 LVertexPos2D; void main(){gl_Position = vec4( LVertexPos2D.x, LVertexPos2D.y, 0, 1 ); }"
};
//Set vertex shource
glShaderSource(vertexShader, 1, vertexShaderSource, NULL);
//Compile vertex source
glCompileShader(vertexShader);
//Check vertex shader for errors
GLint vShaderCompiled = GL_FALSE;
glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &vShaderCompiled);
if (vShaderCompiled != GL_TRUE)
{
printf("Unable to compile vertext shader %d!\n", vertexShader);
printShaderLog(vertexShader);
success = false;
}
else
{
//Attach vertext shader to program
glAttachShader(gProgramID, vertexShader);
//Create fragment shader
GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
//Get fragment source
const GLchar* fragmentShaderSource[] =
{
"#version 140\nout vec4 LFragment; void main(){LFragment = vec4( 1.0, 1.0, 1.0, 1.0);}"
};
//Set fragment source
glShaderSource(fragmentShader, 1, fragmentShaderSource, NULL);
//Compile fragment source
glCompileShader(fragmentShader);
//Check fragment shader for errors
GLint fShaderCompiled = GL_FALSE;
glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &fShaderCompiled);
if (fShaderCompiled != GL_TRUE)
{
printf("Unable to compile fragment shader %d!\n", fragmentShader);
printShaderLog(fragmentShader);
success = false;
}
else
{
//Attach fragment shader to program
glAttachShader(gProgramID, fragmentShader);
//Link program
glLinkProgram(gProgramID);
//Check for errors
GLint programSuccess = GL_TRUE;
glGetProgramiv(gProgramID, GL_LINK_STATUS, &programSuccess);
if (programSuccess != GL_TRUE)
{
printf("Error linking program %d\n", gProgramID);
printProgramLog(gProgramID);
success = false;
}
else
{
//Get vertext attribute location
gVertexPos2DLocation = glGetAttribLocation(gProgramID, "LVertexPos2D");
if (gVertexPos2DLocation == -1)
{
printf("LVertexPos2D is not a valid glsl program variable!\n");
success = false;
}
else
{
//Initalize clear color
glClearColor(0.f, 0.f, 0.f, 1.f);
//VBO data
GLfloat vertexData[] =
{
-0.5f, -0.5f,
0.5f, -0.5f,
0.5f, 0.5f,
-0.5f, 0.5f
};
//IBO data
GLuint indexData[] = { 0,1,2,3 };
//Create VBO
glGenBuffers(1, &gVBO);
glBindBuffer(GL_ARRAY_BUFFER, gVBO);
glBufferData(GL_ARRAY_BUFFER, 2 * 4 * sizeof(GLfloat), vertexData, GL_STATIC_DRAW);
//Create IBO
glGenBuffers(1, &gIBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, gIBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, 4 * sizeof(GLuint), indexData, GL_STATIC_DRAW);
}//end gVertexPos2DLocation
}//end program success
}//end if fShaderCopiled
}//end vShader compiled
return success;
}
bool BSTexturedPolygonProgram2D::loadProgram()
{
//Generate program
BSProgramID = glCreateProgram();
//Load vertex shader
GLuint vertexShader = loadShaderFromFile( "Shaders/BSTexturedPolygonProgram2D.glvs", GL_VERTEX_SHADER );
//Check for errors
if( vertexShader == 0 )
{
glDeleteProgram( BSProgramID );
BSProgramID = 0;
return false;
}
//Attach vertex shader to program
glAttachShader( BSProgramID, vertexShader );
//Create fragment shader
GLuint fragmentShader = loadShaderFromFile( "Shaders/BSTexturedPolygonProgram2D.glfs", GL_FRAGMENT_SHADER );
//Check for errors
if( fragmentShader == 0 )
{
glDeleteProgram( BSProgramID );
BSProgramID = 0;
return false;
}
//Attach fragment shader to program
glAttachShader( BSProgramID, fragmentShader );
//Link program
glLinkProgram( BSProgramID );
//Check for errors
GLint programSuccess = GL_TRUE;
glGetProgramiv( BSProgramID, GL_LINK_STATUS, &programSuccess );
if( programSuccess != GL_TRUE )
{
printf( "Error linking program %d!\n", BSProgramID );
printProgramLog( BSProgramID );
glDeleteProgram( BSProgramID );
BSProgramID = 0;
return false;
}
loadShaderAttributesLocation(locationBSVertexPosition3D, "BSVertexPosition3D");
loadShaderAttributesLocation(locationBSTextureCoordinate, "BSTextureCoordinates");
loadShaderUniformsLocation(ShaderCameraExtremeLeft, "CameraExtremeLeft");
loadShaderUniformsLocation(ShaderCameraExtremeRight, "CameraExtremeRight");
loadShaderUniformsLocation(ShaderCameraExtremeUp, "CameraExtremeUp");
loadShaderUniformsLocation(ShaderCameraExtremeDown, "CameraExtremeDown");
// ShaderCameraExtremeLeft = glGetUniformLocation(BSProgramID, "CameraExtremeLeft");
// ShaderCameraExtremeRight = glGetUniformLocation(BSProgramID, "CameraExtremeRight");
// ShaderCameraExtremeUp = glGetUniformLocation(BSProgramID, "CameraExtremeUp");
// ShaderCameraExtremeDown = glGetUniformLocation(BSProgramID, "CameraExtremeDown");
loadShaderUniformsLocation(ShaderPlayerCoordinatesX, "PlayerCoordinatesX");
loadShaderUniformsLocation(ShaderPlayerCoordinatesY, "PlayerCoordinatesY");
// ShaderPlayerCoordinatesX = glGetUniformLocation(BSProgramID, "PlayerCoordinatesX");
// ShaderPlayerCoordinatesY = glGetUniformLocation(BSProgramID, "PlayerCoordinatesY");
loadShaderUniformsLocation(ShaderScaleSize, "ScaleSize");
loadShaderUniformsLocation(ShaderScaleOnX, "TheScaleX");
loadShaderUniformsLocation(ShaderScaleOnY, "TheScaleY");
// ShaderScaleSize = glGetUniformLocation(BSProgramID, "ScaleSize");
// ShaderScaleOnX = glGetUniformLocation(BSProgramID, "TheScaleX");
// ShaderScaleOnY = glGetUniformLocation(BSProgramID, "TheScaleY");
loadShaderUniformsLocation(ShaderFlake, "isFlake");
loadShaderUniformsLocation(ShaderIsCircle, "isCircle");
loadShaderUniformsLocation(ShaderDark, "isDark");
// ShaderFlake = glGetUniformLocation(BSProgramID, "isFlake");
// ShaderIsCircle = glGetUniformLocation(BSProgramID, "isCircle");
// ShaderDark = glGetUniformLocation(BSProgramID, "isDark");
loadShaderUniformsLocation(ShaderRotationAngle, "RotationAngle");
loadShaderUniformsLocation(ShaderCircleRadius, "CircleRadius");
// ShaderRotationAngle = glGetUniformLocation(BSProgramID, "RotationAngle");
// ShaderCircleRadius = glGetUniformLocation(BSProgramID, "CircleRadius");
loadShaderUniformsLocation(locationBSTextureColor, "BSTextureColor");
loadShaderUniformsLocation(locationBSTextureUnit, "BSTextureUnit");
loadShaderUniformsLocation(locationBSProjectionMatrix, "BSProjectionMatrix");
loadShaderUniformsLocation(locationBSModelViewMatrix, "BSModelViewMatrix");
// mTextureColorLocation = glGetUniformLocation( BSProgramID, "BSTextureColor" );
// mTextureUnitLocation = glGetUniformLocation( BSProgramID, "BSTextureUnit" );
// mProjectionMatrixLocation = glGetUniformLocation( BSProgramID, "BSProjectionMatrix" );
// mModelViewMatrixLocation = glGetUniformLocation( BSProgramID, "BSModelViewMatrix" );
return true;
}
bool ShaderManager::loadProgram( const string& name, const ArrayList<Shader>& shaders )
{
ArrayList<GLuint> shaderIDs;
for (unsigned int i = 0; i < shaders.getSize(); ++i)
{
const Shader& shader = shaders[i];
shaderIDs.add(loadShaderFromFile(shader.Filename, shader.Type));
}
GLuint program;
program = glCreateProgram();
for (unsigned int i = 0; i < shaders.getSize(); ++i)
{
glAttachShader(program, shaderIDs[i]);
}
glLinkProgram(program);
GLint programLinked = GL_FALSE;
glGetProgramiv(program, GL_LINK_STATUS, &programLinked);
if (programLinked != GL_TRUE)
{
Log::ErrorFmt(getClassName(), "Failed to link program %d\n", program);
printProgramLog(program);
glDeleteProgram(program);
program = 0;
}
for (unsigned int i = 0; i < shaders.getSize(); ++i)
{
glDeleteShader(shaderIDs[i]);
}
if (program == 0)
return false;
m_Programs.add(name, program);
m_UniformLocations.add(name, Map<string, GLint>());
int uniformCount = -1;
glGetProgramiv(program, GL_ACTIVE_UNIFORMS, &uniformCount);
for (GLuint i = 0; i < (unsigned)uniformCount; ++i)
{
int nameLength;
int num;
GLenum uniformType = GL_ZERO;
char uniformName[100];
glGetActiveUniform(program, i, sizeof(uniformName) - 1, &nameLength, &num, &uniformType, uniformName );
uniformName[nameLength] = '\0';
GLuint location = i;
//GLuint location = glGetUniformLocation(program, uniformName);
m_UniformLocations[name].add(uniformName, location);
}
return true;
}
