GLuint GlFramework::createShader( const char* shader_prefix ) { char shader_name[128]; sprintf( shader_name, "%s.vs", shader_prefix ); const GLchar* vs_content = loadShader( shader_name ); sprintf( shader_name, "%s.fs", shader_prefix ); const GLchar* fs_content = loadShader( shader_name ); if (vs_content == NULL) { QMessageBox::critical(this, trUtf8("Erreur"), trUtf8("Echec du chargement d'un shader\n")); } GLint status, logSize; QByteArray log; GLuint pProgram; pProgram = glCreateProgram(); GLuint vshader = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vshader, 1, &vs_content, NULL); glCompileShader(vshader); glGetShaderiv(vshader, GL_COMPILE_STATUS, &status); if(status != GL_TRUE) { glGetShaderiv(vshader, GL_INFO_LOG_LENGTH, &logSize); log.resize(logSize - 1); glGetShaderInfoLog(vshader, logSize, &logSize, log.data()); QMessageBox::critical(this, trUtf8("Erreur"), trUtf8("Echec de la compilation du vertex shader:\n\n%1").arg(QString(log))); exit(-1); } glAttachShader(pProgram, vshader); GLuint fshader = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fshader, 1, &fs_content, NULL); glCompileShader(fshader); if(status != GL_TRUE) { glGetShaderiv(fshader, GL_INFO_LOG_LENGTH, &logSize); log.resize(logSize - 1); glGetShaderInfoLog(fshader, logSize, &logSize, log.data()); QMessageBox::critical(this, trUtf8("Erreur"), trUtf8("Echec de la compilation du fragment shader:\n\n%1").arg(QString(log))); exit(-1); } glAttachShader(pProgram, fshader); glLinkProgram(pProgram); glGetProgramiv(pProgram, GL_LINK_STATUS, &status); if(status != GL_TRUE) { glGetProgramiv(pProgram, GL_INFO_LOG_LENGTH, &logSize); log.resize(logSize - 1); glGetProgramInfoLog(pProgram, logSize, &logSize, log.data()); QMessageBox::critical(this, trUtf8("Erreur"), trUtf8("Echec du linkage du programme:\n\n%1").arg(QString(log))); exit(-1); } delete [] vs_content; delete [] fs_content; m_ShaderNames.push_back( shader_prefix ); m_Shader.push_back( pProgram ); return m_Shader.size()-1; }
bool DGLShader::compileAndAttachShader( GLuint& shaderID, GLenum shaderType, const char* shaderTypeStr, std::string filename, std::string contents ) { // if there's no filename and no contents, then a shader for this type hasn't been // specified. That's not (necessarily) an error, so return true - if it's a problem // then there will be a link error. if( !filename.length() && !contents.length() ) return true; // create this shader if it hasn't been created yet if( !shaderID ) shaderID = glCreateShader( shaderType ); // If a shader was passed in, just use that. Otherwise try and load from the filename. if( !contents.length() ) { // try and load the file if( !readFile( filename, contents ) ) { printf( "DGLShader: Error reading file %s\n", contents.c_str() ); return false; } } // try to compile the shader const char* source = contents.c_str(); glShaderSource( shaderID, 1, &source, NULL ); glCompileShader( shaderID ); // if it didn't work, print the error message GLint compileStatus; glGetShaderiv( shaderID, GL_COMPILE_STATUS, &compileStatus ); if( !compileStatus ) { // perhaps print the linker error if( _printErrors ) { // get the length of the error message GLint errorMessageLength; glGetShaderiv( shaderID, GL_INFO_LOG_LENGTH, &errorMessageLength ); // get the error message itself char* errorMessage = new char[errorMessageLength]; glGetShaderInfoLog( shaderID, errorMessageLength, &errorMessageLength, errorMessage ); // print the error if( filename.length() ) printf( "GLSL %s Compile Error (file: %s)\n", shaderTypeStr, filename.c_str() ); else printf( "GLSL %s Compile Error (no shader file)\n", shaderTypeStr ); printf( "================================================================================\n" ); // also display shader source { GLint length; glGetShaderiv(shaderID, GL_SHADER_SOURCE_LENGTH, &length); GLchar *source= new GLchar [length]; glGetShaderSource(shaderID, length, NULL, source); printf("%s\n", source); delete [] source; } printf( "%s\n", errorMessage ); printf( "\n" ); delete[] errorMessage; } return false; } // attach it to the program object glAttachShader( _programID, shaderID ); return true; }
bool Shaders::load() { /* Creating the vertex shader */ m_vertex = glCreateShader(GL_VERTEX_SHADER); if(glIsShader(m_vertex) != GL_TRUE) { core::logger::logm("Couldn't create vertex shader.", core::logger::WARNING); return false; } glShaderSource(m_vertex, 1, &vertexSrc, NULL); /* Compiling the vertex shader */ glCompileShader(m_vertex); GLint result; glGetShaderiv(m_vertex, GL_COMPILE_STATUS, &result); if(result != GL_TRUE) { core::logger::logm("Couldn't compile vertex shader.", core::logger::WARNING); logCompileError(m_vertex); return false; } /* Creating the fragment shader */ m_fragment = glCreateShader(GL_FRAGMENT_SHADER); if(glIsShader(m_fragment) != GL_TRUE) { core::logger::logm("Couldn't create fragment shader.", core::logger::WARNING); return false; } glShaderSource(m_fragment, 1, &fragmentSrc, NULL); /* Compiling the fragment shader */ glCompileShader(m_fragment); glGetShaderiv(m_fragment, GL_COMPILE_STATUS, &result); if(result != GL_TRUE) { core::logger::logm("Couldn't compile fragment shader.", core::logger::WARNING); logCompileError(m_fragment); return false; } /* Creating the openGL program */ m_program = glCreateProgram(); if(m_program == 0) { core::logger::logm("Couldn't create the shader program.", core::logger::WARNING); return false; } /* Attaching the shaders to the program */ glAttachShader(m_program, m_vertex); glAttachShader(m_program, m_fragment); /* Linking the program */ glLinkProgram(m_program); glGetProgramiv(m_program, GL_LINK_STATUS, &result); if(result != GL_TRUE) { core::logger::logm("Couldn't link the shader program.", core::logger::WARNING); GLint logsize; glGetProgramiv(m_program, GL_INFO_LOG_LENGTH, &logsize); if(logsize > 0) { char* log = new char [logsize]; glGetProgramInfoLog(m_program, logsize, &logsize, log); log[logsize - 1] = '\0'; std::ostringstream oss; oss << "Error while linking a shader program \"" << log << "\""; core::logger::logm(oss.str(), core::logger::MSG); delete[] log; } return false; } glUseProgram(m_program); /* Getting the uniforms */ if(!loadUniform(&m_text, "texture")) return false; /* Preparing the texture */ GLint tex = -1; if(!loadUniform(&tex, "tex")) return false; glUniform1i(tex, 0); return true; }
ShaderProgram::ShaderProgram(const char *vertex, const char *fragment, const ShaderFlags &flags) { File::uptr vs, fs; v = glCreateShader(GL_VERTEX_SHADER); f = glCreateShader(GL_FRAGMENT_SHADER); uint64 size; vs = File::map(vertex, File::Read, &size); std::unique_ptr<char[]> vs1(new char[size + 1]); memcpy(vs1.get(), vs.get(), size * sizeof(char)); vs1[size] = 0; fs = File::map(fragment, File::Read, &size); std::unique_ptr<char[]> fs1(new char[size + 1]); memcpy(fs1.get(), fs.get(), size * sizeof(char)); fs1[size] = 0; //TODO: Może troszkę to ulepszyć... (Chodzi o to, że header trzeba dokleić po #version) const char * vv = vs1.get(); std::string fscode = fs1.get(); size_t ver = fscode.find("#version"); ver = fscode.find("\n", ver); std::string ffs = fscode.substr(0, ver) + "\n" + flags.getHeader() + fscode.substr(ver + 1); const char * ff = ffs.c_str(); glShaderSource(v, 1, &vv, NULL); glShaderSource(f, 1, &ff, NULL); GLint status; glCompileShader(v); glGetShaderiv(v, GL_INFO_LOG_LENGTH, &status); std::unique_ptr<GLchar[]> buffer(new GLchar[status]); glGetShaderInfoLog(v, status, &status, buffer.get()); glGetShaderiv(v, GL_COMPILE_STATUS, &status); if(status != GL_TRUE) RAISE(ShaderException, "Error while compiling Vertex Shader!", buffer.get()); else LOG(errorLogger, "Vertex Shader Info Log:%s\n", buffer.get()); glCompileShader(f); glGetShaderiv(f, GL_INFO_LOG_LENGTH, &status); buffer = std::unique_ptr<GLchar[]>(new GLchar[status]); glGetShaderInfoLog(f, status, &status, buffer.get()); glGetShaderiv(f, GL_COMPILE_STATUS, &status); if(status != GL_TRUE) RAISE(ShaderException, "Error while compiling Fragment Shader!", buffer.get()); else LOG(errorLogger, "Fragment Shader Info Log:%s\n", buffer.get()); p = glCreateProgram(); glAttachShader(p, v); glAttachShader(p, f); glLinkProgram(p); glValidateProgram(p); glGetProgramiv(p, GL_INFO_LOG_LENGTH, &status); buffer = std::unique_ptr<GLchar[]>(new GLchar[status]); glGetProgramInfoLog(p, status, &status, buffer.get()); glGetProgramiv(p, GL_VALIDATE_STATUS, &status); if(status != GL_TRUE) RAISE(ShaderException, "Error while linking / validating Shader Program!", buffer.get()); else LOG(errorLogger, "Shader Program Info Log:%s\n", buffer.get()); HASSERT(p && v && f); }
bool ShaderVariation::Create() { Release(); if (!owner_) { compilerOutput_ = "Owner shader has expired"; return false; } object_ = glCreateShader(type_ == VS ? GL_VERTEX_SHADER : GL_FRAGMENT_SHADER); if (!object_) { compilerOutput_ = "Could not create shader object"; return false; } const String& originalShaderCode = owner_->GetSourceCode(type_); String shaderCode; // Check if the shader code contains a version define unsigned verStart = originalShaderCode.Find('#'); unsigned verEnd = 0; if (verStart != String::NPOS) { if (originalShaderCode.Substring(verStart + 1, 7) == "version") { verEnd = verStart + 9; while (verEnd < originalShaderCode.Length()) { if (IsDigit((unsigned)originalShaderCode[verEnd])) ++verEnd; else break; } // If version define found, insert it first String versionDefine = originalShaderCode.Substring(verStart, verEnd - verStart); shaderCode += versionDefine + "\n"; } } // Force GLSL version 150 if no version define and GL3 is being used if (!verEnd && Graphics::GetGL3Support()) shaderCode += "#version 150\n"; // Distinguish between VS and PS compile in case the shader code wants to include/omit different things shaderCode += type_ == VS ? "#define COMPILEVS\n" : "#define COMPILEPS\n"; // Add define for the maximum number of supported bones shaderCode += "#define MAXBONES " + String(Graphics::GetMaxBones()) + "\n"; // Prepend the defines to the shader code Vector<String> defineVec = defines_.Split(' '); for (unsigned i = 0; i < defineVec.Size(); ++i) { // Add extra space for the checking code below String defineString = "#define " + defineVec[i].Replaced('=', ' ') + " \n"; shaderCode += defineString; // In debug mode, check that all defines are referenced by the shader code #ifdef _DEBUG String defineCheck = defineString.Substring(8, defineString.Find(' ', 8) - 8); if (originalShaderCode.Find(defineCheck) == String::NPOS) URHO3D_LOGWARNING("Shader " + GetFullName() + " does not use the define " + defineCheck); #endif } #ifdef RPI if (type_ == VS) shaderCode += "#define RPI\n"; #endif #ifdef __EMSCRIPTEN__ shaderCode += "#define WEBGL\n"; #endif if (Graphics::GetGL3Support()) shaderCode += "#define GL3\n"; // When version define found, do not insert it a second time if (verEnd > 0) shaderCode += (originalShaderCode.CString() + verEnd); else shaderCode += originalShaderCode; const char* shaderCStr = shaderCode.CString(); glShaderSource(object_, 1, &shaderCStr, 0); glCompileShader(object_); int compiled, length; glGetShaderiv(object_, GL_COMPILE_STATUS, &compiled); if (!compiled) { glGetShaderiv(object_, GL_INFO_LOG_LENGTH, &length); compilerOutput_.Resize((unsigned)length); int outLength; glGetShaderInfoLog(object_, length, &outLength, &compilerOutput_[0]); glDeleteShader(object_); object_ = 0; } else compilerOutput_.Clear(); return object_ != 0; }
int main(int argc, char *argv[]) { SDL_Surface *screen; if ( SDL_Init(SDL_INIT_VIDEO) != 0 ) { printf("Unable to initialize SDL: %s\n", SDL_GetError()); return 1; } SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); screen = SDL_SetVideoMode( 640, 480, 24, SDL_OPENGL ); if ( !screen ) { printf("Unable to set video mode: %s\n", SDL_GetError()); return 1; } glClearColor( 0, 0, 0, 0 ); glClear( GL_COLOR_BUFFER_BIT ); // Fog glEnable(GL_FOG); glFogf(GL_FOG_START, 100); glFogf(GL_FOG_END, 2000); glFogi(GL_FOG_MODE, GL_LINEAR); GLfloat fogcolor[4] = { 0.9, 0.1, 0.35, 0 }; glFogfv(GL_FOG_COLOR, fogcolor); // Create a texture GLuint texture; glGenTextures( 1, &texture ); glBindTexture( GL_TEXTURE_2D, texture ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); GLubyte textureData[16*16*4]; for (int x = 0; x < 16; x++) { for (int y = 0; y < 16; y++) { *((int*)&textureData[(x*16 + y) * 4]) = x*16 + ((y*16) << 8); } } glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, textureData ); // Create a second texture GLuint texture2; glGenTextures( 1, &texture2 ); glBindTexture( GL_TEXTURE_2D, texture2 ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); GLubyte texture2Data[] = { 0xff, 0, 0, 0xff, 0, 0xff, 0, 0xaa, 0, 0, 0xff, 0x55, 0x80, 0x90, 0x70, 0 }; glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, texture2Data ); // BEGIN #if USE_GLEW glewInit(); #endif glMatrixMode(GL_PROJECTION); glLoadIdentity(); // original: glFrustum(-0.6435469817188064, 0.6435469817188064 ,-0.48266022190470925, 0.48266022190470925 ,0.5400000214576721, 2048); glFrustum(-0.6435469817188064, 0.1435469817188064 ,-0.48266022190470925, 0.88266022190470925 ,0.5400000214576721, 2048); glRotatef(-30, 1, 1, 1); //GLfloat pm[] = { 1.372136116027832, 0, 0, 0, 0, 0.7910231351852417, 0, 0, -0.6352481842041016, 0.29297152161598206, -1.0005275011062622, -1, 0, 0, -1.080284833908081, 0 }; //glLoadMatrixf(pm); glMatrixMode(GL_MODELVIEW); GLfloat matrixData[] = { -1, 0, 0, 0, 0, 0,-1, 0, 0, 1, 0, 0, 0, 0, 0, 1 }; glLoadMatrixf(matrixData); //glTranslated(-512,-512,-527); // XXX this should be uncommented, but if it is then nothing is shown glEnable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); glClear(GL_DEPTH_BUFFER_BIT); glEnableClientState(GL_NORMAL_ARRAY); glEnableClientState(GL_COLOR_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glActiveTexture(GL_TEXTURE0); glEnableClientState(GL_VERTEX_ARRAY); GLuint arrayBuffer, elementBuffer; glGenBuffers(1, &arrayBuffer); glGenBuffers(1, &elementBuffer); GLubyte arrayData[] = { /* [0, 0, 0, 67] ==> 128 float [0, 0, 128, 67] ==> 256 float [0, 0, 0, 68] ==> 512 float [0, 0, 128, 68] ==> 1024 float [vertex x ] [vertex y ] [vertex z ] [nr] [texture u ] [texture v ] [lm u ] [lm v ] [color r,g,b,a ] */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 68, 11, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, // 0 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 68, 23, 20, 0, 0, 0, 0, 0, 67, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, // 1 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 35, 30, 0, 0, 0, 0, 0, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 2 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 68, 47, 40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 3 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 68, 51, 50, 0, 0, 0, 0, 0, 67, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, // 4 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 68, 64, 60, 0, 0, 0, 0, 128, 67, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, // 5 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 68, 70, 70, 0, 0, 0, 0, 128, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 6 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 89, 80, 0, 0, 0, 0, 0, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 7 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 68, 94, 90, 0, 0, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 8 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 20, 10, 0, 0, 0, 0, 0, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 9 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 68, 31, 20, 0, 0, 0, 0, 0, 67, 0, 0, 128, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 10 0, 0, 0, 0, 0, 0, 128, 68, 0, 0, 0, 68, 42, 30, 0, 0, 0, 0, 0, 0, 0, 0, 128, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 11 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 53, 40, 0, 0, 0, 0, 0, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 12 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 68, 64, 50, 0, 0, 0, 0, 128, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 13 0, 0, 128, 68, 0, 0, 128, 68, 0, 0, 0, 68, 75, 60, 0, 0, 0, 0, 128, 67, 0, 0, 128, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 14 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 68, 86, 70, 0, 0, 0, 0, 0, 67, 0, 0, 128, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 15 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 128, 68, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128 }; assert(sizeof(arrayData) == 1408); glBindBuffer(GL_ARRAY_BUFFER, arrayBuffer); glBufferData(GL_ARRAY_BUFFER, sizeof(arrayData), arrayData, GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, 0); GLushort elementData[] = { 1, 2, 0, 2, 3, 0, 5, 6, 4, 6, 7, 4, 9, 10, 8, 10, 11, 8, 13, 14, 12, 14, 15, 12 }; assert(sizeof(elementData) == 48); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementBuffer); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(elementData), elementData, GL_STATIC_DRAW); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, arrayBuffer); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementBuffer); // sauer vertex data is apparently 0-12: V3F, 12: N1B, 16-24: T2F, 24-28: T2S, 28-32: C4B glVertexPointer(3, GL_FLOAT, 32, (void*)0); // all these apply to the ARRAY_BUFFER that is bound glTexCoordPointer(2, GL_FLOAT, 32, (void*)16); glClientActiveTexture(GL_TEXTURE1); // XXX seems to be ignored in native build glTexCoordPointer(2, GL_SHORT, 32, (void*)24); glClientActiveTexture(GL_TEXTURE0); // likely not needed, it is a cleanup glNormalPointer(GL_BYTE, 32, (void*)12); glColorPointer(4, GL_UNSIGNED_BYTE, 32, (void*)28); glBindTexture(GL_TEXTURE_2D, texture); // diffuse? glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, texture2); // lightmap? glActiveTexture(GL_TEXTURE0); GLint ok; const char *vertexShader = "uniform vec4 texgenscroll;\n" "void main(void)\n" "{\n" " gl_Position = ftransform();\n" " gl_TexCoord[0].xy = gl_MultiTexCoord0.xy/10000.0 + (0.001*texgenscroll.xy) + gl_Normal.xy;\n" // added /100 here " gl_TexCoord[1].xy = gl_MultiTexCoord1.xy/100.0 * 3.051851e-05;\n" " gl_FogFragCoord = gl_Position.z;\n" "}\n"; const char *fragmentShader = "uniform vec4 colorparams;\n" "uniform sampler2D diffusemap, lightmap;\n" "void main(void)\n" "{\n" " vec4 diffuse = texture2D(diffusemap, gl_TexCoord[0].xy);\n" " vec4 lm = texture2D(lightmap, gl_TexCoord[1].xy);\n" " diffuse *= colorparams;\n" " vec4 color = diffuse * lm;\n" " gl_FragColor.rgb = mix((gl_Fog.color).rgb, color.rgb, clamp((gl_Fog.end - gl_FogFragCoord) * gl_Fog.scale, 0.0, 1.0));\n" //" gl_FragColor.rgb = 0.0001 * color.rgb + ((gl_Fog.color).rgb * (1.0-clamp((gl_FogFragCoord)* 1.0/1000.0, 0.0, 1.0)));\n" "}\n"; GLuint vs = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vs, 1, &vertexShader, NULL); glCompileShader(vs); glGetShaderiv(vs, GL_COMPILE_STATUS, &ok); assert(ok); GLuint fs = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fs, 1, &fragmentShader, NULL); glCompileShader(fs); glGetShaderiv(fs, GL_COMPILE_STATUS, &ok); assert(ok); GLuint program = glCreateProgram(); glAttachShader(program, vs); glAttachShader(program, fs); glLinkProgram(program); glGetProgramiv(program, GL_LINK_STATUS, &ok); assert(ok); glUseProgram(program); GLint lightmapLocation = glGetUniformLocation(program, "lightmap"); assert(lightmapLocation >= 0); glUniform1i(lightmapLocation, 1); // sampler2D? Is it the texture unit? GLint diffusemapLocation = glGetUniformLocation(program, "diffusemap"); assert(diffusemapLocation >= 0); glUniform1i(diffusemapLocation, 0); GLint texgenscrollLocation = glGetUniformLocation(program, "texgenscroll"); assert(texgenscrollLocation >= 0); GLint colorparamsLocation = glGetUniformLocation(program, "colorparams"); assert(colorparamsLocation >= 0); GLfloat texgenscrollData[] = { 0, 0, 0, 0 }; glUniform4fv(texgenscrollLocation, 1, texgenscrollData); GLfloat colorparamsData[] = { 2, 2, 2, 1 }; glUniform4fv(colorparamsLocation, 1, colorparamsData); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*)12); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*) 0); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*)24); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*)36); // END SDL_GL_SwapBuffers(); #if !EMSCRIPTEN SDL_Delay(1500); #endif SDL_Quit(); return 0; }
// Create a GLSL program object from vertex and fragment shader files GLuint InitShader(const char* vShaderFile, const char* fShaderFile) { struct Shader { const char* filename; GLenum type; GLchar* source; } shaders[2] = { { vShaderFile, GL_VERTEX_SHADER, NULL }, { fShaderFile, GL_FRAGMENT_SHADER, NULL } }; GLuint program = glCreateProgram(); for ( int i = 0; i < 2; ++i ) { Shader& s = shaders[i]; s.source = readShaderSource( s.filename ); if ( shaders[i].source == NULL ) { std::cerr << "Failed to read " << s.filename << std::endl; exit( EXIT_FAILURE ); } GLuint shader = glCreateShader( s.type ); glShaderSource( shader, 1, (const GLchar**) &s.source, NULL ); glCompileShader( shader ); GLint compiled; glGetShaderiv( shader, GL_COMPILE_STATUS, &compiled ); if ( !compiled ) { std::cerr << s.filename << " failed to compile:" << std::endl; GLint logSize; glGetShaderiv( shader, GL_INFO_LOG_LENGTH, &logSize ); char* logMsg = new char[logSize]; glGetShaderInfoLog( shader, logSize, NULL, logMsg ); std::cerr << logMsg << std::endl; delete [] logMsg; exit( EXIT_FAILURE ); } delete [] s.source; glAttachShader( program, shader ); } /* link and error check */ glLinkProgram(program); GLint linked; glGetProgramiv( program, GL_LINK_STATUS, &linked ); if ( !linked ) { std::cerr << "Shader program failed to link" << std::endl; GLint logSize; glGetProgramiv( program, GL_INFO_LOG_LENGTH, &logSize); char* logMsg = new char[logSize]; glGetProgramInfoLog( program, logSize, NULL, logMsg ); std::cerr << logMsg << std::endl; delete [] logMsg; exit( EXIT_FAILURE ); } /* use program object */ glUseProgram(program); return program; }
bool GLSLESProgram::compile(const bool checkErrors) { if (mCompiled == 1) { return true; } // Only create a shader object if glsl es is supported if (isSupported()) { GL_CHECK_ERROR // Create shader object GLenum shaderType = 0x0000; if (mType == GPT_VERTEX_PROGRAM) { shaderType = GL_VERTEX_SHADER; } else if (mType == GPT_FRAGMENT_PROGRAM) { shaderType = GL_FRAGMENT_SHADER; } mGLShaderHandle = glCreateShader(shaderType); GL_CHECK_ERROR #if GL_EXT_debug_label glLabelObjectEXT(GL_SHADER_OBJECT_EXT, mGLShaderHandle, 0, mName.c_str()); #endif if(Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_SEPARATE_SHADER_OBJECTS)) { mGLProgramHandle = glCreateProgram(); GL_CHECK_ERROR #if GL_EXT_debug_label glLabelObjectEXT(GL_PROGRAM_OBJECT_EXT, mGLProgramHandle, 0, mName.c_str()); #endif } } // Add preprocessor extras and main source if (!mSource.empty()) { const char *source = mSource.c_str(); glShaderSource(mGLShaderHandle, 1, &source, NULL); // Check for load errors GL_CHECK_ERROR } if (checkErrors) logObjectInfo("GLSL ES compiling: " + mName, mGLShaderHandle); glCompileShader(mGLShaderHandle); GL_CHECK_ERROR // Check for compile errors glGetShaderiv(mGLShaderHandle, GL_COMPILE_STATUS, &mCompiled); if(!mCompiled && checkErrors) { String message = logObjectInfo("GLSL ES compile log: " + mName, mGLShaderHandle); checkAndFixInvalidDefaultPrecisionError(message); } // Log a message that the shader compiled successfully. if (mCompiled && checkErrors) logObjectInfo("GLSL ES compiled: " + mName, mGLShaderHandle); return (mCompiled == 1); }
bool ShaderVariation::Create() { Release(); if (!owner_) { compilerOutput_ = "Owner shader has expired"; return false; } object_ = glCreateShader(type_ == VS ? GL_VERTEX_SHADER : GL_FRAGMENT_SHADER); if (!object_) { compilerOutput_ = "Could not create shader object"; return false; } const QString& originalShaderCode = owner_->GetSourceCode(type_); QString shaderCode; // Check if the shader code contains a version define int verStart = originalShaderCode.indexOf('#'); int verEnd = 0; if (verStart != -1) { if (originalShaderCode.midRef(verStart + 1, 7) == "version") { verEnd = verStart + 9; while (verEnd < originalShaderCode.length()) { if (originalShaderCode[verEnd].isDigit()) ++verEnd; else break; } // If version define found, insert it first QString versionDefine = originalShaderCode.mid(verStart, verEnd - verStart); shaderCode += versionDefine + "\n"; } } // Force GLSL version 150 if no version define and GL3 is being used if (!verEnd) shaderCode += "#version 150\n"; // Distinguish between VS and PS compile in case the shader code wants to include/omit different things shaderCode += type_ == VS ? "#define COMPILEVS\n" : "#define COMPILEPS\n"; // Add define for the maximum number of supported bones shaderCode += "#define MAXBONES " + QString::number(Graphics::GetMaxBones()) + "\n"; // Prepend the defines to the shader code QStringList defineVec = defines_.split(' ',QString::SkipEmptyParts); for (QString &str : defineVec) { // Add extra space for the checking code below QString defineString = "#define " + str.replace('=', ' ') + " \n"; shaderCode += defineString; // In debug mode, check that all defines are referenced by the shader code #ifdef _DEBUG QString defineCheck = defineString.mid(8, defineString.indexOf(' ', 8) - 8); if (originalShaderCode.indexOf(defineCheck) == -1) URHO3D_LOGWARNING("Shader " + GetFullName() + " does not use the define " + defineCheck); #endif } shaderCode += "#define GL3\n"; // When version define found, do not insert it a second time if (verEnd > 0) shaderCode += originalShaderCode.midRef(verEnd); else shaderCode += originalShaderCode; QByteArray shaderCodeBytes= shaderCode.toLatin1(); const char* shaderCStr = shaderCodeBytes.data(); glShaderSource(object_, 1, &shaderCStr, nullptr); glCompileShader(object_); int compiled, length; glGetShaderiv(object_, GL_COMPILE_STATUS, &compiled); if (!compiled) { glGetShaderiv(object_, GL_INFO_LOG_LENGTH, &length); QByteArray compilerOutputBytes(length,0); int outLength; glGetShaderInfoLog(object_, length, &outLength, compilerOutputBytes.data()); glDeleteShader(object_); object_ = 0; compilerOutput_ = compilerOutputBytes; } else compilerOutput_.clear(); return object_ != 0; }
HQReturnVal HQBaseGLSLShaderController::CreateShaderFromMemoryGLSL(HQShaderType type, const char* source, const HQShaderMacro * pDefines,//pointer đến dãy các shader macro, phần tử cuối phải có cả 2 thành phần <name> và <definition>là NULL để chỉ kết thúc dãy HQShaderObjectGL **ppShaderObjectOut) { if(source == NULL) { return HQ_FAILED; } GLenum shaderType; bool selfContained = false; switch (type) { case HQ_VERTEX_SHADER: shaderType = GL_VERTEX_SHADER; break; case HQ_PIXEL_SHADER: shaderType = GL_FRAGMENT_SHADER; break; #ifdef GL_GEOMETRY_SHADER case HQ_GEOMETRY_SHADER: if (GLEW_EXT_geometry_shader4 || GLEW_VERSION_3_2) { shaderType = GL_GEOMETRY_SHADER; break; } #endif #ifdef GL_COMPUTE_SHADER case HQ_COMPUTE_SHADER: if (GLEW_VERSION_4_3) { shaderType = GL_COMPUTE_SHADER; selfContained = true; break; } #endif default: g_pShaderMan->Log("Error : Unsupported GLSL shader type=%u", (hquint32)type); return HQ_FAILED; } HQShaderObjectGL *sobject = HQ_NEW HQShaderObjectGL(); sobject->type = type; sobject->selfContainProgram = selfContained; sobject->isGLSL = true; bool parseSuccess ; std::string processed_src; HQLinkedList<HQUniformBlockInfoGL>** ppUBlocksInfo = NULL; ppUBlocksInfo = &sobject->pUniformBlocks; bool native_UBO_supported = GLEW_VERSION_3_1 == GL_TRUE; #ifdef HQ_OPENGLES std::string preDefined = "#define HQEXT_GLSL_ES\n"; #else std::string preDefined = "#define HQEXT_GLSL\n"; #endif this->AppendPredefinedMacros(preDefined);//implement dependent /*--------------preprocess source---------------*/ if(type==HQ_VERTEX_SHADER) { parseSuccess = pVParser->Parse(source, g_pShaderMan->GetIncludeFileManager(), preDefined, pDefines, processed_src, native_UBO_supported, ppUBlocksInfo, &sobject->pAttribList, &sobject->pUniformSamplerList); } else { parseSuccess = pVParser->Parse(source, g_pShaderMan->GetIncludeFileManager(), preDefined, pDefines, processed_src, native_UBO_supported, ppUBlocksInfo, NULL, &sobject->pUniformSamplerList); } if (!parseSuccess) { delete sobject; return HQ_FAILED; } sobject->shader = glCreateShader(shaderType); std::string version_string = ""; /*------ Remove #version in the source---------*/ { size_t pos1 = processed_src.find("#"); if (pos1 != std::string::npos) { size_t pos2 = processed_src.find("version", pos1); if (pos2 != std::string::npos) { bool found = true; for (size_t i = pos1 + 1; i < pos2; ++i)//make sure only white spaces are between "#" and "version" { char c = processed_src[i]; if (c != ' ' && c != '\t' && c != '\r') { found = false; break; } } if (found) { size_t pos3 = processed_src.find("\n", pos2 + 7); version_string.assign(processed_src.c_str() + pos1, pos3 - pos1 + 1); for (size_t i = pos1; i < pos3; ++i) { processed_src[i] = ' ';//remove from the source } } }//if (pos2 != std::string::npos) }//if (pos1 != std::string::npos) } /*---create macro definition list---------*/ std::string macroDefList; this->GetPredefineMacroGLSL(macroDefList , pDefines, version_string); //get version number int version_number = 0; if (sscanf(version_string.c_str(), "#version %d", &version_number) != 1) sscanf(version_string.c_str(), "# version %d", &version_number);//try one more time std::string UBO_extension_line = ""; //work around uniform buffer objects if (sobject->pUniformBlocks != NULL && sobject->pUniformBlocks->GetSize() > 0) { if (native_UBO_supported) { SafeDelete(sobject->pUniformBlocks);//no need for this information InsertUBO_STD140_LayoutControl(processed_src);//set std140 layout as default #ifdef HQ_OPENGLES if (version_number < 300) { version_string = "#version 300 es\n";//300 is minimum version for uniform buffer objects g_pShaderMan->Log("GLSL shader compile warning: shader contains uniform buffer blocks but they are not supported. Switching to version 300 es...", version_number); } #else//#ifdef HQ_OPENGLES if (version_number < 140) { version_string = "#version 140\n";//140 is minimum version for uniform buffer objects g_pShaderMan->Log("GLSL shader compile warning: shader contains uniform buffer blocks but they are not supported. Switching to version 140...", version_number); } #endif//#ifdef HQ_OPENGLES }//if (native_UBO_supported) }//if (sobject->pUniformBlocks != NULL && sobject->pUniformBlocks->GetSize() > 0) /*--------set shader source---------*/ const GLchar* sourceArray[] = { version_string.c_str(), UBO_extension_line.c_str(), semanticKeywords, samplerKeywords, preDefined.c_str(), macroDefList.c_str(), "#line 0 0\n", processed_src.c_str() }; if (type != HQ_VERTEX_SHADER) sourceArray[2] = "";//only vertex shader need semantic definitions glShaderSource(sobject->shader, 8, (const GLchar**)sourceArray, NULL); glCompileShader(sobject->shader); GLint compileOK; glGetShaderiv(sobject->shader , GL_COMPILE_STATUS , &compileOK); bool error = (sobject->shader==0 || compileOK == GL_FALSE); { int infologLength = 0; int charsWritten = 0; char *infoLog; glGetShaderiv(sobject->shader, GL_INFO_LOG_LENGTH,&infologLength); if (infologLength > 0) { #if LOG_SRC_ERR int src_length; char * glsource; glGetShaderiv(sobject->shader, GL_SHADER_SOURCE_LENGTH,&src_length); glsource = (char*)malloc(src_length); glGetShaderSource(sobject->shader, src_length, NULL, glsource); #endif infoLog = (char *)malloc(infologLength); glGetShaderInfoLog(sobject->shader, infologLength, &charsWritten, infoLog); if (error) #if LOG_SRC_ERR g_pShaderMan->Log("GLSL shader compile error: %s. Source code=<%s>",infoLog, glsource); #else g_pShaderMan->Log("GLSL shader compile error: %s",infoLog); #endif else g_pShaderMan->Log("GLSL shader compile info: %s",infoLog); free(infoLog); #if LOG_SRC_ERR free(glsource); #endif }
///////////////////////////////////////////////////////////////// // Load a pair of shaders, compile, and link together. Specify the complete // file path for each shader. Note, there is no support for // just loading say a vertex program... you have to do both. GLuint gltLoadShaderPair(const char *szVertexProg, const char *szFragmentProg, bool loadFromFile) { // Temporary Shader objects GLuint hVertexShader; GLuint hFragmentShader; GLuint hReturn = 0; GLint testVal; // Create shader objects hVertexShader = glCreateShader(GL_VERTEX_SHADER); hFragmentShader = glCreateShader(GL_FRAGMENT_SHADER); if (loadFromFile) { if(gltLoadShaderFile(szVertexProg, hVertexShader) == false) { glDeleteShader(hVertexShader); glDeleteShader(hFragmentShader); return (GLuint)NULL; } if(gltLoadShaderFile(szFragmentProg, hFragmentShader) == false) { glDeleteShader(hVertexShader); glDeleteShader(hFragmentShader); return (GLuint)NULL; } } else { gltLoadShaderSrc(vertexShader, hVertexShader); gltLoadShaderSrc(fragmentShader, hFragmentShader); } // Compile them glCompileShader(hVertexShader); glCompileShader(hFragmentShader); // Check for errors glGetShaderiv(hVertexShader, GL_COMPILE_STATUS, &testVal); if(testVal == GL_FALSE) { char temp[256] = ""; glGetShaderInfoLog( hVertexShader, 256, NULL, temp); fprintf( stderr, "Compile failed:\n%s\n", temp); assert(0); exit(0); glDeleteShader(hVertexShader); glDeleteShader(hFragmentShader); return (GLuint)NULL; } glGetShaderiv(hFragmentShader, GL_COMPILE_STATUS, &testVal); if(testVal == GL_FALSE) { char temp[256] = ""; glGetShaderInfoLog( hFragmentShader, 256, NULL, temp); fprintf( stderr, "Compile failed:\n%s\n", temp); assert(0); exit(0); glDeleteShader(hVertexShader); glDeleteShader(hFragmentShader); return (GLuint)NULL; } // Link them - assuming it works... hReturn = glCreateProgram(); glAttachShader(hReturn, hVertexShader); glAttachShader(hReturn, hFragmentShader); glLinkProgram(hReturn); // These are no longer needed glDeleteShader(hVertexShader); glDeleteShader(hFragmentShader); // Make sure link worked too glGetProgramiv(hReturn, GL_LINK_STATUS, &testVal); if(testVal == GL_FALSE) { glDeleteProgram(hReturn); return (GLuint)NULL; } return hReturn; }
/*!************************************************************************************ @Function initView @Return bool 1 if no error occured @Description Code in initView() will be called upon initialization or after a change in the rendering context. Used to initialize variables that are dependant on the rendering context (e.g. textures, vertex buffers, etc.) ***************************************************************************************/ int initView() { // Fragment and vertex shaders code // Create the fragment shader object m_uiFragShader = glCreateShader(GL_FRAGMENT_SHADER); // Load the source code into it glShaderSource(m_uiFragShader, 1, (const char**)&fshader_src, NULL); // Compile the source code glCompileShader(m_uiFragShader); // Check if compilation succeeded GLint bShaderCompiled; glGetShaderiv(m_uiFragShader, GL_COMPILE_STATUS, &bShaderCompiled); if (!bShaderCompiled) { // An error happened, first retrieve the length of the log message int i32InfoLogLength, i32CharsWritten; glGetShaderiv(m_uiFragShader, GL_INFO_LOG_LENGTH, &i32InfoLogLength); // Allocate enough space for the message and retrieve it char* pszInfoLog = (char*) malloc(sizeof(char)*i32InfoLogLength); glGetShaderInfoLog(m_uiFragShader, i32InfoLogLength, &i32CharsWritten, pszInfoLog); char* pszMsg = (char*) malloc(sizeof(char)* (i32InfoLogLength+256)); sprintf(pszMsg, "Failed to compile fragment shader: %s", pszInfoLog); free(pszMsg); free(pszInfoLog); return 0; } // Loads the vertex shader in the same way m_uiVertexShader = glCreateShader(GL_VERTEX_SHADER); glShaderSource(m_uiVertexShader, 1, (const char**)&vshader_src, NULL); glCompileShader(m_uiVertexShader); glGetShaderiv(m_uiVertexShader, GL_COMPILE_STATUS, &bShaderCompiled); if (!bShaderCompiled) { int i32InfoLogLength, i32CharsWritten; glGetShaderiv(m_uiVertexShader, GL_INFO_LOG_LENGTH, &i32InfoLogLength); char* pszInfoLog = (char*) malloc(sizeof(char)* i32InfoLogLength); glGetShaderInfoLog(m_uiVertexShader, i32InfoLogLength, &i32CharsWritten, pszInfoLog); char* pszMsg = (char*) malloc(sizeof(char)* (i32InfoLogLength+256)); sprintf(pszMsg, "Failed to compile vertex shader: %s", pszInfoLog); free(pszMsg); free(pszInfoLog); return 0; } // Create the shader program program = glCreateProgram(); // Attach the fragment and vertex shaders to it glAttachShader(program, m_uiFragShader); glAttachShader(program, m_uiVertexShader); // Bind vPosition to attribute 0 glBindAttribLocation(program, 0, "vPosition"); glBindAttribLocation(program, 1, "inTexCoord"); // Link the program glLinkProgram(program); // Check if linking succeeded in the same way we checked for compilation success GLint bLinked; glGetProgramiv(program, GL_LINK_STATUS, &bLinked); if (!bLinked) { int i32InfoLogLength, i32CharsWritten; glGetProgramiv(program, GL_INFO_LOG_LENGTH, &i32InfoLogLength); char* pszInfoLog = (char*) malloc(sizeof(char)* i32InfoLogLength); glGetProgramInfoLog(program, i32InfoLogLength, &i32CharsWritten, pszInfoLog); char* pszMsg = (char*) malloc(sizeof(char)* (i32InfoLogLength+256)); sprintf(pszMsg, "Failed to link program: %s", pszInfoLog); free(pszMsg); free(pszInfoLog); return 0; } // Actually use the created program glUseProgram(program); // Set the variable to the first texture unit glUniform1i(glGetUniformLocation(program, "sTexture"), 0); return 1; }
int initResources( void ) { const char* vsSource; const char* fsSource; char* attribute_coord3d_name; char* attribute_corRGB_name; const char* uniform_matriz_global_name; GLint compileOK = GL_FALSE; GLint linkOK = GL_FALSE; /* String contendo o codigo (GLSL) do vertex-shader */ vsSource = readShaderSource( "vShader.glsl" ); if( vsSource == NULL ) { fprintf( stderr, "ERRO no LEITURA do VERTEX-SHADER\n" ); exit( EXIT_FAILURE ); } /* Para passar vertices 3D ao Vertex-Shader */ attribute_coord3d_name = "coord3d"; /* Para passar cores ao Vertex-Shader */ attribute_corRGB_name = "v_corRGB"; /* Para passar a matriz global ao Vertex-Shader */ uniform_matriz_global_name = "matriz"; /* String contendo o codigo (GLSL) do fragment-shader */ fsSource = readShaderSource( "fShader.glsl" ); if( fsSource == NULL ) { fprintf( stderr, "ERRO no LEITURA do FRAGMENT-SHADER\n" ); exit( EXIT_FAILURE ); } /* Criar e compilar o Vertex-Shader */ vs = glCreateShader( GL_VERTEX_SHADER ); glShaderSource( vs, 1, &vsSource, NULL ); glCompileShader( vs ); glGetShaderiv( vs, GL_COMPILE_STATUS, &compileOK ); if( compileOK == 0 ) { fprintf( stderr, "Error in vertex shader\n" ); return 0; } /* Criar e compilar o Fragment-Shader */ fs = glCreateShader( GL_FRAGMENT_SHADER ); glShaderSource( fs, 1, &fsSource, NULL ); glCompileShader( fs ); glGetShaderiv( fs, GL_COMPILE_STATUS, &compileOK ); if( compileOK == 0 ) { fprintf( stderr, "Error in fragment shader\n" ); return 0; } /* Criando o programa em GLSL */ programaGLSL = glCreateProgram(); glAttachShader( programaGLSL, vs ); glAttachShader( programaGLSL, fs ); glLinkProgram( programaGLSL ); glGetProgramiv( programaGLSL, GL_LINK_STATUS, &linkOK ); if( linkOK == 0 ) { fprintf( stderr, "Error while linking\n" ); return 0; } /* Para input ao Vertex-Shader */ attribute_coord3d = glGetAttribLocation( programaGLSL, attribute_coord3d_name ); if( attribute_coord3d == -1 ) { fprintf( stderr, "Could not bind attribute %s\n", attribute_coord3d_name ); return 0; } attribute_corRGB = glGetAttribLocation( programaGLSL, attribute_corRGB_name ); if( attribute_corRGB == -1 ) { fprintf( stderr, "Could not bind attribute %s\n", attribute_corRGB_name ); return 0; } uniform_location_matriz_global = glGetUniformLocation( programaGLSL, "matriz"); if( uniform_location_matriz_global == -1 ) { fprintf( stderr, "Could not bind uniform %s\n", uniform_matriz_global_name ); return 0; } return 1; }
DisplayClass::DisplayClass(void) { this->camera = new Camera(); this->light = new Light(); rotation = 0.0f; //Call GLEW only _after_ you get the window //I had to tell the author of your textbook that ;-) -Cory glewInit(); //Create the VBOs and IBO we'll be using to render images in OpenGL glGenBuffers(1, &vbo); glGenBuffers(1, &cbo); glGenBuffers(1, &nbo); glGenBuffers(1, &ibo); // assign locations positionLocation = 0; colorLocation = 1; normalLocation = 2; //Everybody does this glClearColor(0, 0, 0, 1); glEnable(GL_DEPTH_TEST); glClearDepth(1.0); glDepthFunc(GL_LEQUAL); //here is stuff for setting up our shaders const char* fragFile = "diffuseFrag.frag"; const char* vertFile = "diffuseVert.vert"; vertexShader = glCreateShader(GL_VERTEX_SHADER); fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); shaderProgram = glCreateProgram(); //load up the source, compile and link the shader program const char* vertSource = textFileRead(vertFile); const char* fragSource = textFileRead(fragFile); glShaderSource(vertexShader, 1, &vertSource, 0); glShaderSource(fragmentShader, 1, &fragSource, 0); glCompileShader(vertexShader); glCompileShader(fragmentShader); //For your convenience, i decided to throw in some compiler/linker output helper functions //from CIS 565 GLint compiled; glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &compiled); if (!compiled) { printShaderInfoLog(vertexShader); } glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &compiled); if (!compiled) { printShaderInfoLog(fragmentShader); } //set the attribute locations for our shaders glBindAttribLocation(shaderProgram, positionLocation, "vs_position"); glBindAttribLocation(shaderProgram, normalLocation, "vs_normal"); glBindAttribLocation(shaderProgram, colorLocation, "vs_color"); //finish shader setup glAttachShader(shaderProgram, vertexShader); glAttachShader(shaderProgram, fragmentShader); glLinkProgram(shaderProgram); //check for linking success GLint linked; glGetProgramiv(shaderProgram,GL_LINK_STATUS, &linked); if (!linked) { printLinkInfoLog(shaderProgram); } //Get the uniform locations for our shaders, unfortunately they can not be set by us, we have //to ask OpenGL for them u_modelMatrixLocation = glGetUniformLocation(shaderProgram, "u_modelMatrix"); u_projMatrixLocation = glGetUniformLocation(shaderProgram, "u_projMatrix"); u_lightPosition = glGetUniformLocation(shaderProgram, "u_lightPos"); u_lightColor = glGetUniformLocation(shaderProgram, "u_lightColor"); //Always remember that it doesn't do much good if you don't have OpenGL actually use the shaders glUseProgram(shaderProgram); glUniform3f(u_lightColor, light->color.r, light->color.g, light->color.b); glUniform3f(u_lightPosition, light->position.x, light->position.y, light->position.z); camera->resizeWindow(DEFAULT_WIDTH, DEFAULT_HEIGHT); }
// Alternative single C++ method to Load/Compile/Link a pair for vertex and fragment shaders GLuint LoadShaders(const char * vertex_file_path,const char * fragment_file_path) { string str_vertex_filepath = getGLSLResourcePath(vertex_file_path); //cout << str_vertex_filepath << endl; string str_fragment_filepath = getGLSLResourcePath(fragment_file_path); //cout << str_fragment_filepath << endl; // Create the shaders GLuint VertexShaderID = glCreateShader(GL_VERTEX_SHADER); GLuint FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER); // Read the Vertex Shader code from the file std::string VertexShaderCode; std::ifstream VertexShaderStream(str_vertex_filepath.c_str(), std::ios::in); if(VertexShaderStream.is_open()){ std::string Line = ""; while(getline(VertexShaderStream, Line)) VertexShaderCode += "\n" + Line; VertexShaderStream.close(); } else { std::cout<<"shader: "<<str_vertex_filepath<<" not found!"<<std::endl; return 0; } // Read the Fragment Shader code from the file std::string FragmentShaderCode; std::ifstream FragmentShaderStream(str_fragment_filepath.c_str(), std::ios::in); if(FragmentShaderStream.is_open()){ std::string Line = ""; while(getline(FragmentShaderStream, Line)) FragmentShaderCode += "\n" + Line; FragmentShaderStream.close(); } else { std::cout<<"shader: "<<str_fragment_filepath<<" not found!"<<std::endl; return 0; } GLint Result = GL_FALSE; int InfoLogLength=10; // Compile Vertex Shader printf("Compiling shader : %s\n\n", str_vertex_filepath.c_str()); char const * VertexSourcePointer = VertexShaderCode.c_str(); glShaderSource(VertexShaderID, 1, &VertexSourcePointer , NULL); glCompileShader(VertexShaderID); // Check Vertex Shader glGetShaderiv(VertexShaderID, GL_COMPILE_STATUS, &Result); if (!Result) { glGetShaderiv(VertexShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength); std::vector<char> VertexShaderErrorMessage(InfoLogLength); glGetShaderInfoLog(VertexShaderID, InfoLogLength, NULL, &VertexShaderErrorMessage[0]); fprintf(stdout, "%s\n", &VertexShaderErrorMessage[0]); } // Compile Fragment Shader printf("Compiling shader : %s\n\n", str_fragment_filepath.c_str()); char const * FragmentSourcePointer = FragmentShaderCode.c_str(); glShaderSource(FragmentShaderID, 1, &FragmentSourcePointer , NULL); glCompileShader(FragmentShaderID); // Check Fragment Shader glGetShaderiv(FragmentShaderID, GL_COMPILE_STATUS, &Result); if (!Result) { glGetShaderiv(FragmentShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength); std::vector<char> FragmentShaderErrorMessage(InfoLogLength); glGetShaderInfoLog(FragmentShaderID, InfoLogLength, NULL, &FragmentShaderErrorMessage[0]); fprintf(stdout, "%s\n", &FragmentShaderErrorMessage[0]); } // Link the program fprintf(stdout, "Linking program\n"); GLuint ProgramID = glCreateProgram(); glAttachShader(ProgramID, VertexShaderID); glAttachShader(ProgramID, FragmentShaderID); glLinkProgram(ProgramID); // Check the program glGetProgramiv(ProgramID, GL_LINK_STATUS, &Result); glGetProgramiv(ProgramID, GL_INFO_LOG_LENGTH, &InfoLogLength); std::vector<char> ProgramErrorMessage( max(InfoLogLength, int(1)) ); glGetProgramInfoLog(ProgramID, InfoLogLength, NULL, &ProgramErrorMessage[0]); fprintf(stdout, "%s\n", &ProgramErrorMessage[0]); glDeleteShader(VertexShaderID); glDeleteShader(FragmentShaderID); return ProgramID; }
bool Shader::LoadFromFile(const char *pathVertex, const char *pathFragment) { m_VertexShaderObj = glCreateShader(GL_VERTEX_SHADER); m_FragmentShaderObj = glCreateShader(GL_FRAGMENT_SHADER); m_Program = glCreateProgram(); std::ifstream fileVer; std::ifstream fileFrag; fileVer.open(pathVertex); if (fileVer.is_open()) { std::string buffer; while (fileVer.good()) { std::getline(fileVer, buffer); m_VertexSource.append(buffer + "\n"); } fileVer.close(); } else { std::cout << "Cannot open shader file: " << pathVertex << std::endl; return false; } fileFrag.open(pathFragment); if (fileFrag.is_open()) { std::string buffer; while (fileFrag.good()) { getline(fileFrag, buffer); m_FragmentSource.append(buffer + "\n"); } fileFrag.close(); } else { std::cout << "Cannot open shader file: " << pathFragment << std::endl; return false; } const char *vP = m_VertexSource.c_str(); const char *vF = m_FragmentSource.c_str(); glShaderSource(m_VertexShaderObj, 1, &vP, NULL); glCompileShader(m_VertexShaderObj); GLint Result; GLint InfoLogLength; glGetShaderiv(m_VertexShaderObj, GL_COMPILE_STATUS, &Result); glGetShaderiv(m_VertexShaderObj, GL_INFO_LOG_LENGTH, &InfoLogLength); std::vector<char> VertexShaderErrorMessage(InfoLogLength); glGetShaderInfoLog(m_VertexShaderObj, InfoLogLength, NULL, &VertexShaderErrorMessage[0]); printf("Shader (Vertex): %s\n", &VertexShaderErrorMessage[0]); glShaderSource(m_FragmentShaderObj, 1, &vF, NULL); glCompileShader(m_FragmentShaderObj); glGetShaderiv(m_FragmentShaderObj, GL_COMPILE_STATUS, &Result); glGetShaderiv(m_FragmentShaderObj, GL_INFO_LOG_LENGTH, &InfoLogLength); VertexShaderErrorMessage = std::vector<char>(InfoLogLength); glGetShaderInfoLog(m_FragmentShaderObj, InfoLogLength, NULL, &VertexShaderErrorMessage[0]); printf("Shader (Fragment): %s\n", &VertexShaderErrorMessage[0]); glAttachShader(m_Program, m_VertexShaderObj); glAttachShader(m_Program, m_FragmentShaderObj); glLinkProgram(m_Program); glDeleteShader(m_VertexShaderObj); glDeleteShader(m_FragmentShaderObj); return true; }
GLuint InitShader(const char* vShader, const char* fShader) { Shader shaders[2]; shaders[0].filename = vShader; shaders[0].type = GL_VERTEX_SHADER; shaders[1].filename = fShader; shaders[1].type = GL_FRAGMENT_SHADER; // create the program in the GPU GLuint program = glCreateProgram(); for ( int i = 0; i < 2; ++i ) { Shader& s = shaders[i]; // read file contents onto ONE LINE, doesn't seem to work // if file passed to glShaderSource in multiple lines bool read = readShaderSource( s.filename, s.source ); if ( !read ) { std::cerr << "Failed to read " << s.filename << std::endl; exit( EXIT_FAILURE ); } // First build the shader GLuint shader = glCreateShader( s.type ); // Second load the source const GLchar* sourceCode = s.source.c_str(); glShaderSource( shader, 1, const_cast<const GLchar**>(&sourceCode), NULL ); // Third compile the shader glCompileShader( shader ); // Make sure it compiled, other display error message GLint compiled; glGetShaderiv( shader, GL_COMPILE_STATUS, &compiled ); if ( !compiled ) { std::cerr << s.filename << " failed to compile:" << std::endl; GLint logSize; glGetShaderiv( shader, GL_INFO_LOG_LENGTH, &logSize ); char* logMsg = new char[logSize]; glGetShaderInfoLog( shader, logSize, NULL, logMsg ); std::cerr << logMsg << std::endl; delete [] logMsg; exit( EXIT_FAILURE ); } glAttachShader( program, shader ); } // link and error check glLinkProgram(program); GLint linked; glGetProgramiv( program, GL_LINK_STATUS, &linked ); if ( !linked ) { std::cerr << "Shader program failed to link" << std::endl; GLint logSize; glGetProgramiv( program, GL_INFO_LOG_LENGTH, &logSize); char* logMsg = new char[logSize]; glGetProgramInfoLog( program, logSize, NULL, logMsg ); std::cerr << logMsg << std::endl; delete [] logMsg; exit( EXIT_FAILURE ); } // use program object glUseProgram(program); return program; }
void processFn(struct fnargs* args) { switch (args->fn) { case glfnUNDEFINED: abort(); // bad glfn break; case glfnActiveTexture: glActiveTexture((GLenum)args->a0); break; case glfnAttachShader: glAttachShader((GLint)args->a0, (GLint)args->a1); break; case glfnBindAttribLocation: glBindAttribLocation((GLint)args->a0, (GLint)args->a1, (GLchar*)args->a2); free((void*)args->a2); break; case glfnBindBuffer: glBindBuffer((GLenum)args->a0, (GLuint)args->a1); break; case glfnBindFramebuffer: glBindFramebuffer((GLenum)args->a0, (GLint)args->a1); break; case glfnBindRenderbuffer: glBindRenderbuffer((GLenum)args->a0, (GLint)args->a1); break; case glfnBindTexture: glBindTexture((GLenum)args->a0, (GLint)args->a1); break; case glfnBlendColor: glBlendColor(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3); break; case glfnBlendEquation: glBlendEquation((GLenum)args->a0); break; case glfnBlendEquationSeparate: glBlendEquationSeparate((GLenum)args->a0, (GLenum)args->a1); break; case glfnBlendFunc: glBlendFunc((GLenum)args->a0, (GLenum)args->a1); break; case glfnBlendFuncSeparate: glBlendFuncSeparate((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLenum)args->a3); break; case glfnBufferData: glBufferData((GLenum)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2, (GLenum)args->a3); break; case glfnBufferSubData: glBufferSubData((GLenum)args->a0, (GLint)args->a1, (GLsizeiptr)args->a2, (GLvoid*)args->a3); break; case glfnCheckFramebufferStatus: ret = glCheckFramebufferStatus((GLenum)args->a0); break; case glfnClear: glClear((GLenum)args->a0); break; case glfnClearColor: glClearColor(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3); break; case glfnClearDepthf: glClearDepthf(*(GLfloat*)&args->a0); break; case glfnClearStencil: glClearStencil((GLint)args->a0); break; case glfnColorMask: glColorMask((GLboolean)args->a0, (GLboolean)args->a1, (GLboolean)args->a2, (GLboolean)args->a3); break; case glfnCompileShader: glCompileShader((GLint)args->a0); break; case glfnCompressedTexImage2D: glCompressedTexImage2D((GLenum)args->a0, (GLint)args->a1, (GLenum)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLsizeiptr)args->a6, (GLvoid*)args->a7); break; case glfnCompressedTexSubImage2D: glCompressedTexSubImage2D((GLenum)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLenum)args->a6, (GLsizeiptr)args->a7, (GLvoid*)args->a8); break; case glfnCopyTexImage2D: glCopyTexImage2D((GLenum)args->a0, (GLint)args->a1, (GLenum)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLint)args->a6, (GLint)args->a7); break; case glfnCopyTexSubImage2D: glCopyTexSubImage2D((GLenum)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLint)args->a6, (GLint)args->a7); break; case glfnCreateProgram: ret = glCreateProgram(); break; case glfnCreateShader: ret = glCreateShader((GLenum)args->a0); break; case glfnCullFace: glCullFace((GLenum)args->a0); break; case glfnDeleteBuffer: glDeleteBuffers(1, (const GLuint*)(&args->a0)); break; case glfnDeleteFramebuffer: glDeleteFramebuffers(1, (const GLuint*)(&args->a0)); break; case glfnDeleteProgram: glDeleteProgram((GLint)args->a0); break; case glfnDeleteRenderbuffer: glDeleteRenderbuffers(1, (const GLuint*)(&args->a0)); break; case glfnDeleteShader: glDeleteShader((GLint)args->a0); break; case glfnDeleteTexture: glDeleteTextures(1, (const GLuint*)(&args->a0)); break; case glfnDepthFunc: glDepthFunc((GLenum)args->a0); break; case glfnDepthMask: glDepthMask((GLboolean)args->a0); break; case glfnDepthRangef: glDepthRangef(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1); break; case glfnDetachShader: glDetachShader((GLint)args->a0, (GLint)args->a1); break; case glfnDisable: glDisable((GLenum)args->a0); break; case glfnDisableVertexAttribArray: glDisableVertexAttribArray((GLint)args->a0); break; case glfnDrawArrays: glDrawArrays((GLenum)args->a0, (GLint)args->a1, (GLint)args->a2); break; case glfnDrawElements: glDrawElements((GLenum)args->a0, (GLint)args->a1, (GLenum)args->a2, (void*)args->a3); break; case glfnEnable: glEnable((GLenum)args->a0); break; case glfnEnableVertexAttribArray: glEnableVertexAttribArray((GLint)args->a0); break; case glfnFinish: glFinish(); break; case glfnFlush: glFlush(); break; case glfnFramebufferRenderbuffer: glFramebufferRenderbuffer((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLint)args->a3); break; case glfnFramebufferTexture2D: glFramebufferTexture2D((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLint)args->a3, (GLint)args->a4); break; case glfnFrontFace: glFrontFace((GLenum)args->a0); break; case glfnGenBuffer: glGenBuffers(1, (GLuint*)&ret); break; case glfnGenFramebuffer: glGenFramebuffers(1, (GLuint*)&ret); break; case glfnGenRenderbuffer: glGenRenderbuffers(1, (GLuint*)&ret); break; case glfnGenTexture: glGenTextures(1, (GLuint*)&ret); break; case glfnGenerateMipmap: glGenerateMipmap((GLenum)args->a0); break; case glfnGetActiveAttrib: glGetActiveAttrib( (GLuint)args->a0, (GLuint)args->a1, (GLsizei)args->a2, NULL, (GLint*)args->a4, (GLenum*)args->a5, (GLchar*)args->a6); break; case glfnGetActiveUniform: glGetActiveUniform( (GLuint)args->a0, (GLuint)args->a1, (GLsizei)args->a2, NULL, (GLint*)args->a4, (GLenum*)args->a5, (GLchar*)args->a6); break; case glfnGetAttachedShaders: glGetAttachedShaders((GLuint)args->a0, (GLsizei)args->a1, (GLsizei*)args->a2, (GLuint*)args->a3); break; case glfnGetAttribLocation: ret = glGetAttribLocation((GLint)args->a0, (GLchar*)args->a1); free((void*)args->a1); break; case glfnGetBooleanv: glGetBooleanv((GLenum)args->a0, (GLboolean*)args->a1); break; case glfnGetBufferParameteri: glGetBufferParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)&ret); break; case glfnGetFloatv: glGetFloatv((GLenum)args->a0, (GLfloat*)args->a1); break; case glfnGetIntegerv: glGetIntegerv((GLenum)args->a0, (GLint*)args->a1); break; case glfnGetError: ret = glGetError(); break; case glfnGetFramebufferAttachmentParameteriv: glGetFramebufferAttachmentParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLint*)&ret); break; case glfnGetProgramiv: glGetProgramiv((GLint)args->a0, (GLenum)args->a1, (GLint*)&ret); break; case glfnGetProgramInfoLog: glGetProgramInfoLog((GLuint)args->a0, (GLsizei)args->a1, (GLsizei*)args->a2, (GLchar*)args->a3); break; case glfnGetRenderbufferParameteriv: glGetRenderbufferParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)&ret); break; case glfnGetShaderiv: glGetShaderiv((GLint)args->a0, (GLenum)args->a1, (GLint*)&ret); break; case glfnGetShaderInfoLog: glGetShaderInfoLog((GLuint)args->a0, (GLsizei)args->a1, (GLsizei*)args->a2, (GLchar*)args->a3); break; case glfnGetShaderPrecisionFormat: glGetShaderPrecisionFormat((GLenum)args->a0, (GLenum)args->a1, (GLint*)args->a2, (GLint*)args->a3); break; case glfnGetShaderSource: glGetShaderSource((GLuint)args->a0, (GLsizei)args->a1, (GLsizei*)args->a2, (GLchar*)args->a3); break; case glfnGetString: ret = (uintptr_t)glGetString((GLenum)args->a0); break; case glfnGetTexParameterfv: glGetTexParameterfv((GLenum)args->a0, (GLenum)args->a1, (GLfloat*)args->a2); break; case glfnGetTexParameteriv: glGetTexParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)args->a2); break; case glfnGetUniformfv: glGetUniformfv((GLuint)args->a0, (GLint)args->a1, (GLfloat*)args->a2); break; case glfnGetUniformiv: glGetUniformiv((GLuint)args->a0, (GLint)args->a1, (GLint*)args->a2); break; case glfnGetUniformLocation: ret = glGetUniformLocation((GLint)args->a0, (GLchar*)args->a1); free((void*)args->a1); break; case glfnGetVertexAttribfv: glGetVertexAttribfv((GLuint)args->a0, (GLenum)args->a1, (GLfloat*)args->a2); break; case glfnGetVertexAttribiv: glGetVertexAttribiv((GLuint)args->a0, (GLenum)args->a1, (GLint*)args->a2); break; case glfnHint: glHint((GLenum)args->a0, (GLenum)args->a1); break; case glfnIsBuffer: ret = glIsBuffer((GLint)args->a0); break; case glfnIsEnabled: ret = glIsEnabled((GLenum)args->a0); break; case glfnIsFramebuffer: ret = glIsFramebuffer((GLint)args->a0); break; case glfnIsProgram: ret = glIsProgram((GLint)args->a0); break; case glfnIsRenderbuffer: ret = glIsRenderbuffer((GLint)args->a0); break; case glfnIsShader: ret = glIsShader((GLint)args->a0); break; case glfnIsTexture: ret = glIsTexture((GLint)args->a0); break; case glfnLineWidth: glLineWidth(*(GLfloat*)&args->a0); break; case glfnLinkProgram: glLinkProgram((GLint)args->a0); break; case glfnPixelStorei: glPixelStorei((GLenum)args->a0, (GLint)args->a1); break; case glfnPolygonOffset: glPolygonOffset(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1); break; case glfnReadPixels: glReadPixels((GLint)args->a0, (GLint)args->a1, (GLsizei)args->a2, (GLsizei)args->a3, (GLenum)args->a4, (GLenum)args->a5, (void*)args->a6); break; case glfnReleaseShaderCompiler: glReleaseShaderCompiler(); break; case glfnRenderbufferStorage: glRenderbufferStorage((GLenum)args->a0, (GLenum)args->a1, (GLint)args->a2, (GLint)args->a3); break; case glfnSampleCoverage: glSampleCoverage(*(GLfloat*)&args->a0, (GLboolean)args->a1); break; case glfnScissor: glScissor((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3); break; case glfnShaderSource: #if defined(os_ios) || defined(os_osx) glShaderSource((GLuint)args->a0, (GLsizei)args->a1, (const GLchar *const *)args->a2, NULL); #else glShaderSource((GLuint)args->a0, (GLsizei)args->a1, (const GLchar **)args->a2, NULL); #endif free(*(void**)args->a2); free((void*)args->a2); break; case glfnStencilFunc: glStencilFunc((GLenum)args->a0, (GLint)args->a1, (GLuint)args->a2); break; case glfnStencilFuncSeparate: glStencilFuncSeparate((GLenum)args->a0, (GLenum)args->a1, (GLint)args->a2, (GLuint)args->a3); break; case glfnStencilMask: glStencilMask((GLuint)args->a0); break; case glfnStencilMaskSeparate: glStencilMaskSeparate((GLenum)args->a0, (GLuint)args->a1); break; case glfnStencilOp: glStencilOp((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2); break; case glfnStencilOpSeparate: glStencilOpSeparate((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLenum)args->a3); break; case glfnTexImage2D: glTexImage2D( (GLenum)args->a0, (GLint)args->a1, (GLint)args->a2, (GLsizei)args->a3, (GLsizei)args->a4, 0, // border (GLenum)args->a5, (GLenum)args->a6, (const GLvoid*)args->a7); break; case glfnTexSubImage2D: glTexSubImage2D( (GLenum)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLsizei)args->a4, (GLsizei)args->a5, (GLenum)args->a6, (GLenum)args->a7, (const GLvoid*)args->a8); break; case glfnTexParameterf: glTexParameterf((GLenum)args->a0, (GLenum)args->a1, *(GLfloat*)&args->a2); break; case glfnTexParameterfv: glTexParameterfv((GLenum)args->a0, (GLenum)args->a1, (GLfloat*)args->a2); break; case glfnTexParameteri: glTexParameteri((GLenum)args->a0, (GLenum)args->a1, (GLint)args->a2); break; case glfnTexParameteriv: glTexParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)args->a2); break; case glfnUniform1f: glUniform1f((GLint)args->a0, *(GLfloat*)&args->a1); break; case glfnUniform1fv: glUniform1fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2); break; case glfnUniform1i: glUniform1i((GLint)args->a0, (GLint)args->a1); break; case glfnUniform1iv: glUniform1iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2); break; case glfnUniform2f: glUniform2f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2); break; case glfnUniform2fv: glUniform2fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2); break; case glfnUniform2i: glUniform2i((GLint)args->a0, (GLint)args->a1, (GLint)args->a2); break; case glfnUniform2iv: glUniform2iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2); break; case glfnUniform3f: glUniform3f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3); break; case glfnUniform3fv: glUniform3fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2); break; case glfnUniform3i: glUniform3i((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3); break; case glfnUniform3iv: glUniform3iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2); break; case glfnUniform4f: glUniform4f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3, *(GLfloat*)&args->a4); break; case glfnUniform4fv: glUniform4fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2); break; case glfnUniform4i: glUniform4i((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLint)args->a4); break; case glfnUniform4iv: glUniform4iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2); break; case glfnUniformMatrix2fv: glUniformMatrix2fv((GLint)args->a0, (GLsizeiptr)args->a1, 0, (GLvoid*)args->a2); break; case glfnUniformMatrix3fv: glUniformMatrix3fv((GLint)args->a0, (GLsizeiptr)args->a1, 0, (GLvoid*)args->a2); break; case glfnUniformMatrix4fv: glUniformMatrix4fv((GLint)args->a0, (GLsizeiptr)args->a1, 0, (GLvoid*)args->a2); break; case glfnUseProgram: glUseProgram((GLint)args->a0); break; case glfnValidateProgram: glValidateProgram((GLint)args->a0); break; case glfnVertexAttrib1f: glVertexAttrib1f((GLint)args->a0, *(GLfloat*)&args->a1); break; case glfnVertexAttrib1fv: glVertexAttrib1fv((GLint)args->a0, (GLfloat*)args->a1); break; case glfnVertexAttrib2f: glVertexAttrib2f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2); break; case glfnVertexAttrib2fv: glVertexAttrib2fv((GLint)args->a0, (GLfloat*)args->a1); break; case glfnVertexAttrib3f: glVertexAttrib3f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3); break; case glfnVertexAttrib3fv: glVertexAttrib3fv((GLint)args->a0, (GLfloat*)args->a1); break; case glfnVertexAttrib4f: glVertexAttrib4f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3, *(GLfloat*)&args->a4); break; case glfnVertexAttrib4fv: glVertexAttrib4fv((GLint)args->a0, (GLfloat*)args->a1); break; case glfnVertexAttribPointer: glVertexAttribPointer((GLuint)args->a0, (GLint)args->a1, (GLenum)args->a2, (GLboolean)args->a3, (GLsizei)args->a4, (const GLvoid*)args->a5); break; case glfnViewport: glViewport((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3); break; } }
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglGetShaderiv(JNIEnv *env, jclass clazz, jint shader, jint pname, jlong params, jlong function_pointer) { GLint *params_address = (GLint *)(intptr_t)params; glGetShaderivPROC glGetShaderiv = (glGetShaderivPROC)((intptr_t)function_pointer); glGetShaderiv(shader, pname, params_address); }
void QSGSharedDistanceFieldGlyphCache::saveTexture(GLuint textureId, int width, int height) { GLuint fboId; glGenFramebuffers(1, &fboId); GLuint tmpTexture = 0; glGenTextures(1, &tmpTexture); glBindTexture(GL_TEXTURE_2D, tmpTexture); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glBindTexture(GL_TEXTURE_2D, 0); glBindFramebuffer(GL_FRAMEBUFFER_EXT, fboId); glFramebufferTexture2D(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, tmpTexture, 0); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, textureId); glDisable(GL_STENCIL_TEST); glDisable(GL_DEPTH_TEST); glDisable(GL_SCISSOR_TEST); glDisable(GL_BLEND); GLfloat textureCoordinateArray[8]; textureCoordinateArray[0] = 0.0f; textureCoordinateArray[1] = 0.0f; textureCoordinateArray[2] = 1.0f; textureCoordinateArray[3] = 0.0f; textureCoordinateArray[4] = 1.0f; textureCoordinateArray[5] = 1.0f; textureCoordinateArray[6] = 0.0f; textureCoordinateArray[7] = 1.0f; GLfloat vertexCoordinateArray[8]; vertexCoordinateArray[0] = -1.0f; vertexCoordinateArray[1] = -1.0f; vertexCoordinateArray[2] = 1.0f; vertexCoordinateArray[3] = -1.0f; vertexCoordinateArray[4] = 1.0f; vertexCoordinateArray[5] = 1.0f; vertexCoordinateArray[6] = -1.0f; vertexCoordinateArray[7] = 1.0f; glViewport(0, 0, width, height); glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, vertexCoordinateArray); glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, textureCoordinateArray); { static const char vertexShaderSource[] = "attribute highp vec4 vertexCoordsArray; \n" "attribute highp vec2 textureCoordArray; \n" "varying highp vec2 textureCoords; \n" "void main(void) \n" "{ \n" " gl_Position = vertexCoordsArray; \n" " textureCoords = textureCoordArray; \n" "} \n"; static const char fragmentShaderSource[] = "varying highp vec2 textureCoords; \n" "uniform sampler2D texture; \n" "void main() \n" "{ \n" " gl_FragColor = texture2D(texture, textureCoords); \n" "} \n"; GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER); GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); if (vertexShader == 0 || fragmentShader == 0) { GLenum error = glGetError(); qWarning("SharedGraphicsCacheServer::setupShaderPrograms: Failed to create shaders. (GL error: %x)", error); return; } glShaderSource(vertexShader, 1, &vertexShaderSource, NULL); glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL); glCompileShader(vertexShader); GLint len = 1; glGetShaderiv(vertexShader, GL_INFO_LOG_LENGTH, &len); char infoLog[2048]; glGetShaderInfoLog(vertexShader, 2048, NULL, infoLog); if (qstrlen(infoLog) > 0) { qWarning("SharedGraphicsCacheServer::setupShaderPrograms, problems compiling vertex shader:\n %s", infoLog); //return; } glCompileShader(fragmentShader); glGetShaderInfoLog(fragmentShader, 2048, NULL, infoLog); if (qstrlen(infoLog) > 0) { qWarning("SharedGraphicsCacheServer::setupShaderPrograms, problems compiling fragent shader:\n %s", infoLog); //return; } GLuint shaderProgram = glCreateProgram(); glAttachShader(shaderProgram, vertexShader); glAttachShader(shaderProgram, fragmentShader); glBindAttribLocation(shaderProgram, 0, "vertexCoordsArray"); glBindAttribLocation(shaderProgram, 1, "textureCoordArray"); glLinkProgram(shaderProgram); glGetProgramInfoLog(shaderProgram, 2048, NULL, infoLog); if (qstrlen(infoLog) > 0) { qWarning("SharedGraphicsCacheServer::setupShaderPrograms, problems linking shaders:\n %s", infoLog); //return; } glUseProgram(shaderProgram); glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); int textureUniformLocation = glGetUniformLocation(shaderProgram, "_qt_texture"); glUniform1i(textureUniformLocation, 0); } glDrawArrays(GL_TRIANGLE_FAN, 0, 4); { GLenum error = glGetError(); if (error != GL_NO_ERROR) { qWarning("SharedGraphicsCacheServer::readBackBuffer: glDrawArrays reported error 0x%x", error); } } uchar *data = new uchar[width * height * 4]; glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data); QImage image(width, height, QImage::Format_ARGB32); quint32 *dest = reinterpret_cast<quint32 *>(image.bits()); for (int i=0; i<width*height; ++i) dest[i] = qRgba(0xff, 0xff, 0xff, data[i]); QByteArray fileName = m_cacheId + ' ' + QByteArray::number(textureId); fileName = fileName.replace('/', '_').replace(' ', '_') + ".png"; image.save(QString::fromLocal8Bit(fileName)); { GLenum error = glGetError(); if (error != GL_NO_ERROR) { qWarning("SharedGraphicsCacheServer::readBackBuffer: glReadPixels reported error 0x%x", error); } } glDisableVertexAttribArray(0); glDisableVertexAttribArray(1); glDeleteFramebuffers(1, &fboId); glDeleteTextures(1, &tmpTexture); delete[] data; }
GPUShader *GPU_shader_create_ex(const char *vertexcode, const char *fragcode, const char *geocode, const char *libcode, const char *defines, int input, int output, int number, const int flags) { #ifdef WITH_OPENSUBDIV /* TODO(sergey): used to add #version 150 to the geometry shader. * Could safely be renamed to "use_geometry_code" since it's very * likely any of geometry code will want to use GLSL 1.5. */ bool use_opensubdiv = (flags & GPU_SHADER_FLAGS_SPECIAL_OPENSUBDIV) != 0; #else UNUSED_VARS(flags); bool use_opensubdiv = false; #endif GLint status; GLchar log[5000]; GLsizei length = 0; GPUShader *shader; char standard_defines[MAX_DEFINE_LENGTH] = ""; char standard_extensions[MAX_EXT_DEFINE_LENGTH] = ""; if (geocode && !GPU_geometry_shader_support()) return NULL; shader = MEM_callocN(sizeof(GPUShader), "GPUShader"); if (vertexcode) shader->vertex = glCreateShader(GL_VERTEX_SHADER); if (fragcode) shader->fragment = glCreateShader(GL_FRAGMENT_SHADER); if (geocode) shader->geometry = glCreateShader(GL_GEOMETRY_SHADER_EXT); shader->program = glCreateProgram(); if (!shader->program || (vertexcode && !shader->vertex) || (fragcode && !shader->fragment) || (geocode && !shader->geometry)) { fprintf(stderr, "GPUShader, object creation failed.\n"); GPU_shader_free(shader); return NULL; } gpu_shader_standard_defines(standard_defines, use_opensubdiv, (flags & GPU_SHADER_FLAGS_NEW_SHADING) != 0); gpu_shader_standard_extensions(standard_extensions, geocode != NULL); if (vertexcode) { const char *source[5]; /* custom limit, may be too small, beware */ int num_source = 0; source[num_source++] = gpu_shader_version(); source[num_source++] = standard_extensions; source[num_source++] = standard_defines; if (defines) source[num_source++] = defines; source[num_source++] = vertexcode; glAttachShader(shader->program, shader->vertex); glShaderSource(shader->vertex, num_source, source, NULL); glCompileShader(shader->vertex); glGetShaderiv(shader->vertex, GL_COMPILE_STATUS, &status); if (!status) { glGetShaderInfoLog(shader->vertex, sizeof(log), &length, log); shader_print_errors("compile", log, source, num_source); GPU_shader_free(shader); return NULL; } } if (fragcode) { const char *source[7]; int num_source = 0; source[num_source++] = gpu_shader_version(); source[num_source++] = standard_extensions; source[num_source++] = standard_defines; #ifdef WITH_OPENSUBDIV /* TODO(sergey): Move to fragment shader source code generation. */ if (use_opensubdiv) { source[num_source++] = "#ifdef USE_OPENSUBDIV\n" "in block {\n" " VertexData v;\n" "} inpt;\n" "#endif\n"; } #endif if (defines) source[num_source++] = defines; if (libcode) source[num_source++] = libcode; source[num_source++] = fragcode; glAttachShader(shader->program, shader->fragment); glShaderSource(shader->fragment, num_source, source, NULL); glCompileShader(shader->fragment); glGetShaderiv(shader->fragment, GL_COMPILE_STATUS, &status); if (!status) { glGetShaderInfoLog(shader->fragment, sizeof(log), &length, log); shader_print_errors("compile", log, source, num_source); GPU_shader_free(shader); return NULL; } } if (geocode) { const char *source[6]; int num_source = 0; source[num_source++] = gpu_shader_version(); source[num_source++] = standard_extensions; source[num_source++] = standard_defines; if (defines) source[num_source++] = defines; source[num_source++] = geocode; glAttachShader(shader->program, shader->geometry); glShaderSource(shader->geometry, num_source, source, NULL); glCompileShader(shader->geometry); glGetShaderiv(shader->geometry, GL_COMPILE_STATUS, &status); if (!status) { glGetShaderInfoLog(shader->geometry, sizeof(log), &length, log); shader_print_errors("compile", log, source, num_source); GPU_shader_free(shader); return NULL; } if (!use_opensubdiv) { GPU_shader_geometry_stage_primitive_io(shader, input, output, number); } } #ifdef WITH_OPENSUBDIV if (use_opensubdiv) { glBindAttribLocation(shader->program, 0, "position"); glBindAttribLocation(shader->program, 1, "normal"); GPU_shader_geometry_stage_primitive_io(shader, GL_LINES_ADJACENCY_EXT, GL_TRIANGLE_STRIP, 4); } #endif glLinkProgram(shader->program); glGetProgramiv(shader->program, GL_LINK_STATUS, &status); if (!status) { glGetProgramInfoLog(shader->program, sizeof(log), &length, log); /* print attached shaders in pipeline order */ if (vertexcode) shader_print_errors("linking", log, &vertexcode, 1); if (geocode) shader_print_errors("linking", log, &geocode, 1); if (libcode) shader_print_errors("linking", log, &libcode, 1); if (fragcode) shader_print_errors("linking", log, &fragcode, 1); GPU_shader_free(shader); return NULL; } #ifdef WITH_OPENSUBDIV /* TODO(sergey): Find a better place for this. */ if (use_opensubdiv && GLEW_VERSION_4_1) { glProgramUniform1i(shader->program, glGetUniformLocation(shader->program, "FVarDataOffsetBuffer"), 30); /* GL_TEXTURE30 */ glProgramUniform1i(shader->program, glGetUniformLocation(shader->program, "FVarDataBuffer"), 31); /* GL_TEXTURE31 */ } #endif return shader; }
int main(void) { GLFWwindow* window; /* Initialize the library */ if (!glfwInit()) return -1; /* Create a windowed mode window and its OpenGL context */ window = glfwCreateWindow(800, 450, "Mah Base Project", NULL, NULL); if (!window) { glfwTerminate(); return -1; } /* Make the window's context current */ glfwMakeContextCurrent(window); glewExperimental = GL_TRUE; glewInit(); // Create Vertex Array Object GLuint vao; glGenVertexArrays(1, &vao); glBindVertexArray(vao); // Create a Vertex Buffer Object and copy the vertex data to it GLuint vbo; glGenBuffers(1, &vbo); GLfloat vertices[] = { 0.0f, 0.5f, 0.5f, -0.5f, -0.5f, -0.5f }; glBindBuffer(GL_ARRAY_BUFFER, vbo); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); const char* vertexSource = loadSource("VertexSource.glsl"); const char* fragmentSource = loadSource("FragmentSource.glsl"); GLint status = GL_TRUE; GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vertexShader, 1, &vertexSource, NULL); glCompileShader(vertexShader); glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &status); // cout<< "Vertex" << status << endl; // Create and compile the fragment shader GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fragmentShader, 1, &fragmentSource, NULL); glCompileShader(fragmentShader); glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &status); // cout<< "Fragment" << status << endl; // Link the vertex and fragment shader into a shader program GLuint shaderProgram = glCreateProgram(); glAttachShader(shaderProgram, vertexShader); glAttachShader(shaderProgram, fragmentShader); glBindFragDataLocation(shaderProgram, 0, "outColor"); glLinkProgram(shaderProgram); glUseProgram(shaderProgram); // Specify the layout of the vertex data GLint posAttrib = glGetAttribLocation(shaderProgram, "position"); glEnableVertexAttribArray(posAttrib); glVertexAttribPointer(posAttrib, 2, GL_FLOAT, GL_FALSE, 0, 0); /* Loop until the user closes the window */ while (!glfwWindowShouldClose(window)) { /* Render here */ // Clear the screen to black glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT); // Draw a triangle from the 3 vertices glDrawArrays(GL_TRIANGLES, 0, 3); // Swap buffers /* Swap front and back buffers */ glfwSwapBuffers(window); /* Poll for and process events */ glfwPollEvents(); } glfwTerminate(); return 0; }
int main(int argc, char *argv[]) { SDL_Surface *screen; if ( SDL_Init(SDL_INIT_VIDEO) != 0 ) { printf("Unable to initialize SDL: %s\n", SDL_GetError()); return 1; } SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); screen = SDL_SetVideoMode( 640, 480, 24, SDL_OPENGL ); if ( !screen ) { printf("Unable to set video mode: %s\n", SDL_GetError()); return 1; } glClearColor( 0, 0, 0, 0 ); glClear( GL_COLOR_BUFFER_BIT ); glGenVertexArrays_ = (PFNGLGENVERTEXARRAYSPROC) SDL_GL_GetProcAddress("glGenVertexArrays"); assert(glGenVertexArrays_); glBindVertexArray_ = (PFNGLBINDVERTEXARRAYPROC) SDL_GL_GetProcAddress("glBindVertexArray"); assert(glBindVertexArray_); glDeleteVertexArrays_ = (PFNGLDELETEVERTEXARRAYSPROC) SDL_GL_GetProcAddress("glDeleteVertexArrays"); assert(glDeleteVertexArrays_); glEnableClientState(GL_TEXTURE_COORD_ARRAY); // enabling it *before* the vao does nothing, the vao should wipe it out! // Generate a VAO GLuint vao; glGenVertexArrays_(1, &vao); glBindVertexArray_(vao); // Create a texture GLuint texture; glGenTextures( 1, &texture ); glBindTexture( GL_TEXTURE_2D, texture ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); GLubyte textureData[16*16*4]; for (int x = 0; x < 16; x++) { for (int y = 0; y < 16; y++) { *((int*)&textureData[(x*16 + y) * 4]) = x*16 + ((y*16) << 8); } } glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, textureData ); // Create a second texture GLuint texture2; glGenTextures( 1, &texture2 ); glBindTexture( GL_TEXTURE_2D, texture2 ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); GLubyte texture2Data[] = { 0xff, 0, 0, 0xff, 0, 0xff, 0, 0xaa, 0, 0, 0xff, 0x55, 0x80, 0x90, 0x70, 0 }; glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, texture2Data ); // BEGIN #if USE_GLEW glewInit(); #endif glMatrixMode(GL_PROJECTION); glLoadIdentity(); // original: glFrustum(-0.6435469817188064, 0.6435469817188064 ,-0.48266022190470925, 0.48266022190470925 ,0.5400000214576721, 2048); //glFrustum(-0.6435469817188064, 0.1435469817188064 ,-0.48266022190470925, 0.88266022190470925 ,0.5400000214576721, 2048); GLfloat pm[] = { 1.372136116027832, 0, 0, 0, 0, 0.7910231351852417, 0, 0, -0.6352481842041016, 0.29297152161598206, -1.0005275011062622, -1, 0, 0, -1.080284833908081, 0 }; glLoadMatrixf(pm); glMatrixMode(GL_MODELVIEW); GLfloat matrixData[] = { -1, 0, 0, 0, 0, 0,-1, 0, 0, 1, 0, 0, 0, 0, 0, 1 }; glLoadMatrixf(matrixData); //glTranslated(-512,-512,-527); // XXX this should be uncommented, but if it is then nothing is shown // glEnable(GL_CULL_FACE); // glEnable(GL_DEPTH_TEST); //glClear(GL_DEPTH_BUFFER_BIT); // glEnableClientState(GL_NORMAL_ARRAY); // glEnableClientState(GL_COLOR_ARRAY); glActiveTexture(GL_TEXTURE0); glEnableClientState(GL_VERTEX_ARRAY); GLuint arrayBuffer, elementBuffer; glGenBuffers(1, &arrayBuffer); glGenBuffers(1, &elementBuffer); GLubyte arrayData[] = { /* [0, 0, 0, 67] ==> 128 float [0, 0, 128, 67] ==> 256 float [0, 0, 0, 68] ==> 512 float [0, 0, 128, 68] ==> 1024 float [vertex x ] [vertex y ] [vertex z ] [nr] [texture u ] [texture v ] [lm u ] [lm v ] [color r,g,b,a ] */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, // 0 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, // 1 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 2 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 3 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, // 4 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 128, 67, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, // 5 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 128, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 6 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 7 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 8 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 9 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 128, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 10 0, 0, 0, 0, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 11 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 12 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 128, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 13 0, 0, 128, 68, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 128, 67, 0, 0, 128, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 14 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 128, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 15 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 128, 68, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128 }; assert(sizeof(arrayData) == 1408); glBindBuffer(GL_ARRAY_BUFFER, arrayBuffer); glBufferData(GL_ARRAY_BUFFER, sizeof(arrayData), arrayData, GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, 0); GLushort elementData[] = { 1, 2, 0, 2, 3, 0, 5, 6, 4, 6, 7, 4, 9, 10, 8, 10, 11, 8, 13, 14, 12, 14, 15, 12 }; assert(sizeof(elementData) == 48); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementBuffer); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(elementData), elementData, GL_STATIC_DRAW); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, arrayBuffer); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementBuffer); // sauer vertex data is apparently 0-12: V3F, 12: N1B, 16-24: T2F, 24-28: T2S, 28-32: C4B glVertexPointer(3, GL_FLOAT, 32, (void*)0); // all these apply to the ARRAY_BUFFER that is bound glTexCoordPointer(2, GL_FLOAT, 32, (void*)16); // glClientActiveTexture(GL_TEXTURE1); // XXX seems to be ignored in native build // glTexCoordPointer(2, GL_SHORT, 32, (void*)24); // glClientActiveTexture(GL_TEXTURE0); // likely not needed, it is a cleanup // glNormalPointer(GL_BYTE, 32, (void*)12); // glColorPointer(4, GL_UNSIGNED_BYTE, 32, (void*)28); glBindTexture(GL_TEXTURE_2D, texture); // diffuse? glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, texture2); // lightmap? glActiveTexture(GL_TEXTURE0); GLint ok; const char *vertexShader = "uniform mat4 u_modelView;\n" "uniform mat4 u_projection;\n" "varying vec4 v_texCoord0;\n" "void main(void)\n" "{\n" // (gl_ProjectionMatrix * gl_ModelViewMatrix * gl_Vertex) // (u_projection * u_modelView * a_position) " gl_Position = (u_projection * u_modelView * gl_Vertex) + vec4(200, 0, 0, 0);\n" " v_texCoord0.xy = gl_MultiTexCoord0.xy/20.0;\n" // added /100 here "}\n"; const char *fragmentShader = "uniform sampler2D diffusemap;\n" "varying vec4 v_texCoord0;\n" "void main(void)\n" "{\n" " vec4 diffuse = texture2D(diffusemap, v_texCoord0.xy);\n" " gl_FragColor = diffuse;\n" "}\n"; GLuint vs = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vs, 1, &vertexShader, NULL); glCompileShader(vs); glGetShaderiv(vs, GL_COMPILE_STATUS, &ok); if (!ok) { printf("Shader compilation error with vertex\n"); GLint infoLen = 0; glGetShaderiv (vs, GL_INFO_LOG_LENGTH, &infoLen); if (infoLen > 1) { char* infoLog = (char *)malloc(sizeof(char) * infoLen+1); glGetShaderInfoLog(vs, infoLen, NULL, infoLog); printf("Error compiling shader:\n%s\n", infoLog); } } GLuint fs = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fs, 1, &fragmentShader, NULL); glCompileShader(fs); glGetShaderiv(fs, GL_COMPILE_STATUS, &ok); if (!ok) { printf("Shader compilation error with fragment\n"); GLint infoLen = 0; glGetShaderiv (vs, GL_INFO_LOG_LENGTH, &infoLen); if (infoLen > 1) { char* infoLog = (char *)malloc(sizeof(char) * infoLen+1); glGetShaderInfoLog(vs, infoLen, NULL, infoLog); printf("Error compiling shader:\n%s\n", infoLog); } } GLuint program = glCreateProgram(); glAttachShader(program, vs); glAttachShader(program, fs); glLinkProgram(program); glGetProgramiv(program, GL_LINK_STATUS, &ok); assert(ok); glUseProgram(program); //GLint lightmapLocation = glGetUniformLocation(program, "lightmap"); //assert(lightmapLocation >= 0); //glUniform1i(lightmapLocation, 1); // sampler2D? Is it the texture unit? GLint diffusemapLocation = glGetUniformLocation(program, "diffusemap"); assert(diffusemapLocation >= 0); glUniform1i(diffusemapLocation, 0); //GLint texgenscrollLocation = glGetUniformLocation(program, "texgenscroll"); //assert(texgenscrollLocation >= 0); //GLint colorparamsLocation = glGetUniformLocation(program, "colorparams"); //assert(colorparamsLocation >= 0); //GLfloat texgenscrollData[] = { 0, 0, 0, 0 }; //glUniform4fv(texgenscrollLocation, 1, texgenscrollData); //GLfloat colorparamsData[] = { 2, 2, 2, 1 }; //glUniform4fv(colorparamsLocation, 1, colorparamsData); { GLfloat data[16]; glGetFloatv(GL_MODELVIEW_MATRIX, data); printf("Modelview: "); for (int i = 0; i < 16; i++) printf("%.3f, ", data[i]); printf("\n"); //memset(data, 0, 16*4); GLint modelViewLocation = glGetUniformLocation(program, "u_modelView"); assert(modelViewLocation >= 0); glUniformMatrix4fv(modelViewLocation, 1, GL_FALSE, data); } { GLfloat data[16]; glGetFloatv(GL_PROJECTION_MATRIX, data); printf("Projection: "); for (int i = 0; i < 16; i++) printf("%.3f, ", data[i]); printf("\n"); //memset(data, 0, 16*4); GLint projectionLocation = glGetUniformLocation(program, "u_projection"); assert(projectionLocation >= 0); glUniformMatrix4fv(projectionLocation, 1, GL_FALSE, data); } /* glBindAttribLocation(program, 0, "a_position"); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 32, (void*)0); glEnableVertexAttribArray(0); glBindAttribLocation(program, 1, "v_texCoord0"); glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 32, (void*)16); glEnableVertexAttribArray(1); */ // stop recording in the VAO glBindVertexArray_(0); // unbind all the stuff the VAO would save for us, so this is a valid test glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_VERTEX_ARRAY); // draw with VAO glBindVertexArray_(vao); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*)12); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*) 0); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*)24); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*)36); // END SDL_GL_SwapBuffers(); #if !EMSCRIPTEN SDL_Delay(1500); #endif // SDL_Quit(); return 0; }
GLuint LoadShaders(ShaderInfo *shaders) { if (shaders == NULL) { return 0; } GLuint program = glCreateProgram(); ShaderInfo *entry = shaders; while (entry->type != GL_NONE) { GLuint shader = glCreateShader(entry->type); entry->shader = shader; const GLchar *source = ReadShader(entry->filename); if (source == NULL) { for (entry = shaders; entry->type != GL_NONE; ++entry) { glDeleteShader(entry->shader); entry->shader = 0; } return 0; } glShaderSource(shader, 1, &source, NULL); delete[] source; glCompileShader(shader); GLint compiled; glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled); if (!compiled) { #ifdef _DEBUG GLsizei len; glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &len); GLchar* log = new GLchar[len + 1]; glGetShaderInfoLog(shader, len, &len, log); std::cerr << "Shader compilation failed: " << log << std::endl; delete [] log; #endif /* DEBUG */ return 0; } glAttachShader(program, shader); ++entry; } #ifdef GL_VERSION_4_1 if (GLEW_VERSION_4_1) { // glProgramParameteri( program, GL_PROGRAM_SEPARABLE, GL_TRUE ); } #endif /* GL_VERSION_4_1 */ glLinkProgram(program); GLint linked; glGetProgramiv(program, GL_LINK_STATUS, &linked); if (!linked) { #ifdef _DEBUG GLsizei len; glGetProgramiv(program, GL_INFO_LOG_LENGTH, &len); GLchar* log = new GLchar[len + 1]; glGetProgramInfoLog(program, len, &len, log); std::cerr << "Shader linking failed: " << log << std::endl; delete [] log; #endif /* DEBUG */ for (entry = shaders; entry->type != GL_NONE; ++entry) { glDeleteShader(entry->shader); entry->shader = 0; } return 0; } return program; }
// Constructor generates the shader on the fly Shader(const GLchar* vertexPath, const GLchar* fragmentPath) { // 1. Retrieve the vertex/fragment source code from filePath std::string vertexCode; std::string fragmentCode; std::ifstream vShaderFile; std::ifstream fShaderFile; // ensures ifstream objects can throw exceptions: vShaderFile.exceptions (std::ifstream::failbit | std::ifstream::badbit); fShaderFile.exceptions (std::ifstream::failbit | std::ifstream::badbit); try { // Open files vShaderFile.open(vertexPath); fShaderFile.open(fragmentPath); // Read file's buffer contents into streams std::stringstream vShaderStream, fShaderStream; vShaderStream << vShaderFile.rdbuf(); fShaderStream << fShaderFile.rdbuf(); // close file handlers vShaderFile.close(); fShaderFile.close(); // Convert stream into string vertexCode = vShaderStream.str(); fragmentCode = fShaderStream.str(); } catch (std::ifstream::failure e) { std::cout << "ERROR::SHADER::FILE_NOT_SUCCESFULLY_READ" << std::endl; } const GLchar* vShaderCode = vertexCode.c_str(); const GLchar * fShaderCode = fragmentCode.c_str(); // 2. Compile shaders GLuint vertex, fragment; GLint success; GLchar infoLog[512]; // Vertex Shader vertex = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vertex, 1, &vShaderCode, NULL); glCompileShader(vertex); // Print compile errors if any glGetShaderiv(vertex, GL_COMPILE_STATUS, &success); if (!success) { glGetShaderInfoLog(vertex, 512, NULL, infoLog); std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl; } // Fragment Shader fragment = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fragment, 1, &fShaderCode, NULL); glCompileShader(fragment); // Print compile errors if any glGetShaderiv(fragment, GL_COMPILE_STATUS, &success); if (!success) { glGetShaderInfoLog(fragment, 512, NULL, infoLog); std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl; } // Shader Program this->Program = glCreateProgram(); glAttachShader(this->Program, vertex); glAttachShader(this->Program, fragment); glLinkProgram(this->Program); // Print linking errors if any glGetProgramiv(this->Program, GL_LINK_STATUS, &success); if (!success) { glGetProgramInfoLog(this->Program, 512, NULL, infoLog); std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl; } // Delete the shaders as they're linked into our program now and no longer necessery glDeleteShader(vertex); glDeleteShader(fragment); }
int Mesh::loadShaders(const char* vertexFile, const char* fragmentFile) { GLint result = GL_FALSE; int infoLogLength; GLuint vertexShaderID = glCreateShader(GL_VERTEX_SHADER); GLuint fragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER); std::ofstream outputLog("output.txt", std::ios::out); std::string vertexShaderCode; std::ifstream vertexShaderStream(vertexFile, std::ios::in); if(vertexShaderStream.is_open()) { char line[256]; while(vertexShaderStream.getline(line, 256)) { vertexShaderCode += std::string("\n"); vertexShaderCode += std::string(line); } vertexShaderStream.close(); } const char* vertexShaderSource = vertexShaderCode.c_str(); // Compile vertex shader glShaderSource(vertexShaderID, 1, &vertexShaderSource, NULL); glCompileShader(vertexShaderID); // Check vertex shader glGetShaderiv(vertexShaderID, GL_COMPILE_STATUS, &result); glGetShaderiv(vertexShaderID, GL_INFO_LOG_LENGTH, &infoLogLength); std::vector<char> vertexShaderErrorMessage(infoLogLength); glGetShaderInfoLog(vertexShaderID, infoLogLength, NULL, &vertexShaderErrorMessage[0]); if(outputLog.is_open()) { outputLog<<&vertexShaderErrorMessage[0]<<std::endl; } std::string fragmentShaderCode; std::ifstream fragmentShaderStream(fragmentFile, std::ios::in); if(fragmentShaderStream.is_open()) { char line[256]; while(fragmentShaderStream.getline(line, 256)) { fragmentShaderCode += std::string("\n"); fragmentShaderCode += std::string(line); } fragmentShaderStream.close(); } const char* fragmentShaderSource = fragmentShaderCode.c_str(); // Compile fragment shader glShaderSource(fragmentShaderID, 1, &fragmentShaderSource, NULL); glCompileShader(fragmentShaderID); // Check fragment shader glGetShaderiv(fragmentShaderID, GL_COMPILE_STATUS, &result); glGetShaderiv(fragmentShaderID, GL_INFO_LOG_LENGTH, &infoLogLength); std::vector<char> fragmentShaderErrorMessage(infoLogLength); glGetShaderInfoLog(fragmentShaderID, infoLogLength, NULL, &fragmentShaderErrorMessage[0]); if(outputLog.is_open()) { outputLog<<&fragmentShaderErrorMessage[0]<<std::endl; } // Create and link a program GLuint programID = glCreateProgram(); glAttachShader(programID, vertexShaderID); glAttachShader(programID, fragmentShaderID); glLinkProgram(programID); // Check the program glGetProgramiv(programID, GL_LINK_STATUS, &result); glGetProgramiv(programID, GL_INFO_LOG_LENGTH, &infoLogLength); std::vector<char> programErrorMessage(infoLogLength); glGetProgramInfoLog(programID, infoLogLength, NULL, &programErrorMessage[0]); if(outputLog.is_open()) { outputLog<<&programErrorMessage[0]<<std::endl; } outputLog.close(); glDeleteShader(vertexShaderID); glDeleteShader(fragmentShaderID); return programID; }
GLuint CompileShader(const DKString& implement, DKShader::Type t, DKString& err) { if (implement.Length() == 0) { err = L"No implementation."; return 0; } if (t != DKShader::TypeFragmentShader && t != DKShader::TypeGeometryShader && t != DKShader::TypeVertexShader) { err = L"Unknown shader type"; return 0; } DKStringU8 source(implement); if (source.Bytes() == 0) { err = L"Failed to convert source encoding (UTF-8)"; return 0; } GLuint hShader = 0; if (t == DKShader::TypeVertexShader) // vertex shader { hShader = glCreateShader(GL_VERTEX_SHADER); } else if (t == DKShader::TypeFragmentShader) // fragment shader (pixel shader) { hShader = glCreateShader(GL_FRAGMENT_SHADER); } else { #ifdef GL_GEOMETRY_SHADER hShader = glCreateShader(GL_GEOMETRY_SHADER); #else err = L"Geometry shader not supported in this implementation."; DKLog("Error: Geometry shader not supported in this implementation.\n"); return 0; #endif } if (hShader == 0) { err = L"Failed to create shader object"; return 0; } const char* src = (const char*)source; glShaderSource(hShader, 1, &src, NULL); glCompileShader(hShader); // retrieve compiler log int nLogLen = 0; glGetShaderiv(hShader, GL_INFO_LOG_LENGTH, &nLogLen); if (nLogLen > 1) { char *pLog = (char*)DKMemoryHeapAlloc(nLogLen); int nCharsWritten = 0; glGetShaderInfoLog(hShader, nLogLen, &nCharsWritten, pLog); err = pLog; DKMemoryHeapFree(pLog); } //////////////////////////////////////////////////////////////////////////////// // get compilation result. int result = 0; glGetShaderiv(hShader, GL_COMPILE_STATUS, &result); glFlush(); if (result) { return hShader; } // compile error. if (err.Length() == 0) err = L"Failed to compile shader."; glDeleteShader(hShader); return 0; }
bool CShader::Compile() { tstring sShaderHeader = CShaderLibrary::GetShaderHeader(); if (CShaderLibrary::Get()->m_iSamples) sShaderHeader += "#define USE_MULTISAMPLE_TEXTURES 1\n"; sShaderHeader += CShaderLibrary::GetShaderFunctions(); FILE* f = tfopen("shaders/" + m_sVertexFile + ".vs", "r"); TAssert(f); if (!f) return false; tstring sVertexShader = sShaderHeader; sVertexShader += "uniform mat4x4 mProjection;\n"; sVertexShader += "uniform mat4x4 mView;\n"; sVertexShader += "uniform mat4x4 mGlobal;\n"; tstring sLine; while (fgetts(sLine, f)) sVertexShader += sLine; fclose(f); f = tfopen("shaders/" + m_sFragmentFile + ".fs", "r"); TAssert(f); if (!f) return false; tstring sFragmentShader = sShaderHeader; sFragmentShader += "out vec4 vecOutputColor;\n"; while (fgetts(sLine, f)) sFragmentShader += sLine; fclose(f); size_t iVShader = glCreateShader(GL_VERTEX_SHADER); const char* pszStr = sVertexShader.c_str(); glShaderSource((GLuint)iVShader, 1, &pszStr, NULL); glCompileShader((GLuint)iVShader); int iVertexCompiled; glGetShaderiv((GLuint)iVShader, GL_COMPILE_STATUS, &iVertexCompiled); if (iVertexCompiled != GL_TRUE || Application()->HasCommandLineSwitch("--debug-gl")) { int iLogLength = 0; char szLog[1024]; glGetShaderInfoLog((GLuint)iVShader, 1024, &iLogLength, szLog); CShaderLibrary::Get()->WriteLog(m_sVertexFile + ".vs", szLog, pszStr); } size_t iFShader = glCreateShader(GL_FRAGMENT_SHADER); pszStr = sFragmentShader.c_str(); glShaderSource((GLuint)iFShader, 1, &pszStr, NULL); glCompileShader((GLuint)iFShader); int iFragmentCompiled; glGetShaderiv((GLuint)iFShader, GL_COMPILE_STATUS, &iFragmentCompiled); if (iFragmentCompiled != GL_TRUE || Application()->HasCommandLineSwitch("--debug-gl")) { int iLogLength = 0; char szLog[1024]; glGetShaderInfoLog((GLuint)iFShader, 1024, &iLogLength, szLog); CShaderLibrary::Get()->WriteLog(m_sFragmentFile + ".fs", szLog, pszStr); } size_t iProgram = glCreateProgram(); glBindAttribLocation(iProgram, 0, "vecPosition"); // Force position at location 0. ATI cards won't work without this. glAttachShader((GLuint)iProgram, (GLuint)iVShader); glAttachShader((GLuint)iProgram, (GLuint)iFShader); glLinkProgram((GLuint)iProgram); int iProgramLinked; glGetProgramiv((GLuint)iProgram, GL_LINK_STATUS, &iProgramLinked); if (iProgramLinked != GL_TRUE || Application()->HasCommandLineSwitch("--debug-gl")) { int iLogLength = 0; char szLog[1024]; glGetProgramInfoLog((GLuint)iProgram, 1024, &iLogLength, szLog); CShaderLibrary::Get()->WriteLog("link", szLog, "link"); } if (iVertexCompiled != GL_TRUE || iFragmentCompiled != GL_TRUE || iProgramLinked != GL_TRUE) { TError("Shader compilation failed for shader " + m_sName + ". Check shaders.txt\n"); Destroy(); return false; } m_iProgram = iProgram; m_iVShader = iVShader; m_iFShader = iFShader; m_iPositionAttribute = glGetAttribLocation(m_iProgram, "vecPosition"); m_iNormalAttribute = glGetAttribLocation(m_iProgram, "vecNormal"); m_iTangentAttribute = glGetAttribLocation(m_iProgram, "vecTangent"); m_iBitangentAttribute = glGetAttribLocation(m_iProgram, "vecBitangent"); for (size_t i = 0; i < MAX_TEXTURE_CHANNELS; i++) m_aiTexCoordAttributes[i] = glGetAttribLocation(m_iProgram, sprintf("vecTexCoord%d", i).c_str()); m_iColorAttribute = glGetAttribLocation(m_iProgram, "vecVertexColor"); glBindFragDataLocation(m_iProgram, 0, "vecOutputColor"); TAssert(m_iPositionAttribute != ~0); int iNumUniforms; glGetProgramiv(m_iProgram, GL_ACTIVE_UNIFORMS, &iNumUniforms); char szUniformName[256]; GLsizei iLength; GLint iSize; GLenum iType; for (int i = 0; i < iNumUniforms; i++) { glGetActiveUniform(m_iProgram, i, sizeof(szUniformName), &iLength, &iSize, &iType, szUniformName); tstring sUniformName = szUniformName; if (sUniformName == "mProjection") continue; if (sUniformName == "mView") continue; if (sUniformName == "mGlobal") continue; CShader::CUniform& oUniform = m_asUniforms[sUniformName]; oUniform.m_pDefault = nullptr; switch (iType) { case GL_FLOAT: oUniform.m_sUniformType = "float"; break; case GL_FLOAT_VEC2: oUniform.m_sUniformType = "vec2"; break; case GL_FLOAT_VEC3: oUniform.m_sUniformType = "vec3"; break; case GL_FLOAT_VEC4: oUniform.m_sUniformType = "vec4"; break; case GL_INT: oUniform.m_sUniformType = "int"; break; case GL_BOOL: oUniform.m_sUniformType = "bool"; break; case GL_FLOAT_MAT4: oUniform.m_sUniformType = "mat4"; break; case GL_SAMPLER_2D: oUniform.m_sUniformType = "sampler2D"; break; default: TUnimplemented(); } } for (auto it = m_aParameters.begin(); it != m_aParameters.end(); it++) { for (size_t j = 0; j < it->second.m_aActions.size(); j++) { auto it2 = m_asUniforms.find(it->second.m_aActions[j].m_sName); TAssert(it2 != m_asUniforms.end()); if (it2 == m_asUniforms.end()) { TError("Shader '" + m_sName + "' specifies a uniform '" + it->second.m_aActions[j].m_sName + "' that is not in the linked program.\n"); continue; } CShader::CUniform& oUniform = it2->second; // This is almost cheating CData d; d.SetValue(it->second.m_aActions[j].m_sValue); if (oUniform.m_sUniformType == "float") it->second.m_aActions[j].m_flValue = d.GetValueFloat(); else if (oUniform.m_sUniformType == "vec2") it->second.m_aActions[j].m_vec2Value = d.GetValueVector2D(); else if (oUniform.m_sUniformType == "vec3") it->second.m_aActions[j].m_vecValue = d.GetValueVector(); else if (oUniform.m_sUniformType == "vec4") it->second.m_aActions[j].m_vec4Value = d.GetValueVector4D(); else if (oUniform.m_sUniformType == "int") it->second.m_aActions[j].m_iValue = d.GetValueInt(); else if (oUniform.m_sUniformType == "bool") it->second.m_aActions[j].m_bValue = d.GetValueBool(); else if (oUniform.m_sUniformType == "mat4") { TUnimplemented(); } else if (oUniform.m_sUniformType == "sampler2D") { // No op. } else TUnimplemented(); } } for (auto it = m_aDefaults.begin(); it != m_aDefaults.end(); it++) { auto it2 = m_asUniforms.find(it->first); TAssert(it2 != m_asUniforms.end()); if (it2 == m_asUniforms.end()) { TError("Shader '" + m_sName + "' specifies a default for uniform '" + it->second.m_sName + "' that is not in the linked program.\n"); continue; } CShader::CUniform& oUniform = it2->second; oUniform.m_pDefault = &it->second; // Again with the cheating. CData d; d.SetValue(it->second.m_sValue); if (oUniform.m_sUniformType == "float") it->second.m_flValue = d.GetValueFloat(); else if (oUniform.m_sUniformType == "vec2") it->second.m_vec2Value = d.GetValueVector2D(); else if (oUniform.m_sUniformType == "vec3") it->second.m_vecValue = d.GetValueVector(); else if (oUniform.m_sUniformType == "vec4") it->second.m_vec4Value = d.GetValueVector4D(); else if (oUniform.m_sUniformType == "int") it->second.m_iValue = d.GetValueInt(); else if (oUniform.m_sUniformType == "bool") it->second.m_bValue = d.GetValueBool(); else if (oUniform.m_sUniformType == "mat4") { TUnimplemented(); } else if (oUniform.m_sUniformType == "sampler2D") { TUnimplemented(); // Can't set a default texture... yet. } else TUnimplemented(); } return true; }
int main() { //Initilization of GLFW if (!glfwInit()) { return -1; } //create a windowed mode winow and it's OpenGL context GLFWwindow* window; window = glfwCreateWindow(640, 480, "Hello World", NULL, NULL); if (!window) { glfwTerminate(); return -1; } //make the window's context current glfwMakeContextCurrent(window); //............................................................................. //START GLEW BRUH if (glewInit() != GLEW_OK) { // OpenGL didn't start-up! shutdown GLFW and return an error code bruh glfwTerminate(); return -1; } //.............................................................................. //looooppppooop unitl user closes windooe // GENERATE BUFFERS GLuint vao; glGenVertexArrays(1, &vao); //Start using by bindiing;sehti glBindVertexArray(vao); GLuint vbo; glGenBuffers(1, &vbo); // Generate 1 buffer glBindBuffer(GL_ARRAY_BUFFER, vbo); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); GLuint ebo; glGenBuffers(1, &ebo); GLuint elements[] = { 0, 1, 2, 2, 3, 0 }; glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(elements), elements, GL_STATIC_DRAW); // GENERATE SHADERS //VERTEX GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vertexShader, 1, &vertexSource, NULL); glCompileShader(vertexShader); //TEST GLint status; glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &status); if (status == GL_TRUE) { printf("Vertex shader compiled successfully bruh\n"); printf("I furted\n"); } else if (status == GL_FALSE) { printf("Vertex shader error.\n"); } char buffer[512]; glGetShaderInfoLog(vertexShader, 512, NULL, buffer); printf(buffer); //------------------------------------------------------------- //FRAGMENT GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fragmentShader, 1, &fragmentSource, NULL); glCompileShader(fragmentShader); //TEST(SHIT) GLint SHIT; glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &SHIT); if (SHIT == GL_TRUE) { printf("Shit's working fragment shader \n"); } else if (SHIT == GL_FALSE) { printf("SHIT AINT REAL BRUH\n"); } // SHADER PROGRAM GLuint shaderProgram = glCreateProgram(); glAttachShader(shaderProgram, vertexShader); glAttachShader(shaderProgram, fragmentShader); //glBindFragDataLocation(shaderProgram, 0, "outColor"); //Linksshit glLinkProgram(shaderProgram); //start using shit glUseProgram(shaderProgram); GLint statusProgram; glGetProgramiv(shaderProgram, GL_LINK_STATUS, &statusProgram); if (statusProgram == GL_FALSE) { GLint infoLogLength; glGetProgramiv(shaderProgram, GL_INFO_LOG_LENGTH, &infoLogLength); GLchar *strInfoLog = new GLchar[infoLogLength + 1]; glGetProgramInfoLog(shaderProgram, infoLogLength, NULL, strInfoLog); fprintf(stderr, "Linker failure: %s\n", strInfoLog); delete[] strInfoLog; } //================================================================= // LOAD TEXTURE GLuint textures[2]; glGenTextures(2, textures); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, textures[0]); int width, height; unsigned char* image = SOIL_load_image("Sonic.png", &width, &height, 0, SOIL_LOAD_RGB); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image); SOIL_free_image_data(image); glUniform1i(glGetUniformLocation(shaderProgram, "texKitten"), 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, textures[1]); image = SOIL_load_image("sample2.png", &width, &height, 0, SOIL_LOAD_RGB); glTexImage2D(GL_TEXTURE_2D, 0 , GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image); SOIL_free_image_data(image); glUniform1i(glGetUniformLocation(shaderProgram, "texPuppy"), 1); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); //Retrieving Postion GLint posAttrib = glGetAttribLocation(shaderProgram, "position"); GLint texAttrib = glGetAttribLocation(shaderProgram, "texcoord"); GLint colAttrib = glGetAttribLocation(shaderProgram, "color"); glEnableVertexAttribArray(posAttrib); glEnableVertexAttribArray(texAttrib); glEnableVertexAttribArray(colAttrib); glVertexAttribPointer(posAttrib, 2, GL_FLOAT, GL_FALSE, 7 * sizeof(float), 0); glVertexAttribPointer(texAttrib, 2, GL_FLOAT, GL_FALSE, 7 * sizeof(float), (void*)(5 * sizeof(float))); glVertexAttribPointer(colAttrib, 3, GL_FLOAT, GL_FALSE, 7 * sizeof(float), (void*)(2 * sizeof(float))); //--------------------------------------------------------------------------------------------------------- //3D tranforms stuffs GLint uniTrans = glGetUniformLocation(shaderProgram, "trans"); //glm::mat4 view = glm::lookAt // ( // glm::vec3(1.2f, 1.2f, 1.2f), // glm::vec3(0.0f, 0.0f, 0.0f), // glm::vec3(0.0f, 0.0f, 1.0f) // ); //GLint uniView = glGetUniformLocation(shaderProgram, "view"); //glUniformMatrix4fv(uniView, 1, GL_FALSE, glm::value_ptr(view)); //glm::mat4 proj = glm::perspective(45.0f, 800.0f / 600.0f, 1.0f, 10.0f); //GLint uniProj = glGetUniformLocation(shaderProgram, "proj"); //glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(proj)); glfwSetTime(0); float time = 0; while (!glfwWindowShouldClose(window)) { time = glfwGetTime(); if (time > 1.0f / 10.0f) { time -= 1.0f / 10.0f; // background color glClearColor(0.5f, 0.3f, 0.6f, 0.0f); glClear(GL_COLOR_BUFFER_BIT); // Calculate transformation glm::mat4 trans; trans = glm::rotate( trans, (float)clock() / (float)CLOCKS_PER_SEC * glm::radians(0.0f), //Spin and rate glm::vec3(0.0f, 0.0f, 1.0f) ); glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(trans)); vertices[5] += 0.1f; vertices[12] += 0.1f; vertices[19] += 0.1f; vertices[26] += 0.1f; if (vertices[5] == 1) { vertices[5] = 0.0f; vertices[12] = 0.1f; vertices[19] = 0.1f; vertices[26] = 0.0f; } glBindBuffer(GL_ARRAY_BUFFER, vbo); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); //glDrawArrays(GL_TRIANGLES, 0, 6); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0); //glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_INT, 0); //swap front and back buffers glfwSwapBuffers(window); } //poll for and process events glfwPollEvents(); } glfwTerminate(); return 0; }
void Game::LoadAndCompileShaders() { // In the future, this should return an GLuint ID for the shader program. // Also, in the future, this should be adding a shader program to a material component. // Essentially, the eventual purpose of this function will be to load all the shaders for all the mats. std::ifstream inf("vertexShader.vertex"); std::string vertexShaderCode ( (std::istreambuf_iterator<char>(inf) ), (std::istreambuf_iterator<char>() ) ); inf.close(); inf.open("fragmentShader.frag"); std::string fragmentShaderCode ( (std::istreambuf_iterator<char>(inf)), (std::istreambuf_iterator<char>() ) ); GLuint VertexShaderID = glCreateShader(GL_VERTEX_SHADER); GLuint FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER); GLint Result = GL_FALSE; int InfoLogLength; std::ofstream log("log.txt"); std::cout << " Compiling Vertex Shader" << std::endl; char const * VertexSourcePointer = vertexShaderCode.c_str(); glShaderSource(VertexShaderID, 1, &VertexSourcePointer, NULL); glCompileShader(VertexShaderID); // Check shader compilation glGetShaderiv(VertexShaderID, GL_COMPILE_STATUS, &Result); glGetShaderiv(VertexShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength); if(InfoLogLength > 0) { std::vector<char> VertexShaderErrorMessage(InfoLogLength); glGetShaderInfoLog(VertexShaderID, InfoLogLength, NULL, &VertexShaderErrorMessage[0]); std::cout << &VertexShaderErrorMessage[0] << std::endl; log << &VertexShaderErrorMessage[0] << std::endl; } std::cout << "Compiling Fragment Shader" << std::endl; char const * FragmentSourcePointer = fragmentShaderCode.c_str(); glShaderSource(FragmentShaderID, 1, &FragmentSourcePointer, NULL); glCompileShader(FragmentShaderID); glGetShaderiv(FragmentShaderID, GL_COMPILE_STATUS, &Result); glGetShaderiv(FragmentShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength); if(InfoLogLength > 0) { std::vector<char> FragmentShaderErrorMessage(InfoLogLength); glGetShaderInfoLog(FragmentShaderID, InfoLogLength, NULL, &FragmentShaderErrorMessage[0]); std::cout << &FragmentShaderErrorMessage[0] << std::endl; log << &FragmentShaderErrorMessage[0] << std::endl; } std::cout << "Linking Program" << std::endl; GLuint ProgramID = glCreateProgram(); glAttachShader(ProgramID, VertexShaderID); glAttachShader(ProgramID, FragmentShaderID); glLinkProgram(ProgramID); glGetProgramiv(ProgramID, GL_COMPILE_STATUS, &Result); glGetProgramiv(ProgramID, GL_INFO_LOG_LENGTH, &InfoLogLength); std::vector<char> ProgramErrorMessage(std::max(InfoLogLength, int(1))); std::cout << &ProgramErrorMessage[0] << std::endl; glDeleteShader(VertexShaderID); glDeleteShader(FragmentShaderID); glValidateProgram(ProgramID); ShaderProgramID = ProgramID; }