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