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; }