void ShaderG::loadShader(std::string vertexShaderFileName, std::string fragmentShaderFileName) { //read, parse and compile the vertex shader std::string v = readShaderFile(vertexShaderFileName); const GLchar* vertexShaderString = v.c_str(); GLuint vertexShader; vertexShader = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vertexShader, 1, &vertexShaderString, NULL); glCompileShader(vertexShader); //check compilation status shaderCompileLog(vertexShader); //read, parse and compile the vertex shader std::string f = readShaderFile(fragmentShaderFileName); const GLchar* fragmentShaderString = f.c_str(); GLuint fragmentShader; fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fragmentShader, 1, &fragmentShaderString, NULL); glCompileShader(fragmentShader); //check compilation status shaderCompileLog(fragmentShader); //attach and link the shader programs this->shaderProgram = glCreateProgram(); glAttachShader(this->shaderProgram, vertexShader); glAttachShader(this->shaderProgram, fragmentShader); glLinkProgram(this->shaderProgram); glDeleteShader(vertexShader); glDeleteShader(fragmentShader); //check linking info shaderLinkLog(this->shaderProgram); }
/* * createShaders() - create, load, compile and link the GLSL shader objects. */ void createShader(GLuint *programObject, char *vertexshaderfile, char *fragmentshaderfile) { GLuint vertexShader; GLuint fragmentShader; const char *vertexShaderStrings[1]; const char *fragmentShaderStrings[1]; GLint vertexCompiled; GLint fragmentCompiled; GLint shadersLinked; char str[4096]; // For error messages from the GLSL compiler and linker // Create the vertex shader. vertexShader = glCreateShader(GL_VERTEX_SHADER); unsigned char *vertexShaderAssembly = readShaderFile( vertexshaderfile ); vertexShaderStrings[0] = (char*)vertexShaderAssembly; glShaderSource( vertexShader, 1, vertexShaderStrings, NULL ); glCompileShader( vertexShader); free((void *)vertexShaderAssembly); glGetShaderiv( vertexShader, GL_COMPILE_STATUS, &vertexCompiled ); if(vertexCompiled == GL_FALSE) { glGetShaderInfoLog(vertexShader, sizeof(str), NULL, str); printError("Vertex shader compile error", str); } // Create the fragment shader. fragmentShader = glCreateShader( GL_FRAGMENT_SHADER ); unsigned char *fragmentShaderAssembly = readShaderFile( fragmentshaderfile ); fragmentShaderStrings[0] = (char*)fragmentShaderAssembly; glShaderSource( fragmentShader, 1, fragmentShaderStrings, NULL ); glCompileShader( fragmentShader ); free((void *)fragmentShaderAssembly); glGetProgramiv( fragmentShader, GL_COMPILE_STATUS, &fragmentCompiled ); if(fragmentCompiled == GL_FALSE) { glGetShaderInfoLog( fragmentShader, sizeof(str), NULL, str ); printError("Fragment shader compile error", str); } // Create a program object and attach the two compiled shaders. *programObject = glCreateProgram(); glAttachShader( *programObject, vertexShader ); glAttachShader( *programObject, fragmentShader ); // Link the program object and print out the info log. glLinkProgram( *programObject ); glGetProgramiv( *programObject, GL_LINK_STATUS, &shadersLinked ); if( shadersLinked == GL_FALSE ) { glGetProgramInfoLog( *programObject, sizeof(str), NULL, str ); printError("Program object linking error", str); } }
void createShaders() { GLint vertexShader = glCreateShader(GL_VERTEX_SHADER); const char *vertexAssembly = readShaderFile("vertex_shader.vert"); glShaderSource( vertexShader, 1, &vertexAssembly, NULL ); glCompileShader( vertexShader); free((void *)vertexAssembly); GLint isCompiled; glGetShaderiv( vertexShader, GL_COMPILE_STATUS, &isCompiled ); if(isCompiled == GL_FALSE){ char str[256]; glGetShaderInfoLog(vertexShader, 256, NULL, str); fprintf( stderr, "Vertex shader compile error: %s\n", str); } GLint fragmentShader = glCreateShader( GL_FRAGMENT_SHADER ); const char *fragmentAssembly = readShaderFile( "fragment_shader.frag" ); glShaderSource( fragmentShader, 1, &fragmentAssembly, NULL ); glCompileShader( fragmentShader ); free((void *)fragmentAssembly); glGetShaderiv( fragmentShader, GL_COMPILE_STATUS, &isCompiled ); if(isCompiled == GL_FALSE){ char str[256]; glGetShaderInfoLog( fragmentShader, 256, NULL, str ); fprintf( stderr, "Fragment shader compile error: %s\n", str ); } programObj = glCreateProgram(); glAttachShader( programObj, vertexShader ); glAttachShader( programObj, fragmentShader ); glLinkProgram( programObj ); GLint isLinked; glGetProgramiv( programObj, GL_LINK_STATUS, &isLinked ); if( isLinked == GL_FALSE ){ char str[256]; glGetProgramInfoLog( programObj, 256, NULL, str ); fprintf( stderr, "Program object linking error: %s\n", str ); } location_testTexture = glGetUniformLocation( programObj, "testTexture" ); if(location_testTexture == -1) fprintf( stderr, "Binding warning: Failed to locate uniform variable 'testTexture'.\n"); location_time = glGetUniformLocation( programObj, "time" ); if(location_time == -1) fprintf( stderr, "Binding warning: Failed to locate uniform variable 'time'.\n"); location_center = glGetUniformLocation( programObj, "center" ); }
GLuint ShaderUtil::compileShaders(std::string vs,std::string fs){ std::string vsSource = readShaderFile(vs); std::string fsSource = readShaderFile(fs); return compileShaders(vsSource.c_str(),fsSource.c_str()); }
GLuint buildShaderFile(const char *vert_fn, const char *frag_fn, const char *prepend_src) { char *vert_src = readShaderFile(vert_fn); char *frag_src = readShaderFile(frag_fn); GLuint ret = 0; if (vert_src && frag_src) { ret = buildShader(vert_src, frag_src, prepend_src); } free(vert_src); free(frag_src); return ret; }
ShaderProgram::ShaderProgram(const char *vertShaderPath, const char *fragShaderPath) { GLuint vertShader = glCreateShader(GL_VERTEX_SHADER); GLuint fragShader = glCreateShader(GL_FRAGMENT_SHADER); std::string vertShaderCode = readShaderFile(vertShaderPath); std::string fragShaderCode = readShaderFile(fragShaderPath); compileShader(vertShader, vertShaderCode); compileShader(fragShader, fragShaderCode); program = linkProgram(vertShader, fragShader); glDeleteShader(vertShader); glDeleteShader(fragShader); }
/** * @description Creates and initializes the shader * @param filename * @param shaderType */ void ShaderObject::init(char* filename, GLenum shaderType) { unsigned char *shaderAssembly; // Create the vertex shader. this->shaderId = glCreateShader( shaderType ); shaderAssembly = readShaderFile( filename ); this->shaderStrings[0] = (char*)shaderAssembly; // suply the source to openGL glShaderSource( this->shaderId, 1, this->shaderStrings, NULL ); // compile the shader source glCompileShader( this->shaderId); free((void *)shaderAssembly); GLint compiled; // get compilation status glGetShaderiv( this->shaderId, GL_COMPILE_STATUS, &compiled ); // if some error occured, print the error msg if(compiled == GL_FALSE) { char statusString[4096]; glGetShaderInfoLog(this->shaderId, sizeof( statusString ), NULL, statusString); ExtensionsLoader::printError("Vertex shader compile error", statusString); } }
fragmentshader::fragmentshader(string theFilename) { if (GLEW_VERSION_2_0) { shaderID = glCreateShader(GL_FRAGMENT_SHADER); shaderText = readShaderFile(theFilename); const GLchar *program = shaderText; glShaderSource(shaderID, 1, &program, NULL); glCompileShader(shaderID); GLint retval; glGetShaderiv(shaderID, GL_COMPILE_STATUS, &retval); if (retval == GL_FALSE) { cout << "fragment shader " << theFilename << " compile failed\n"; } GLint infologLength = 0; GLint charsWritten = 0; char *infoLog; glGetShaderiv(shaderID, GL_INFO_LOG_LENGTH, &infologLength); if (infologLength > 0) { infoLog = (char *)malloc(infologLength); glGetShaderInfoLog(shaderID, infologLength, &charsWritten, infoLog); printf("fragment shader info log: %s\n",infoLog); free(infoLog); } } }
void Effect::loadShaders(const std::string& vertexShader, const std::string& fragmentShader) { assert(id == 0); id = glCreateProgram(); GLuint vertex; GLint status = compileShader(readShaderFile(vertexShader), GL_VERTEX_SHADER, vertex); if (status != GL_TRUE) { return; } GLuint fragment; status = compileShader(readShaderFile(fragmentShader), GL_FRAGMENT_SHADER, fragment); if (status != GL_TRUE) { return; } glAttachShader(id, vertex); glAttachShader(id, fragment); // bind attribute locations // this needs to be done prior to linking glBindAttribLocation(id, 0, "position"); glLinkProgram(id); GLint success; glGetProgramiv(id, GL_LINK_STATUS, &success); if (success == GL_FALSE) { const int logLength = 1024; auto log = std::unique_ptr<GLchar>(new GLchar[logLength]); glGetProgramInfoLog(id, logLength, nullptr, log.get()); SDL_Log("Error linking shader program: '%s'\n", logLength); } worldMatrix = glGetUniformLocation(id, "projectionMatrix"); localMatrix = glGetUniformLocation(id, "modelViewMatrix"); }
////////////////////////////////////////////////////////// // // Shader implementation // ====== inline void Shader::loadSourceFromFile(const char* fileName) //[]----------------------------------------------------[] //| Load source from file | //[]----------------------------------------------------[] { if (fileName == 0) return; const char* buffer = readShaderFile(fileName); // Set shader source code glShaderSource(handle, 1, &buffer, 0); compiled = false; // Delete buffer delete []buffer; // Compile shader compile(); }
GLhandleARB GLSL_CompileShader(const char* shaderfilename,unsigned int ShaderObject) { GLhandleARB GLSLShaderObject=0; GLSLShaderObject=glCreateShaderObjectARB(ShaderObject); unsigned char *ShaderAssembly = readShaderFile( shaderfilename ); const char *ShaderStrings[1]; ShaderStrings[0] = (char*)ShaderAssembly; glShaderSourceARB( GLSLShaderObject, 1, ShaderStrings, NULL ); glCompileShaderARB( GLSLShaderObject); //delete [] ShaderAssembly; GLint bCompiled=0; glGetObjectParameterivARB( GLSLShaderObject, GL_OBJECT_COMPILE_STATUS_ARB, &bCompiled ); if( bCompiled == false ) { char str[4096]; glGetInfoLogARB(GLSLShaderObject, sizeof(str), NULL, str); MessageBox( NULL, str, "Shader Compile Error", MB_OK|MB_ICONEXCLAMATION ); //MessageBox( NULL, "请尝试降低阴影设置,否则程序无法正常运行", "注意", MB_OK|MB_ICONEXCLAMATION ); } return GLSLShaderObject; }
//glMultiTexCoord2fvARB = (PFNGLMULTITEXCOORD2FvARBPROC)wglGetProcAddress("glMultiTexCoord2fvARB"); // glMultiTexCoord3fvARB = (PFNGLMULTITEXCOORD3FvARBPROC)wglGetProcAddress("glMultiTexCoord3fvARB"); void Dot3shader( void ) { char *ext = (char*)glGetString( GL_EXTENSIONS ); if( strstr( ext, "GL_ARB_shading_language_100" ) == NULL ) { // This extension string indicates that the OpenGL Shading Language, // version 1.00, is supported. MessageBox(NULL,"GL_ARB_shading_language_100 extension was not found", "ERROR",MB_OK|MB_ICONEXCLAMATION); return; } if( strstr( ext, "GL_ARB_shader_objects" ) == NULL ) { MessageBox(NULL,"GL_ARB_shader_objects extension was not found", "ERROR",MB_OK|MB_ICONEXCLAMATION); return; } else { glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC)wglGetProcAddress("glCreateProgramObjectARB"); glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC)wglGetProcAddress("glDeleteObjectARB"); glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC)wglGetProcAddress("glUseProgramObjectARB"); glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)wglGetProcAddress("glCreateShaderObjectARB"); glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)wglGetProcAddress("glShaderSourceARB"); glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC)wglGetProcAddress("glCompileShaderARB"); glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC)wglGetProcAddress("glGetObjectParameterivARB"); glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC)wglGetProcAddress("glAttachObjectARB"); glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC)wglGetProcAddress("glGetInfoLogARB"); glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC)wglGetProcAddress("glLinkProgramARB"); glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC)wglGetProcAddress("glGetUniformLocationARB"); glUniform1iARB = (PFNGLUNIFORM1IARBPROC)wglGetProcAddress("glUniform1iARB"); glUniform3fARB = (PFNGLUNIFORM3FARBPROC)wglGetProcAddress("glUniform3fARB"); glUniform4fARB = (PFNGLUNIFORM4FARBPROC)wglGetProcAddress("glUniform4fARB"); glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC)wglGetProcAddress("glActiveTextureARB"); glUniform1fARB = (PFNGLUNIFORM1FARBPROC)wglGetProcAddress("glUniform1fARB"); glUniform3fvARB = (PFNGLUNIFORM3FVARBPROC)wglGetProcAddress("glUniform3fvARB"); glUniform4fvARB = (PFNGLUNIFORM4FVARBPROC)wglGetProcAddress("glUniform4fvARB"); glUniformMatrix4fvARB = (PFNGLUNIFORMMATRIX4FVARBPROC)wglGetProcAddress("glUniformMatrix4fvARB"); glMultiTexCoord2fARB = (PFNGLMULTITEXCOORD2FARBPROC)wglGetProcAddress("glMultiTexCoord2fARB"); glMultiTexCoord3fARB = (PFNGLMULTITEXCOORD3FARBPROC)wglGetProcAddress("glMultiTexCoord3fARB"); glMultiTexCoord2fvARB = (PFNGLMULTITEXCOORD2FVARBPROC)wglGetProcAddress("glMultiTexCoord2fvARB"); glMultiTexCoord3fvARB = (PFNGLMULTITEXCOORD3FVARBPROC)wglGetProcAddress("glMultiTexCoord3fvARB"); glClientActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC)wglGetProcAddress("glClientActiveTextureARB"); if( !glCreateProgramObjectARB || !glDeleteObjectARB || !glUseProgramObjectARB || !glCreateShaderObjectARB || !glCreateShaderObjectARB || !glCompileShaderARB || !glGetObjectParameterivARB || !glAttachObjectARB || !glGetInfoLogARB || !glLinkProgramARB || !glGetUniformLocationARB || !glUniform4fARB || !glUniform1iARB || !glMultiTexCoord2fARB || !glClientActiveTextureARB) { MessageBox(NULL,"One or more GL_ARB_shader_objects functions were not found", "ERROR",MB_OK|MB_ICONEXCLAMATION); return; } } /////////////////____________________SHADER_SETUP_____________SHADER_SETUP_____________SHADER_SETUP_____________SHADER_SETUP const char *fireFresnel_VertexStrings[1]; const char *fireFresnel_FragmentStrings[1]; fireFresnel_Vertex = glCreateShaderObjectARB( GL_VERTEX_SHADER_ARB ); unsigned char *fireFresnel_VertexAssembly = readShaderFile( "_MODEL_FOLDERS_/BLOCKISH_OBJECTS/fireFresnel.vert" ); fireFresnel_VertexStrings[0] = (char*)fireFresnel_VertexAssembly; glShaderSourceARB( fireFresnel_Vertex, 1, fireFresnel_VertexStrings, NULL ); glCompileShaderARB( fireFresnel_Vertex); delete fireFresnel_VertexAssembly; fireFresnel_Fragment = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB ); unsigned char *fireFresnel_FragmentAssembly = readShaderFile( "_MODEL_FOLDERS_/BLOCKISH_OBJECTS/fireFresnel.frag" ); fireFresnel_FragmentStrings[0] = (char*)fireFresnel_FragmentAssembly; glShaderSourceARB( fireFresnel_Fragment, 1, fireFresnel_FragmentStrings, NULL ); glCompileShaderARB( fireFresnel_Fragment ); delete fireFresnel_FragmentAssembly; fireFresnel = glCreateProgramObjectARB(); glAttachObjectARB( fireFresnel, fireFresnel_Vertex ); glAttachObjectARB( fireFresnel, fireFresnel_Fragment ); glLinkProgramARB(fireFresnel); }
const char *smokeSphereSmall_SHADER_VertexStrings[1]; const char *smokeSphereSmall_SHADER_FragmentStrings[1]; smokeSphereSmall_SHADER_Vertex = glCreateShaderObjectARB( GL_VERTEX_SHADER_ARB ); unsigned char *smokeSphereSmall_SHADER_VertexAssembly = readShaderFile( "_MODEL_FOLDERS_/smokeSphereSmall/smokeSphereSmall.vert" ); smokeSphereSmall_SHADER_VertexStrings[0] = (char*)smokeSphereSmall_SHADER_VertexAssembly; glShaderSourceARB( smokeSphereSmall_SHADER_Vertex, 1, smokeSphereSmall_SHADER_VertexStrings, NULL ); glCompileShaderARB( smokeSphereSmall_SHADER_Vertex); delete smokeSphereSmall_SHADER_VertexAssembly; smokeSphereSmall_SHADER_Fragment = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB ); unsigned char *smokeSphereSmall_SHADER_FragmentAssembly = readShaderFile( "_MODEL_FOLDERS_/smokeSphereSmall/smokeSphereSmall.frag" ); smokeSphereSmall_SHADER_FragmentStrings[0] = (char*)smokeSphereSmall_SHADER_FragmentAssembly; glShaderSourceARB( smokeSphereSmall_SHADER_Fragment, 1, smokeSphereSmall_SHADER_FragmentStrings, NULL ); glCompileShaderARB( smokeSphereSmall_SHADER_Fragment ); delete smokeSphereSmall_SHADER_FragmentAssembly; smokeSphereSmall_SHADER = glCreateProgramObjectARB(); glAttachObjectARB( smokeSphereSmall_SHADER, smokeSphereSmall_SHADER_Vertex ); glAttachObjectARB( smokeSphereSmall_SHADER, smokeSphereSmall_SHADER_Fragment ); glLinkProgramARB(smokeSphereSmall_SHADER); UNIFORM_counter_smokeSphereSmall = glGetUniformLocationARB( smokeSphereSmall_SHADER, "counter" );
GLuint compileShader(const char* sourceOrFilename, GLuint shaderType, int is_source) { //DONT CHANGE #define SHADER_TYPE(shaderType) (shaderType == GL_VERTEX_SHADER ? "VERTEX" : "FRAGMENT") char *pShaderBuffer; char *source = (char*)sourceOrFilename; char *ptr = NULL; if(!is_source) source = readShaderFile(sourceOrFilename, shaderType); size_t sourceLen = strlen(source)*2; pShaderBuffer = malloc(sourceLen); memset(pShaderBuffer,0, sourceLen); #if !GLES sprintf(pShaderBuffer,"#version %d%02d\r\n",glslversion_major, glslversion_minor); #else sprintf(pShaderBuffer,"#version %d%02d %s\r\n", glslversion_major, glslversion_minor, glslversion_major >= 3 ? "es" : ""); if( SDL_GL_ExtensionSupported("GL_OES_standard_derivatives") ) sprintf(pShaderBuffer,"%s#extension GL_OES_standard_derivatives : enable\r\n",pShaderBuffer); if( SDL_GL_ExtensionSupported("GL_EXT_shader_texture_lod") ) sprintf(pShaderBuffer,"%s#extension GL_EXT_shader_texture_lod : enable\r\n",pShaderBuffer); // should be deduced via GL_ES/GL_FRAGMENT_PRECISION_HIGH combination since both is predefined // but unknown why manual define is a must for WebGL2 if( glslversion_major >= 3 ) sprintf(pShaderBuffer,"%sprecision highp float;\r\n",pShaderBuffer); #endif #if SUPPORT_PARAMETER_UNIFORM sprintf(pShaderBuffer,"%s#define PARAMETER_UNIFORM\r\n",pShaderBuffer); #endif // remove #pragma parameter from glsl, avoid glsl compiler( I mean you, atom ) complains while((ptr = strstr(source, "#pragma parameter"))!= NULL) { char *ptrEnd = strchr(ptr, '\r'); if( ptrEnd == NULL ) ptrEnd = strchr(ptr, '\n'); glslp_add_parameter(ptr, ptrEnd-ptr, &gGLSLP); while(ptr!=ptrEnd) *ptr++=' '; } sprintf(pShaderBuffer,"%s#define %s\r\n%s\r\n",pShaderBuffer,SHADER_TYPE(shaderType),is_source ? source : skip_version(source)); if(!is_source) free((void*)source); // Create ID for shader GLuint result = glCreateShader(shaderType); // Define shader text glShaderSource(result, 1, (const GLchar *const*)&pShaderBuffer, NULL); // Compile shader glCompileShader(result); //Check vertex shader for errors GLint shaderCompiled = GL_FALSE; glGetShaderiv( result, GL_COMPILE_STATUS, &shaderCompiled ); if( shaderCompiled != GL_TRUE ) { GLint logLength; glGetShaderiv(result, GL_INFO_LOG_LENGTH, &logLength); if (logLength > 0) { GLchar *log = (GLchar*)malloc(logLength); glGetShaderInfoLog(result, logLength, &logLength, log); UTIL_LogOutput(LOGLEVEL_FATAL, "shader %s compilation error:%s\n", is_source ? "stock" : sourceOrFilename,log); free(log); } glDeleteShader(result); result = 0; }else UTIL_LogOutput(LOGLEVEL_DEBUG, "%s shader %s compilation succeed!\n", SHADER_TYPE(shaderType), is_source ? "stock" : sourceOrFilename ); free(pShaderBuffer); return result; }
const char *marcRightHand_SHADER_VertexStrings[1]; const char *marcRightHand_SHADER_FragmentStrings[1]; marcRightHand_SHADER_Vertex = glCreateShaderObjectARB( GL_VERTEX_SHADER_ARB ); unsigned char *marcRightHand_SHADER_VertexAssembly = readShaderFile( "_MODEL_FOLDERS_/marcParts/marcTorso/marcTorso.vert" ); marcRightHand_SHADER_VertexStrings[0] = (char*)marcRightHand_SHADER_VertexAssembly; glShaderSourceARB( marcRightHand_SHADER_Vertex, 1, marcRightHand_SHADER_VertexStrings, NULL ); glCompileShaderARB( marcRightHand_SHADER_Vertex); delete marcRightHand_SHADER_VertexAssembly; marcRightHand_SHADER_Fragment = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB ); unsigned char *marcRightHand_SHADER_FragmentAssembly = readShaderFile( "_MODEL_FOLDERS_/marcParts/marcTorso/marcTorso.frag" ); marcRightHand_SHADER_FragmentStrings[0] = (char*)marcRightHand_SHADER_FragmentAssembly; glShaderSourceARB( marcRightHand_SHADER_Fragment, 1, marcRightHand_SHADER_FragmentStrings, NULL ); glCompileShaderARB( marcRightHand_SHADER_Fragment ); delete marcRightHand_SHADER_FragmentAssembly; marcRightHand_SHADER = glCreateProgramObjectARB(); glAttachObjectARB( marcRightHand_SHADER, marcRightHand_SHADER_Vertex ); glAttachObjectARB( marcRightHand_SHADER, marcRightHand_SHADER_Fragment ); glLinkProgramARB(marcRightHand_SHADER);
const char *marcFace_SHADER_VertexStrings[1]; const char *marcFace_SHADER_FragmentStrings[1]; marcFace_SHADER_Vertex = glCreateShaderObjectARB( GL_VERTEX_SHADER_ARB ); unsigned char *marcFace_SHADER_VertexAssembly = readShaderFile( "_MODEL_FOLDERS_/marcParts/marcFace/marcFace.vert" ); marcFace_SHADER_VertexStrings[0] = (char*)marcFace_SHADER_VertexAssembly; glShaderSourceARB( marcFace_SHADER_Vertex, 1, marcFace_SHADER_VertexStrings, NULL ); glCompileShaderARB( marcFace_SHADER_Vertex); delete marcFace_SHADER_VertexAssembly; marcFace_SHADER_Fragment = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB ); unsigned char *marcFace_SHADER_FragmentAssembly = readShaderFile( "_MODEL_FOLDERS_/marcParts/marcFace/marcFace.frag" ); marcFace_SHADER_FragmentStrings[0] = (char*)marcFace_SHADER_FragmentAssembly; glShaderSourceARB( marcFace_SHADER_Fragment, 1, marcFace_SHADER_FragmentStrings, NULL ); glCompileShaderARB( marcFace_SHADER_Fragment ); delete marcFace_SHADER_FragmentAssembly; marcFace_SHADER = glCreateProgramObjectARB(); glAttachObjectARB( marcFace_SHADER, marcFace_SHADER_Vertex ); glAttachObjectARB( marcFace_SHADER, marcFace_SHADER_Fragment ); glLinkProgramARB(marcFace_SHADER); UNIFORM_counter_marcFace = glGetUniformLocationARB( marcFace_SHADER, "counter" );
const char *matrixMathCube_SHADER_VertexStrings[1]; const char *matrixMathCube_SHADER_FragmentStrings[1]; matrixMathCube_SHADER_Vertex = glCreateShaderObjectARB( GL_VERTEX_SHADER_ARB ); unsigned char *matrixMathCube_SHADER_VertexAssembly = readShaderFile( "_MODEL_FOLDERS_/matrixMathCube/matrixMathCube.vert" ); matrixMathCube_SHADER_VertexStrings[0] = (char*)matrixMathCube_SHADER_VertexAssembly; glShaderSourceARB( matrixMathCube_SHADER_Vertex, 1, matrixMathCube_SHADER_VertexStrings, NULL ); glCompileShaderARB( matrixMathCube_SHADER_Vertex); delete matrixMathCube_SHADER_VertexAssembly; matrixMathCube_SHADER_Fragment = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB ); unsigned char *matrixMathCube_SHADER_FragmentAssembly = readShaderFile( "_MODEL_FOLDERS_/matrixMathCube/matrixMathCube.frag" ); matrixMathCube_SHADER_FragmentStrings[0] = (char*)matrixMathCube_SHADER_FragmentAssembly; glShaderSourceARB( matrixMathCube_SHADER_Fragment, 1, matrixMathCube_SHADER_FragmentStrings, NULL ); glCompileShaderARB(matrixMathCube_SHADER_Fragment ); delete matrixMathCube_SHADER_FragmentAssembly; matrixMathCube_SHADER = glCreateProgramObjectARB(); glAttachObjectARB( matrixMathCube_SHADER, matrixMathCube_SHADER_Vertex ); glAttachObjectARB( matrixMathCube_SHADER, matrixMathCube_SHADER_Fragment ); glLinkProgramARB(matrixMathCube_SHADER); UNIFORM_counter1_matrixMathCube = glGetUniformLocationARB( matrixMathCube_SHADER, "counter1" ); UNIFORM_counter2_matrixMathCube = glGetUniformLocationARB( matrixMathCube_SHADER, "counter2" );
//----------------------------------------------------------------------------- // Name: initShader() // Desc: Assemble the shader //----------------------------------------------------------------------------- void initShader( void ) { // // If the required extension is present, get the addresses of its // functions that we wish to use... // char *ext = (char*)glGetString( GL_EXTENSIONS ); if( strstr( ext, "GL_ARB_shading_language_100" ) == NULL ) { //This extension string indicates that the OpenGL Shading Language, // version 1.00, is supported. MessageBox(NULL,"GL_ARB_shading_language_100 extension was not found", "ERROR",MB_OK|MB_ICONEXCLAMATION); return; } if( strstr( ext, "GL_ARB_shader_objects" ) == NULL ) { MessageBox(NULL,"GL_ARB_shader_objects extension was not found", "ERROR",MB_OK|MB_ICONEXCLAMATION); return; } else { glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC)wglGetProcAddress("glCreateProgramObjectARB"); glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC)wglGetProcAddress("glDeleteObjectARB"); glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC)wglGetProcAddress("glUseProgramObjectARB"); glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)wglGetProcAddress("glCreateShaderObjectARB"); glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)wglGetProcAddress("glShaderSourceARB"); glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC)wglGetProcAddress("glCompileShaderARB"); glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC)wglGetProcAddress("glGetObjectParameterivARB"); glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC)wglGetProcAddress("glAttachObjectARB"); glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC)wglGetProcAddress("glGetInfoLogARB"); glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC)wglGetProcAddress("glLinkProgramARB"); glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC)wglGetProcAddress("glGetUniformLocationARB"); glUniform4fARB = (PFNGLUNIFORM4FARBPROC)wglGetProcAddress("glUniform4fARB"); glUniform1iARB = (PFNGLUNIFORM1IARBPROC)wglGetProcAddress("glUniform1iARB"); if( !glCreateProgramObjectARB || !glDeleteObjectARB || !glUseProgramObjectARB || !glCreateShaderObjectARB || !glCreateShaderObjectARB || !glCompileShaderARB || !glGetObjectParameterivARB || !glAttachObjectARB || !glGetInfoLogARB || !glLinkProgramARB || !glGetUniformLocationARB || !glUniform4fARB || !glUniform1iARB ) { MessageBox(NULL,"One or more GL_ARB_shader_objects functions were not found", "ERROR",MB_OK|MB_ICONEXCLAMATION); return; } } // Check for multitexture support. if(strstr(ext, "GL_ARB_multitexture")) { glActiveTexture = (PFNGLACTIVETEXTUREPROC)wglGetProcAddress("glActiveTexture"); }else{ MessageBox(NULL,"One or more GL_ARB_shader_objects functions were not found", "ERROR",MB_OK|MB_ICONEXCLAMATION); return; } const char *shaderStrings[1]; int nResult; char str[4096]; g_programObj = glCreateProgramObjectARB(); // // Vertex shader // unsigned char *shader_assembly = readShaderFile( "vertex_shader.vert" ); g_vertexShader = glCreateShaderObjectARB( GL_VERTEX_SHADER_ARB ); shaderStrings[0] = (char*)shader_assembly; glShaderSourceARB( g_vertexShader, 1, shaderStrings, NULL ); glCompileShaderARB( g_vertexShader); glGetObjectParameterivARB( g_vertexShader, GL_OBJECT_COMPILE_STATUS_ARB, &nResult ); if( nResult ) glAttachObjectARB( g_programObj, g_vertexShader ); else { glGetInfoLogARB(g_vertexShader, sizeof(str), NULL, str); MessageBox( NULL, str, "Vertex Shader Compile Error", MB_OK|MB_ICONEXCLAMATION ); } // // Fragment shader // delete shader_assembly; shader_assembly = readShaderFile( "fragment_shader.frag" ); g_fragmentShader = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB ); shaderStrings[0] = (char*)shader_assembly; glShaderSourceARB( g_fragmentShader, 1, shaderStrings, NULL ); glCompileShaderARB( g_fragmentShader ); glGetObjectParameterivARB( g_fragmentShader, GL_OBJECT_COMPILE_STATUS_ARB, &nResult ); if( nResult ) glAttachObjectARB( g_programObj, g_fragmentShader ); else { glGetInfoLogARB( g_fragmentShader, sizeof(str), NULL, str ); MessageBox( NULL, str, "Fragment Shader Compile Error", MB_OK|MB_ICONEXCLAMATION ); } glLinkProgramARB( g_programObj ); glGetObjectParameterivARB( g_programObj, GL_OBJECT_LINK_STATUS_ARB, &nResult ); if( !nResult ) { glGetInfoLogARB( g_programObj, sizeof(str), NULL, str ); MessageBox( NULL, str, "Linking Error", MB_OK|MB_ICONEXCLAMATION ); } delete shader_assembly; // // Locate some parameters by name so we can set them later... // g_location_testTexture = glGetUniformLocationARB( g_programObj, "testTexture" ); /////////////////////////////////////////////////////////// // NEW - Retrieving more Uniform locations. /////////////////////////////////////////////////////////// g_location_eyePos = glGetUniformLocationARB( g_programObj, "Eye" ); g_location_tangent = glGetUniformLocationARB( g_programObj, "Tangent" ); g_location_normal = glGetUniformLocationARB( g_programObj, "Normal" ); g_location_binormal = glGetUniformLocationARB( g_programObj, "BiNormal" ); g_location_heightTexture = glGetUniformLocationARB( g_programObj, "HeightTexture" ); }
const char *particle_50mm_SHADER_VertexStrings[1]; const char *particle_50mm_SHADER_FragmentStrings[1]; particle_50mm_SHADER_Vertex = glCreateShaderObjectARB( GL_VERTEX_SHADER_ARB ); unsigned char *particle_50mm_SHADER_VertexAssembly = readShaderFile( "_MODEL_FOLDERS_/particle_50mm/particle_50mm.vert" ); particle_50mm_SHADER_VertexStrings[0] = (char*)particle_50mm_SHADER_VertexAssembly; glShaderSourceARB( particle_50mm_SHADER_Vertex, 1, particle_50mm_SHADER_VertexStrings, NULL ); glCompileShaderARB( particle_50mm_SHADER_Vertex); delete particle_50mm_SHADER_VertexAssembly; particle_50mm_SHADER_Fragment = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB ); unsigned char *particle_50mm_SHADER_FragmentAssembly = readShaderFile( "_MODEL_FOLDERS_/particle_50mm/particle_50mm.frag" ); particle_50mm_SHADER_FragmentStrings[0] = (char*)particle_50mm_SHADER_FragmentAssembly; glShaderSourceARB( particle_50mm_SHADER_Fragment, 1, particle_50mm_SHADER_FragmentStrings, NULL ); glCompileShaderARB(particle_50mm_SHADER_Fragment ); delete particle_50mm_SHADER_FragmentAssembly; particle_50mm_SHADER = glCreateProgramObjectARB(); glAttachObjectARB( particle_50mm_SHADER, particle_50mm_SHADER_Vertex ); glAttachObjectARB( particle_50mm_SHADER, particle_50mm_SHADER_Fragment ); glLinkProgramARB(particle_50mm_SHADER); UNIFORM_counter1_particle_50mm = glGetUniformLocationARB( particle_50mm_SHADER, "counter1" ); UNIFORM_counter2_particle_50mm = glGetUniformLocationARB( particle_50mm_SHADER, "counter2" );
const char *marcLeftLowerLeg_SHADER_VertexStrings[1]; const char *marcLeftLowerLeg_SHADER_FragmentStrings[1]; marcLeftLowerLeg_SHADER_Vertex = glCreateShaderObjectARB( GL_VERTEX_SHADER_ARB ); unsigned char *marcLeftLowerLeg_SHADER_VertexAssembly = readShaderFile( "_MODEL_FOLDERS_/marcParts/marcTorso/marcTorso.vert" ); marcLeftLowerLeg_SHADER_VertexStrings[0] = (char*)marcLeftLowerLeg_SHADER_VertexAssembly; glShaderSourceARB( marcLeftLowerLeg_SHADER_Vertex, 1, marcLeftLowerLeg_SHADER_VertexStrings, NULL ); glCompileShaderARB( marcLeftLowerLeg_SHADER_Vertex); delete marcLeftLowerLeg_SHADER_VertexAssembly; marcLeftLowerLeg_SHADER_Fragment = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB ); unsigned char *marcLeftLowerLeg_SHADER_FragmentAssembly = readShaderFile( "_MODEL_FOLDERS_/marcParts/marcTorso/marcTorso.frag" ); marcLeftLowerLeg_SHADER_FragmentStrings[0] = (char*)marcLeftLowerLeg_SHADER_FragmentAssembly; glShaderSourceARB( marcLeftLowerLeg_SHADER_Fragment, 1, marcLeftLowerLeg_SHADER_FragmentStrings, NULL ); glCompileShaderARB( marcLeftLowerLeg_SHADER_Fragment ); delete marcLeftLowerLeg_SHADER_FragmentAssembly; marcLeftLowerLeg_SHADER = glCreateProgramObjectARB(); glAttachObjectARB( marcLeftLowerLeg_SHADER, marcLeftLowerLeg_SHADER_Vertex ); glAttachObjectARB( marcLeftLowerLeg_SHADER, marcLeftLowerLeg_SHADER_Fragment ); glLinkProgramARB(marcLeftLowerLeg_SHADER); UNIFORM_counter_marcLeftLowerLeg = glGetUniformLocationARB( marcLeftLowerLeg_SHADER, "counter" );
void Shader::load(const std::string &file, const std::string &fragFile) { staticInit(); loaded = false; #ifdef BBGE_BUILD_SHADERS if(!_useShaders) return; debugLog("Shader::load("+file+", "+fragFile+")"); g_location_texture = 0; g_location_mode = 0; g_location_value = 0; try { debugLog("Shader::load 1"); this->vertFile = file; this->fragFile = fragFile; // // If the required extension is present, get the addresses of its // functions that we wish to use... // const char *vertexShaderStrings[1]; const char *fragmentShaderStrings[1]; GLint bVertCompiled; GLint bFragCompiled; GLint bLinked; char str[4096]; // // Create the vertex shader... // debugLog("Shader::load 2"); g_vertexShader = glCreateShaderObjectARB( GL_VERTEX_SHADER_ARB ); unsigned char *vertexShaderAssembly = readShaderFile( file.c_str() ); vertexShaderStrings[0] = (char*)vertexShaderAssembly; glShaderSourceARB( g_vertexShader, 1, vertexShaderStrings, NULL ); glCompileShaderARB( g_vertexShader); delete[] vertexShaderAssembly; glGetObjectParameterivARB( g_vertexShader, GL_OBJECT_COMPILE_STATUS_ARB, &bVertCompiled ); if( bVertCompiled == false ) //if (true) { glGetInfoLogARB(g_vertexShader, sizeof(str), NULL, str); std::ostringstream os; os << "Vertex Shader Compile Error: " << str; debugLog(os.str()); return; } // // Create the fragment shader... // debugLog("Shader::load 3"); g_fragmentShader = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB ); unsigned char *fragmentShaderAssembly = readShaderFile( fragFile.c_str() ); fragmentShaderStrings[0] = (char*)fragmentShaderAssembly; glShaderSourceARB( g_fragmentShader, 1, fragmentShaderStrings, NULL ); glCompileShaderARB( g_fragmentShader ); delete[] fragmentShaderAssembly; glGetObjectParameterivARB( g_fragmentShader, GL_OBJECT_COMPILE_STATUS_ARB, &bFragCompiled ); if( bFragCompiled == false ) { glGetInfoLogARB( g_fragmentShader, sizeof(str), NULL, str ); std::ostringstream os; os << "Fragment Shader Compile Error: " << str; debugLog(os.str()); return; } debugLog("Shader::load 4"); // // Create a program object and attach the two compiled shaders... // g_programObj = glCreateProgramObjectARB(); if (!g_programObj || !g_vertexShader || !g_fragmentShader) { debugLog("programObj / vertexShader / fragmentShader problem"); return; } glAttachObjectARB( g_programObj, g_vertexShader ); glAttachObjectARB( g_programObj, g_fragmentShader ); // // Link the program object and print out the info log... // glLinkProgramARB( g_programObj ); glGetObjectParameterivARB( g_programObj, GL_OBJECT_LINK_STATUS_ARB, &bLinked ); debugLog("Shader::load 5"); if( bLinked == false ) { glGetInfoLogARB( g_programObj, sizeof(str), NULL, str ); std::ostringstream os; os << "Shader Linking Error: " << str; debugLog(os.str()); return; } // // Locate some parameters by name so we can set them later... // debugLog("Shader::load 6"); g_location_texture = glGetUniformLocationARB( g_programObj, "tex" ); g_location_mode = glGetUniformLocationARB( g_programObj, "mode" ); g_location_value = glGetUniformLocationARB( g_programObj, "value" ); debugLog("Shader::load 7"); loaded = true; } catch(...) { debugLog("caught exception in shader::load"); loaded = false; } #endif debugLog("End Shader::load()"); }
void initShader( void ) { // If the required extension is present, get the addresses of its // functions that we wish to use... char *ext = (char*)glGetString( GL_EXTENSIONS ); if( strstr( ext, "GL_ARB_shading_language_100" ) == NULL ) { // This extension string indicates that the OpenGL Shading Language, // version 1.00, is supported. printf( "GL_ARB_shading_language_100 extension was not found\n" ); return; } if( strstr( ext, "GL_ARB_shader_objects" ) == NULL ) { printf( "GL_ARB_shader_objects extension was not found\n" ); return; } else { glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC)glXGetProcAddressARB((GLubyte*)"glCreateProgramObjectARB"); glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC)glXGetProcAddressARB((GLubyte*)"glDeleteObjectARB"); glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC)glXGetProcAddressARB((GLubyte*)"glUseProgramObjectARB"); glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)glXGetProcAddressARB((GLubyte*)"glCreateShaderObjectARB"); glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)glXGetProcAddressARB((GLubyte*)"glShaderSourceARB"); glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC)glXGetProcAddressARB((GLubyte*)"glCompileShaderARB"); glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC)glXGetProcAddressARB((GLubyte*)"glGetObjectParameterivARB"); glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC)glXGetProcAddressARB((GLubyte*)"glAttachObjectARB"); glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC)glXGetProcAddressARB((GLubyte*)"glGetInfoLogARB"); glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC)glXGetProcAddressARB((GLubyte*)"glLinkProgramARB"); glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC)glXGetProcAddressARB((GLubyte*)"glGetUniformLocationARB"); glUniform4fARB = (PFNGLUNIFORM4FARBPROC)glXGetProcAddressARB((GLubyte*)"glUniform4fARB"); glUniform1iARB = (PFNGLUNIFORM1IARBPROC)glXGetProcAddressARB((GLubyte*)"glUniform1iARB"); glUniform2fARB = (PFNGLUNIFORM2FARBPROC)glXGetProcAddressARB((GLubyte*)"glUniform2fARB"); if( !glCreateProgramObjectARB || !glDeleteObjectARB || !glUseProgramObjectARB || !glCreateShaderObjectARB || !glCreateShaderObjectARB || !glCompileShaderARB || !glGetObjectParameterivARB || !glAttachObjectARB || !glGetInfoLogARB || !glLinkProgramARB || !glGetUniformLocationARB || !glUniform4fARB || !glUniform1iARB || !glUniform2fARB ) { printf( "One or more GL_ARB_shader_objects functions were not found\n" ); return; } } const char *vertexShaderStrings[1]; const char *fragmentShaderStrings[1]; GLint bVertCompiled; GLint bFragCompiled; GLint bLinked; char str[4096]; // Create the vertex shader... g_vertexShader = glCreateShaderObjectARB( GL_VERTEX_SHADER_ARB ); unsigned char *vertexShaderAssembly = readShaderFile( "./brightness.slv" ); vertexShaderStrings[0] = (char*)vertexShaderAssembly; glShaderSourceARB( g_vertexShader, 1, vertexShaderStrings, NULL ); glCompileShaderARB( g_vertexShader); delete [] vertexShaderAssembly; glGetObjectParameterivARB( g_vertexShader, GL_OBJECT_COMPILE_STATUS_ARB, &bVertCompiled ); if( bVertCompiled == false ) { glGetInfoLogARB(g_vertexShader, sizeof(str), NULL, str); sprintf( str, "Vertex Shader Compile Error" ); } // Create the fragment shader... g_fragmentShader = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB ); unsigned char *fragmentShaderAssembly = readShaderFile( "./brightness.slf" ); fragmentShaderStrings[0] = (char*)fragmentShaderAssembly; glShaderSourceARB( g_fragmentShader, 1, fragmentShaderStrings, NULL ); glCompileShaderARB( g_fragmentShader ); delete [] fragmentShaderAssembly; glGetObjectParameterivARB( g_fragmentShader, GL_OBJECT_COMPILE_STATUS_ARB, &bFragCompiled ); if( bFragCompiled == false ) { glGetInfoLogARB( g_fragmentShader, sizeof(str), NULL, str ); sprintf( str, "Fragment Shader Compile Error" ); } // Create a program object and attach the two compiled shaders... g_programObj = glCreateProgramObjectARB(); glAttachObjectARB( g_programObj, g_vertexShader ); glAttachObjectARB( g_programObj, g_fragmentShader ); // Link the program object and print out the info log... glLinkProgramARB( g_programObj ); glGetObjectParameterivARB( g_programObj, GL_OBJECT_LINK_STATUS_ARB, &bLinked ); if( bLinked == false ) { glGetInfoLogARB( g_programObj, sizeof(str), NULL, str ); printf( "Linking Error\n" ); } }
const char *gaussianBlurHorizontalPass_SHADER_VertexStrings[1]; const char *gaussianBlurHorizontalPass_SHADER_FragmentStrings[1]; gaussianBlurHorizontalPass_SHADER_Vertex = glCreateShaderObjectARB( GL_VERTEX_SHADER_ARB ); unsigned char *gaussianBlurHorizontalPass_SHADER_VertexAssembly = readShaderFile( "_MODEL_FOLDERS_/gaussianBlur/gaussianBlurHorizontalPass/gaussianBlurHorizontalPass.vert" ); gaussianBlurHorizontalPass_SHADER_VertexStrings[0] = (char*)gaussianBlurHorizontalPass_SHADER_VertexAssembly; glShaderSourceARB( gaussianBlurHorizontalPass_SHADER_Vertex, 1, gaussianBlurHorizontalPass_SHADER_VertexStrings, NULL ); glCompileShaderARB( gaussianBlurHorizontalPass_SHADER_Vertex); delete gaussianBlurHorizontalPass_SHADER_VertexAssembly; gaussianBlurHorizontalPass_SHADER_Fragment = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB ); unsigned char *gaussianBlurHorizontalPass_SHADER_FragmentAssembly = readShaderFile( "_MODEL_FOLDERS_/gaussianBlur/gaussianBlurHorizontalPass/gaussianBlurHorizontalPass.frag" ); gaussianBlurHorizontalPass_SHADER_FragmentStrings[0] = (char*)gaussianBlurHorizontalPass_SHADER_FragmentAssembly; glShaderSourceARB( gaussianBlurHorizontalPass_SHADER_Fragment, 1, gaussianBlurHorizontalPass_SHADER_FragmentStrings, NULL ); glCompileShaderARB(gaussianBlurHorizontalPass_SHADER_Fragment ); delete gaussianBlurHorizontalPass_SHADER_FragmentAssembly; gaussianBlurHorizontalPass_SHADER = glCreateProgramObjectARB(); glAttachObjectARB( gaussianBlurHorizontalPass_SHADER, gaussianBlurHorizontalPass_SHADER_Vertex ); glAttachObjectARB( gaussianBlurHorizontalPass_SHADER, gaussianBlurHorizontalPass_SHADER_Fragment ); glLinkProgramARB(gaussianBlurHorizontalPass_SHADER); UNIFORM_shininess_gaussianBlurHorizontalPass = glGetUniformLocationARB( gaussianBlurHorizontalPass_SHADER, "shiny" ); UNIFORM_counter1_gaussianBlurHorizontalPass = glGetUniformLocationARB( gaussianBlurHorizontalPass_SHADER, "counter1" );
//----------------------------------------------------------------------------- // Name: initShader() // Desc: Assemble the shader //----------------------------------------------------------------------------- void initShader( void ) { // // If the required extension is present, get the addresses of its // functions that we wish to use... // char *ext = (char*)glGetString( GL_EXTENSIONS ); if( strstr( ext, "GL_ARB_shading_language_100" ) == NULL ) { //This extension string indicates that the OpenGL Shading Language, // version 1.00, is supported. MessageBox(NULL,"GL_ARB_shading_language_100 extension was not found", "ERROR",MB_OK|MB_ICONEXCLAMATION); return; } if( strstr( ext, "GL_ARB_shader_objects" ) == NULL ) { MessageBox(NULL,"GL_ARB_shader_objects extension was not found", "ERROR",MB_OK|MB_ICONEXCLAMATION); return; } else { glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC)wglGetProcAddress("glCreateProgramObjectARB"); glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC)wglGetProcAddress("glDeleteObjectARB"); glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC)wglGetProcAddress("glUseProgramObjectARB"); glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)wglGetProcAddress("glCreateShaderObjectARB"); glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)wglGetProcAddress("glShaderSourceARB"); glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC)wglGetProcAddress("glCompileShaderARB"); glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC)wglGetProcAddress("glGetObjectParameterivARB"); glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC)wglGetProcAddress("glAttachObjectARB"); glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC)wglGetProcAddress("glGetInfoLogARB"); glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC)wglGetProcAddress("glLinkProgramARB"); glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC)wglGetProcAddress("glGetUniformLocationARB"); glUniform4fARB = (PFNGLUNIFORM4FARBPROC)wglGetProcAddress("glUniform4fARB"); glUniform1iARB = (PFNGLUNIFORM1IARBPROC)wglGetProcAddress("glUniform1iARB"); if( !glCreateProgramObjectARB || !glDeleteObjectARB || !glUseProgramObjectARB || !glCreateShaderObjectARB || !glCreateShaderObjectARB || !glCompileShaderARB || !glGetObjectParameterivARB || !glAttachObjectARB || !glGetInfoLogARB || !glLinkProgramARB || !glGetUniformLocationARB || !glUniform4fARB || !glUniform1iARB ) { MessageBox(NULL,"One or more GL_ARB_shader_objects functions were not found", "ERROR",MB_OK|MB_ICONEXCLAMATION); return; } } const char *vertexShaderStrings[1]; const char *fragmentShaderStrings[1]; GLint bVertCompiled; GLint bFragCompiled; GLint bLinked; char str[4096]; // // Create the vertex shader... // g_vertexShader = glCreateShaderObjectARB( GL_VERTEX_SHADER_ARB ); unsigned char *vertexShaderAssembly = readShaderFile( "C:\\Users\\colton\\Desktop\\mainroach.git\\plugin-port1\\plugin-port1\\vertex_shader.vert" ); vertexShaderStrings[0] = (char*)vertexShaderAssembly; glShaderSourceARB( g_vertexShader, 1, vertexShaderStrings, NULL ); glCompileShaderARB( g_vertexShader); delete vertexShaderAssembly; glGetObjectParameterivARB( g_vertexShader, GL_OBJECT_COMPILE_STATUS_ARB, &bVertCompiled ); if( bVertCompiled == false ) { glGetInfoLogARB(g_vertexShader, sizeof(str), NULL, str); MessageBox( NULL, str, "Vertex Shader Compile Error", MB_OK|MB_ICONEXCLAMATION ); } // // Create the fragment shader... // g_fragmentShader = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB ); unsigned char *fragmentShaderAssembly = readShaderFile( "C:\\Users\\colton\\Desktop\\mainroach.git\\plugin-port1\\plugin-port1\\fragment_shader.frag" ); fragmentShaderStrings[0] = (char*)fragmentShaderAssembly; glShaderSourceARB( g_fragmentShader, 1, fragmentShaderStrings, NULL ); glCompileShaderARB( g_fragmentShader ); delete fragmentShaderAssembly; glGetObjectParameterivARB( g_fragmentShader, GL_OBJECT_COMPILE_STATUS_ARB, &bFragCompiled ); if( bFragCompiled == false ) { glGetInfoLogARB( g_fragmentShader, sizeof(str), NULL, str ); MessageBox( NULL, str, "Fragment Shader Compile Error", MB_OK|MB_ICONEXCLAMATION ); } // // Create a program object and attach the two compiled shaders... // g_programObj = glCreateProgramObjectARB(); glAttachObjectARB( g_programObj, g_vertexShader ); glAttachObjectARB( g_programObj, g_fragmentShader ); // // Link the program object and print out the info log... // glLinkProgramARB( g_programObj ); glGetObjectParameterivARB( g_programObj, GL_OBJECT_LINK_STATUS_ARB, &bLinked ); if( bLinked == false ) { glGetInfoLogARB( g_programObj, sizeof(str), NULL, str ); MessageBox( NULL, str, "Linking Error", MB_OK|MB_ICONEXCLAMATION ); } // // Locate some parameters by name so we can set them later... // g_location_testTexture = glGetUniformLocationARB( g_programObj, "testTexture" ); }
bool Ftv_ResourceManager::createFtvShaderProgram(ftv_shaderType type, std::shared_ptr<GLSLProgram> &inOutPrgPtr) { /* Check list of shader programs for the shader type */ for(std::list<std::shared_ptr<GLSLProgram>>::iterator i = ftv_shader_program_list.begin(); i != ftv_shader_program_list.end(); ++i) { if(((*i)->getType())==type){ inOutPrgPtr = (*i); return true; } } std::shared_ptr<GLSLProgram> shaderPrg(new GLSLProgram()); shaderPrg->init(); std::string vertSource; std::string fragSource; switch (type) { case FTV_POISSON: { vertSource = readShaderFile("../resources/shaders/genericPostProc_v.glsl"); fragSource = readShaderFile("../resources/shaders/ftv/f_ftv_poisson.glsl"); shaderPrg->bindAttribLocation(0, "vPosition"); shaderPrg->bindAttribLocation(1, "vUVCoord"); break; } case STAMP: { vertSource = readShaderFile("../resources/shaders/genericPostProc_v.glsl"); fragSource = readShaderFile("../resources/shaders/ftv/f_ftv_stamp.glsl"); shaderPrg->bindAttribLocation(0, "vPosition"); shaderPrg->bindAttribLocation(1, "vUVCoord"); break; } case FTV_INPAINTING: { vertSource = readShaderFile("../resources/shaders/genericPostProc_v.glsl"); fragSource = readShaderFile("../resources/shaders/ftv/f_ftv_imageInpainting.glsl"); shaderPrg->bindAttribLocation(0, "vPosition"); shaderPrg->bindAttribLocation(1, "vUVCoord"); break; } case DISTANCEMAPPING: { vertSource = readShaderFile("../resources/shaders/genericPostProc_v.glsl"); fragSource = readShaderFile("../resources/shaders/ftv/f_ftv_distanceMapping.glsl"); shaderPrg->bindAttribLocation(0, "vPosition"); shaderPrg->bindAttribLocation(1, "vUVCoord"); break; } case FTV_MASK: { vertSource = readShaderFile("../resources/shaders/genericPostProc_v.glsl"); fragSource = readShaderFile("../resources/shaders/ftv/f_ftv_mask.glsl"); shaderPrg->bindAttribLocation(0, "vPosition"); shaderPrg->bindAttribLocation(1, "vUVCoord"); shaderPrg->bindFragDataLocation(0, "inpaintingMask"); shaderPrg->bindFragDataLocation(1, "distanceMap"); break; } case FTV_VOLUME_RAYCASTING : { vertSource = readShaderFile("../resources/shaders/ftv/v_ftv_volRen.glsl"); fragSource = readShaderFile("../resources/shaders/ftv/f_ftv_volRen.glsl"); shaderPrg->bindAttribLocation(0, "vPosition"); shaderPrg->bindAttribLocation(3, "vColour"); break; } case COHERENCE: { vertSource = readShaderFile("../resources/shaders/genericPostProc_v.glsl"); fragSource = readShaderFile("../resources/shaders/ftv/f_ftv_coherence.glsl"); shaderPrg->bindAttribLocation(0, "vPosition"); shaderPrg->bindAttribLocation(1, "vUVCoord"); break; } case FTV_IMPROVED_INPAINTING: { vertSource = readShaderFile("../resources/shaders/genericPostProc_v.glsl"); fragSource = readShaderFile("../resources/shaders/ftv/f_ftv_improvedInpainting.glsl"); shaderPrg->bindAttribLocation(0, "vPosition"); shaderPrg->bindAttribLocation(1, "vUVCoord"); break; } case FTV_GAUSSIAN: { vertSource = readShaderFile("../resources/shaders/genericPostProc_v.glsl"); fragSource = readShaderFile("../resources/shaders/ftv/f_ftv_seperatedGaussian.glsl"); shaderPrg->bindAttribLocation(0, "vPosition"); shaderPrg->bindAttribLocation(1, "vUVCoord"); break; } case FTV_MASK_SHRINK: { vertSource = readShaderFile("../resources/shaders/genericPostProc_v.glsl"); fragSource = readShaderFile("../resources/shaders/ftv/f_ftv_shrinkMask.glsl"); shaderPrg->bindAttribLocation(0, "vPosition"); shaderPrg->bindAttribLocation(1, "vUVCoord"); shaderPrg->bindFragDataLocation(0, "inpaintingMask"); shaderPrg->bindFragDataLocation(1, "distanceMap"); break; } case FTV_TEXTURE_ADVECTION: { vertSource = readShaderFile("../resources/shaders/ftv/v_ftv_textureAdvection.glsl"); fragSource = readShaderFile("../resources/shaders/f_idle.glsl"); shaderPrg->bindAttribLocation(0, "vPosition"); shaderPrg->bindAttribLocation(1, "vUVCoord"); break; } case FTV_LIC_INPAINTING: { vertSource = readShaderFile("../resources/shaders/genericPostProc_v.glsl"); fragSource = readShaderFile("../resources/shaders/ftv/f_ftv_licInpainting.glsl"); shaderPrg->bindAttribLocation(0, "vPosition"); shaderPrg->bindAttribLocation(1, "vUVCoord"); break; } default: { return false; break; } } if(!shaderPrg->compileShaderFromString(&vertSource,GL_VERTEX_SHADER)){ std::cout<<shaderPrg->getLog(); return false;} if(!shaderPrg->compileShaderFromString(&fragSource,GL_FRAGMENT_SHADER)){ std::cout<<shaderPrg->getLog(); return false;} if(!shaderPrg->link()){ std::cout<<shaderPrg->getLog(); return false;} inOutPrgPtr = shaderPrg; shader_program_list.push_back(std::move(shaderPrg)); return true; }
int main() { GLFWwindow* window; const int WIDTH = 800, HEIGHT = 600; char* WINDOW_NAME = "OpenGL - basic stuff"; initContext(); window = glfwCreateWindow(WIDTH, HEIGHT, WINDOW_NAME, nullptr, nullptr); glfwMakeContextCurrent(window); glfwSetKeyCallback(window, key_callback); glfwSetCursorPosCallback(window, mouse_callback); glfwSetScrollCallback(window, scroll_callback); //glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); initGLEW(); // Create VAOs GLuint vaoCube, vaoQuad, vaoLight; glGenVertexArrays(1, &vaoCube); glGenVertexArrays(1, &vaoQuad); glGenVertexArrays(1, &vaoLight); // Load vertex data GLuint vboCube, vboQuad; glGenBuffers(1, &vboCube); glGenBuffers(1, &vboQuad); glBindBuffer(GL_ARRAY_BUFFER, vboCube); glBufferData(GL_ARRAY_BUFFER, sizeof(cubeVertices), cubeVertices, GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, vboQuad); glBufferData(GL_ARRAY_BUFFER, sizeof(quadVertices), quadVertices, GL_STATIC_DRAW); // Create shader programs GLuint sceneVertexShader, sceneFragmentShader, sceneShaderProgram; createShaderProgram(readShaderFile("basic.vert"), readShaderFile("basic.frag"), sceneVertexShader, sceneFragmentShader, sceneShaderProgram); GLuint screenVertexShader, screenFragmentShader, screenShaderProgram; createShaderProgram(readShaderFile("basic_screen.vert"), readShaderFile("basic_screen.frag"), screenVertexShader, screenFragmentShader, screenShaderProgram); // Specify the layout of the vertex data glBindVertexArray(vaoCube); glBindBuffer(GL_ARRAY_BUFFER, vboCube); specifySceneVertexAttributes(sceneShaderProgram); glBindVertexArray(vaoQuad); glBindBuffer(GL_ARRAY_BUFFER, vboQuad); specifyScreenVertexAttributes(screenShaderProgram); glBindVertexArray(vaoLight); glBindBuffer(GL_ARRAY_BUFFER, vboCube); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0); // Note that we skip over the other data in our buffer object (we don't need the normals/textures, only positions). glEnableVertexAttribArray(0); glBindVertexArray(0); // Load textures GLuint diffuseMap = loadTextureMap("container2.png"); GLuint specularMap = loadTextureMap("container2_specular.png"); glUseProgram(sceneShaderProgram); glUniform1i(glGetUniformLocation(sceneShaderProgram, "texKitten"), 0); glUniform1i(glGetUniformLocation(sceneShaderProgram, "texPuppy"), 1); glUseProgram(screenShaderProgram); glUniform1i(glGetUniformLocation(screenShaderProgram, "texFramebuffer"), 0); GLint uniModel = glGetUniformLocation(sceneShaderProgram, "model"); // Create frame buffer GLuint frameBuffer; glGenFramebuffers(1, &frameBuffer); glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer); // Create texture to hold color buffer GLuint texColorBuffer; glGenTextures(1, &texColorBuffer); glBindTexture(GL_TEXTURE_2D, texColorBuffer); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 800, 600, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texColorBuffer, 0); // Create Renderbuffer Object to hold depth and stencil buffers GLuint rboDepthStencil; glGenRenderbuffers(1, &rboDepthStencil); glBindRenderbuffer(GL_RENDERBUFFER, rboDepthStencil); glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 800, 600); glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rboDepthStencil); glm::mat4 viewMatrix = glm::lookAt( glm::vec3(2.5f, 2.5f, 2.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 0.0f, 1.0f)); GLint uniView = glGetUniformLocation(sceneShaderProgram, "view"); glUniformMatrix4fv(uniView, 1, GL_FALSE, glm::value_ptr(viewMatrix)); glm::mat4 projMatrix = glm::perspective(camera.Zoom, (float)WIDTH / (float)HEIGHT, 0.1f, 100.0f); GLint uniProj = glGetUniformLocation(sceneShaderProgram, "proj"); glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(projMatrix)); GLint uniColor = glGetUniformLocation(sceneShaderProgram, "overrideColor"); GLint timer = glGetUniformLocation(sceneShaderProgram, "timer"); while (!glfwWindowShouldClose(window)) { GLfloat currentFrame = glfwGetTime(); deltaTime = currentFrame - lastFrame; lastFrame = currentFrame; glfwPollEvents(); Do_Movement(); // Bind our framebuffer and draw 3D scene(spinning cube) glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer); glBindVertexArray(vaoCube); glEnable(GL_DEPTH_TEST); glUseProgram(sceneShaderProgram); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, texKitten); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, texPuppy); // Clear the screen to white glClearColor(.2f, .2f, .2f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); GLfloat time = (GLfloat)glfwGetTime(); glUniform1f(timer, time); time = 0; viewMatrix = camera.GetViewMatrix(); projMatrix = glm::perspective(camera.Zoom, (float)WIDTH / (float)HEIGHT, 0.1f, 100.0f); glm::mat4 modelMatrix; modelMatrix = glm::rotate(modelMatrix, time * 100, glm::vec3(0.0f, 0.0f, 1.0f)); glUniformMatrix4fv(uniModel, 1, GL_FALSE, glm::value_ptr(modelMatrix)); glUniformMatrix4fv(uniView, 1, GL_FALSE, glm::value_ptr(viewMatrix)); glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(projMatrix)); // CUBE glDrawArrays(GL_TRIANGLES, 0, 36); glEnable(GL_STENCIL_TEST); // FLOOR /*glStencilFunc(GL_ALWAYS, 1, 0xFF); glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE); glStencilMask(0xFF); glDepthMask(GL_FALSE); glClear(GL_STENCIL_BUFFER_BIT); glDrawArrays(GL_TRIANGLES, 36, 6); // CUBE REFLECTION glStencilFunc(GL_EQUAL, 1, 0xFF); glStencilMask(0x00); glDepthMask(GL_TRUE); modelMatrix = glm::scale(glm::translate(modelMatrix, glm::vec3(0, 0, -1)), glm::vec3(1, 1, -1)); glUniformMatrix4fv(uniModel, 1, GL_FALSE, glm::value_ptr(modelMatrix)); glUniform3f(uniColor, 0.3f, 0.3f, 0.3f); glUniform3f(uniColor, 0.3f, 0.3f, 0.3f); glDrawArrays(GL_TRIANGLES, 0, 36); glUniform3f(uniColor, 1.0f, 1.0f, 1.0f);*/ glDisable(GL_STENCIL_TEST); // Bind default framebuffer and draw contents of our framebuffer glBindFramebuffer(GL_FRAMEBUFFER, 0); glBindVertexArray(vaoQuad); glDisable(GL_DEPTH_TEST); glUseProgram(screenShaderProgram); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, texColorBuffer); glDrawArrays(GL_TRIANGLES, 0, 6); glfwSwapBuffers(window); } glDeleteRenderbuffers(1, &rboDepthStencil); glDeleteTextures(1, &texColorBuffer); glDeleteFramebuffers(1, &frameBuffer); glDeleteTextures(1, &texKitten); glDeleteTextures(1, &texPuppy); glDeleteProgram(screenShaderProgram); glDeleteShader(screenFragmentShader); glDeleteShader(screenVertexShader); glDeleteProgram(sceneShaderProgram); glDeleteShader(sceneFragmentShader); glDeleteShader(sceneVertexShader); glDeleteBuffers(1, &vboCube); glDeleteBuffers(1, &vboQuad); glDeleteVertexArrays(1, &vaoCube); glDeleteVertexArrays(1, &vaoQuad); glfwTerminate(); }
const char *treeBarkPath_SHADER_VertexStrings[1]; const char *treeBarkPath_SHADER_FragmentStrings[1]; treeBarkPath_SHADER_Vertex = glCreateShaderObjectARB( GL_VERTEX_SHADER_ARB ); unsigned char *treeBarkPath_SHADER_VertexAssembly = readShaderFile( "_MODEL_FOLDERS_/treeBarkPath/treeBarkPath.vert" ); treeBarkPath_SHADER_VertexStrings[0] = (char*)treeBarkPath_SHADER_VertexAssembly; glShaderSourceARB( treeBarkPath_SHADER_Vertex, 1, treeBarkPath_SHADER_VertexStrings, NULL ); glCompileShaderARB( treeBarkPath_SHADER_Vertex); delete treeBarkPath_SHADER_VertexAssembly; treeBarkPath_SHADER_Fragment = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB ); unsigned char *treeBarkPath_SHADER_FragmentAssembly = readShaderFile( "_MODEL_FOLDERS_/treeBarkPath/treeBarkPath.frag" ); treeBarkPath_SHADER_FragmentStrings[0] = (char*)treeBarkPath_SHADER_FragmentAssembly; glShaderSourceARB( treeBarkPath_SHADER_Fragment, 1, treeBarkPath_SHADER_FragmentStrings, NULL ); glCompileShaderARB( treeBarkPath_SHADER_Fragment ); delete treeBarkPath_SHADER_FragmentAssembly; treeBarkPath_SHADER = glCreateProgramObjectARB(); glAttachObjectARB( treeBarkPath_SHADER, treeBarkPath_SHADER_Vertex ); glAttachObjectARB( treeBarkPath_SHADER, treeBarkPath_SHADER_Fragment ); glLinkProgramARB(treeBarkPath_SHADER); UNIFORM_counter_treeBarkPath = glGetUniformLocationARB( treeBarkPath_SHADER, "counter" );
void Shader::load(const std::string &file, const std::string &fragFile) { debugLog("Shader::load("+file+", "+fragFile+")"); loaded = false; #ifdef BBGE_BUILD_SHADERS g_location_texture = 0; g_location_mode = 0; g_location_value = 0; try { debugLog("Shader::load 1"); this->vertFile = file; this->fragFile = fragFile; // // If the required extension is present, get the addresses of its // functions that we wish to use... // debugLog("Shader::load 2"); char *ext = (char*)glGetString( GL_EXTENSIONS ); if( strstr( ext, "GL_ARB_shading_language_100" ) == NULL ) { //This extension string indicates that the OpenGL Shading Language, // version 1.00, is supported. debugLog("GL_ARB_shading_language_100 extension was not found"); /* MessageBox(NULL,"GL_ARB_shading_language_100 extension was not found", "ERROR",MB_OK|MB_ICONEXCLAMATION); */ return; } debugLog("Shader::load 3"); if( strstr( ext, "GL_ARB_shader_objects" ) == NULL ) { debugLog("GL_ARB_shader_objects extension was not found"); return; } else { // only do this once if it works if (!glCreateProgramObjectARB) { #ifdef BBGE_BUILD_GLFW glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC)glfwGetProcAddress("glCreateProgramObjectARB"); glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC)glfwGetProcAddress("glDeleteObjectARB"); glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC)glfwGetProcAddress("glUseProgramObjectARB"); glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)glfwGetProcAddress("glCreateShaderObjectARB"); glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)glfwGetProcAddress("glShaderSourceARB"); glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC)glfwGetProcAddress("glCompileShaderARB"); glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC)glfwGetProcAddress("glGetObjectParameterivARB"); glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC)glfwGetProcAddress("glAttachObjectARB"); glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC)glfwGetProcAddress("glGetInfoLogARB"); glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC)glfwGetProcAddress("glLinkProgramARB"); glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC)glfwGetProcAddress("glGetUniformLocationARB"); glUniform4fARB = (PFNGLUNIFORM4FARBPROC)glfwGetProcAddress("glUniform4fARB"); glUniform1iARB = (PFNGLUNIFORM1IARBPROC)glfwGetProcAddress("glUniform1iARB"); #endif #ifdef BBGE_BUILD_SDL glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC)SDL_GL_GetProcAddress("glCreateProgramObjectARB"); glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC)SDL_GL_GetProcAddress("glDeleteObjectARB"); glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC)SDL_GL_GetProcAddress("glUseProgramObjectARB"); glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)SDL_GL_GetProcAddress("glCreateShaderObjectARB"); glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)SDL_GL_GetProcAddress("glShaderSourceARB"); glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC)SDL_GL_GetProcAddress("glCompileShaderARB"); glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC)SDL_GL_GetProcAddress("glGetObjectParameterivARB"); glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC)SDL_GL_GetProcAddress("glAttachObjectARB"); glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC)SDL_GL_GetProcAddress("glGetInfoLogARB"); glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC)SDL_GL_GetProcAddress("glLinkProgramARB"); glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC)SDL_GL_GetProcAddress("glGetUniformLocationARB"); glUniform4fARB = (PFNGLUNIFORM4FARBPROC)SDL_GL_GetProcAddress("glUniform4fARB"); glUniform1iARB = (PFNGLUNIFORM1IARBPROC)SDL_GL_GetProcAddress("glUniform1iARB"); #endif if( !glCreateProgramObjectARB || !glDeleteObjectARB || !glUseProgramObjectARB || !glCreateShaderObjectARB || !glCreateShaderObjectARB || !glCompileShaderARB || !glGetObjectParameterivARB || !glAttachObjectARB || !glGetInfoLogARB || !glLinkProgramARB || !glGetUniformLocationARB || !glUniform4fARB || !glUniform1iARB ) { glCreateProgramObjectARB = 0; debugLog("One or more GL_ARB_shader_objects functions were not found"); return; } } } debugLog("Shader::load 4"); const char *vertexShaderStrings[1]; const char *fragmentShaderStrings[1]; GLint bVertCompiled; GLint bFragCompiled; GLint bLinked; char str[4096]; // // Create the vertex shader... // debugLog("Shader::load 5"); g_vertexShader = glCreateShaderObjectARB( GL_VERTEX_SHADER_ARB ); unsigned char *vertexShaderAssembly = readShaderFile( file.c_str() ); vertexShaderStrings[0] = (char*)vertexShaderAssembly; glShaderSourceARB( g_vertexShader, 1, vertexShaderStrings, NULL ); glCompileShaderARB( g_vertexShader); delete[] vertexShaderAssembly; glGetObjectParameterivARB( g_vertexShader, GL_OBJECT_COMPILE_STATUS_ARB, &bVertCompiled ); if( bVertCompiled == false ) //if (true) { glGetInfoLogARB(g_vertexShader, sizeof(str), NULL, str); std::ostringstream os; os << "Vertex Shader Compile Error: " << str; debugLog(os.str()); return; } // // Create the fragment shader... // debugLog("Shader::load 6"); g_fragmentShader = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB ); unsigned char *fragmentShaderAssembly = readShaderFile( fragFile.c_str() ); fragmentShaderStrings[0] = (char*)fragmentShaderAssembly; glShaderSourceARB( g_fragmentShader, 1, fragmentShaderStrings, NULL ); glCompileShaderARB( g_fragmentShader ); delete[] fragmentShaderAssembly; glGetObjectParameterivARB( g_fragmentShader, GL_OBJECT_COMPILE_STATUS_ARB, &bFragCompiled ); if( bFragCompiled == false ) { glGetInfoLogARB( g_fragmentShader, sizeof(str), NULL, str ); std::ostringstream os; os << "Fragment Shader Compile Error: " << str; debugLog(os.str()); return; } debugLog("Shader::load 7"); // // Create a program object and attach the two compiled shaders... // g_programObj = glCreateProgramObjectARB(); if (!g_programObj || !g_vertexShader || !g_fragmentShader) { debugLog("programObj / vertexShader / fragmentShader problem"); return; } glAttachObjectARB( g_programObj, g_vertexShader ); glAttachObjectARB( g_programObj, g_fragmentShader ); // // Link the program object and print out the info log... // glLinkProgramARB( g_programObj ); glGetObjectParameterivARB( g_programObj, GL_OBJECT_LINK_STATUS_ARB, &bLinked ); debugLog("Shader::load 8"); if( bLinked == false ) { glGetInfoLogARB( g_programObj, sizeof(str), NULL, str ); std::ostringstream os; os << "Shader Linking Error: " << str; debugLog(os.str()); return; } // // Locate some parameters by name so we can set them later... // debugLog("Shader::load 9"); g_location_texture = glGetUniformLocationARB( g_programObj, "tex" ); g_location_mode = glGetUniformLocationARB( g_programObj, "mode" ); g_location_value = glGetUniformLocationARB( g_programObj, "value" ); debugLog("Shader::load 10"); loaded = true; } catch(...) { debugLog("caught exception in shader::load"); loaded = false; } #endif debugLog("End Shader::load()"); }
const char *jetPackTopCones_SHADER_VertexStrings[1]; const char *jetPackTopCones_SHADER_FragmentStrings[1]; jetPackTopCones_SHADER_Vertex = glCreateShaderObjectARB( GL_VERTEX_SHADER_ARB ); unsigned char *jetPackTopCones_SHADER_VertexAssembly = readShaderFile( "_MODEL_FOLDERS_/jetPackTopCones/jetPackTopCones.vert" ); jetPackTopCones_SHADER_VertexStrings[0] = (char*)jetPackTopCones_SHADER_VertexAssembly; glShaderSourceARB( jetPackTopCones_SHADER_Vertex, 1, jetPackTopCones_SHADER_VertexStrings, NULL ); glCompileShaderARB( jetPackTopCones_SHADER_Vertex); delete jetPackTopCones_SHADER_VertexAssembly; jetPackTopCones_SHADER_Fragment = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB ); unsigned char *jetPackTopCones_SHADER_FragmentAssembly = readShaderFile( "_MODEL_FOLDERS_/jetPackTopCones/jetPackTopCones.frag" ); jetPackTopCones_SHADER_FragmentStrings[0] = (char*)jetPackTopCones_SHADER_FragmentAssembly; glShaderSourceARB( jetPackTopCones_SHADER_Fragment, 1, jetPackTopCones_SHADER_FragmentStrings, NULL ); glCompileShaderARB( jetPackTopCones_SHADER_Fragment ); delete jetPackTopCones_SHADER_FragmentAssembly; jetPackTopCones_SHADER = glCreateProgramObjectARB(); glAttachObjectARB( jetPackTopCones_SHADER, jetPackTopCones_SHADER_Vertex ); glAttachObjectARB( jetPackTopCones_SHADER, jetPackTopCones_SHADER_Fragment ); glLinkProgramARB(jetPackTopCones_SHADER); UNIFORM_counter_jetPackTopCones = glGetUniformLocationARB( jetPackTopCones_SHADER, "counter" );
/* * createShader - create, load, compile and link the shader object. */ GLhandleARB createShader(const char *vertfilename, const char *fragfilename) { GLhandleARB programObj; GLhandleARB fragmentShader; GLhandleARB vertexShader; const char *vertexShaderStrings[1]; GLint vertexCompiled; const char *fragmentShaderStrings[1]; GLint fragmentCompiled; GLint shadersLinked; char str[4096]; // For error messages from the GLSL compiler and linker // Create the vertex and fragment shaders vertexShader = glCreateShaderObjectARB( GL_VERTEX_SHADER_ARB ); char *vertexShaderAssembly = readShaderFile( vertfilename ); vertexShaderStrings[0] = vertexShaderAssembly; glShaderSourceARB( vertexShader, 1, vertexShaderStrings, NULL ); glCompileShaderARB( vertexShader ); free((void *)vertexShaderAssembly); glGetObjectParameterivARB( vertexShader, GL_OBJECT_COMPILE_STATUS_ARB, &vertexCompiled ); if(vertexCompiled == GL_FALSE) { glGetInfoLogARB( vertexShader, sizeof(str), NULL, str ); printError("Vertex shader compile error", str); } fragmentShader = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB ); char *fragmentShaderAssembly = readShaderFile( fragfilename ); fragmentShaderStrings[0] = fragmentShaderAssembly; glShaderSourceARB( fragmentShader, 1, fragmentShaderStrings, NULL ); glCompileShaderARB( fragmentShader ); free((void *)fragmentShaderAssembly); glGetObjectParameterivARB( fragmentShader, GL_OBJECT_COMPILE_STATUS_ARB, &fragmentCompiled ); if(fragmentCompiled == GL_FALSE) { glGetInfoLogARB( fragmentShader, sizeof(str), NULL, str ); printError("Fragment shader compile error", str); } // Create a program object and attach the compiled shaders programObj = glCreateProgramObjectARB(); glAttachObjectARB( programObj, vertexShader ); glAttachObjectARB( programObj, fragmentShader ); // Link the program object and print out the info log glLinkProgramARB( programObj ); glGetObjectParameterivARB( programObj, GL_OBJECT_LINK_STATUS_ARB, &shadersLinked ); if( shadersLinked == GL_FALSE ) { glGetInfoLogARB( programObj, sizeof(str), NULL, str ); printError("Program object linking error", str); } return programObj; }