int ShaderProgram::loadShader(const char* shader_filepath, GLuint &shader) { // Read shader code std::string shaderCode = ""; std::ifstream shaderStream(shader_filepath, std::ios::in); if(shaderStream.is_open()) { std::string Line = ""; while(getline(shaderStream, Line)) shaderCode += "\n" + Line; shaderStream.close(); } else { printf("Failed to open %s.\n", shader_filepath); getchar(); return -1;} // Compile shader //printf("Compiling shader: %s\n", shader_filepath); char const* source = shaderCode.c_str(); glShaderSource(shader, 1, &source , NULL); glCompileShader(shader); // Check shader GLint result = GL_FALSE; int infoLogLength; glGetShaderiv(shader, GL_COMPILE_STATUS, &result); glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLength); if (infoLogLength > 0) { std::vector<char> shaderErrorMessage(infoLogLength+1); glGetShaderInfoLog(shader, infoLogLength, NULL, &shaderErrorMessage[0]); printf("%s\n", &shaderErrorMessage[0]); return -2; } return 0; }
void Shader::LoadShader( const std::string &filename, int type ) { GLuint shaderID = glCreateShader( type ); std::string shaderCode; std::ifstream shaderStream( filename, std::ios::in ); if ( shaderStream.is_open() ) { std::string line = ""; while ( getline( shaderStream, line ) ) { shaderCode += "\n" + line; } shaderStream.close(); } else { fprintf( stderr, "Error loading shader." ); return; } GLint result = GL_FALSE; int infoLogLength; char const *sourcePoint = shaderCode.c_str(); glShaderSource( shaderID, 1, &sourcePoint, NULL ); glCompileShader( shaderID ); glGetShaderiv( shaderID, GL_COMPILE_STATUS, &result ); glGetShaderiv( shaderID, GL_INFO_LOG_LENGTH, &infoLogLength ); std::vector<char> shaderErrorMessage( infoLogLength ); glGetShaderInfoLog( shaderID, infoLogLength, NULL, &shaderErrorMessage[ 0 ] ); // fprintf( stdout, "%s\n", &shaderErrorMessage[ 0 ] ); AttachShader( shaderID ); }
void Shader::buildShader(GLuint shaderLoc, const char* fileName) { // Read the Vertex Shader code from the file std::string shaderCode; std::ifstream shaderStream(fileName, std::ios::in); if (shaderStream.is_open()) { std::string Line = ""; while (getline(shaderStream, Line)) shaderCode += "\n" + Line; shaderStream.close(); } else { LOG_FATAL(logger) << "Could not open file!"; } // Compile Shader char const * sourcePointer = shaderCode.c_str(); glShaderSource(shaderLoc, 1, &sourcePointer , NULL); glCompileShader(shaderLoc); // Check Vertex Shader GLint Result = GL_FALSE; int InfoLogLength; glGetShaderiv(shaderLoc, GL_COMPILE_STATUS, &Result); glGetShaderiv(shaderLoc, GL_INFO_LOG_LENGTH, &InfoLogLength); std::vector<char> shaderErrorMessage(InfoLogLength); glGetShaderInfoLog(shaderLoc, InfoLogLength, NULL, &shaderErrorMessage[0]); if (!Result) LOG_ERROR(logger) << &shaderErrorMessage[0]; }
GLint Shader::loadShader(GLint iType, const GLchar *file_path) { GLuint shaderID = glCreateShader(iType); std::ifstream shaderStream(file_path, std::ios::in); std::string shaderCode = "\0"; if (shaderStream.is_open()) { std::string sLine = "\0"; while(getline(shaderStream, sLine)) { shaderCode += "\n" + sLine; } shaderStream.close(); if (iType == GL_VERTEX_SHADER) { sVertexShaderCode = shaderCode; } else if(iType == GL_FRAGMENT_SHADER) { sFragmentShaderCode = shaderCode; } return shaderID; } else { printf("Failed to open %s. Are you in the right directory ? \n", file_path); getchar(); return -1; } }
/* Az http://www.opengl-tutorial.org/ oldal alapján. */ GLuint loadShader(GLenum _shaderType, const char* _fileName) { // shader azonosito letrehozasa GLuint loadedShader = glCreateShader( _shaderType ); // ha nem sikerult hibauzenet es -1 visszaadasa if ( loadedShader == 0 ) { fprintf(stderr, "Hiba a shader inicializálásakor (glCreateShader) %s!", _fileName); return 0; } // shaderkod betoltese _fileName fajlbol std::string shaderCode = ""; // _fileName megnyitasa std::ifstream shaderStream(_fileName); if ( !shaderStream.is_open() ) { fprintf(stderr, "Hiba a %s shader fájl betöltésekor!", _fileName); return 0; } // file tartalmanak betoltese a shaderCode string-be std::string line = ""; while ( std::getline(shaderStream, line) ) { shaderCode += line + " "; } shaderStream.close(); // fajlbol betoltott kod hozzarendelese a shader-hez const char* sourcePointer = shaderCode.c_str(); glShaderSource( loadedShader, 1, &sourcePointer, NULL ); // shader leforditasa glCompileShader( loadedShader ); // ellenorizzuk, h minden rendben van-e GLint result = GL_FALSE; int infoLogLength; // forditas statuszanak lekerdezese glGetShaderiv(loadedShader, GL_COMPILE_STATUS, &result); glGetShaderiv(loadedShader, GL_INFO_LOG_LENGTH, &infoLogLength); if ( GL_FALSE == result ) { // hibauzenet elkerese es kiirasa std::vector<char> VertexShaderErrorMessage(infoLogLength); glGetShaderInfoLog(loadedShader, infoLogLength, NULL, &VertexShaderErrorMessage[0]); fprintf(stdout, "%s/n", &VertexShaderErrorMessage[0]); } return loadedShader; }
GLuint GlHelper::CreateShader(GLenum eShaderType, const std::string &strShaderFile) { GLuint shader = glCreateShader(eShaderType); std::string shaderCode; std::ifstream shaderStream(strShaderFile.c_str(), std::ios::in); if(shaderStream.is_open()) { std::string Line = ""; while(getline(shaderStream, Line)) shaderCode += "\n" + Line; shaderStream.close(); } else { std::cerr << strShaderFile.c_str() << " dosyasi acilamadi. Uygulamanizi bu dosyanin oldugu dizinde calistirdiginizdan emin olunuz." << std::endl; getchar(); return 0; } const char* shaderCodePtr = shaderCode.c_str(); glShaderSource(shader, 1, &shaderCodePtr, NULL); glCompileShader(shader); GLint status; glGetShaderiv(shader, GL_COMPILE_STATUS, &status); if (status == GL_FALSE) { GLint infoLogLength; glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLength); GLchar *strInfoLog = new GLchar[infoLogLength + 1]; glGetShaderInfoLog(shader, infoLogLength, NULL, strInfoLog); const char *strShaderType = NULL; switch(eShaderType) { case GL_VERTEX_SHADER: strShaderType = "vertex"; break; case GL_GEOMETRY_SHADER: strShaderType = "geometry"; break; case GL_FRAGMENT_SHADER: strShaderType = "fragment"; break; } std::cerr << strShaderType << " tipi shader dosyasi derlenemedi. Detaylar:\n" << strInfoLog << std::endl; delete[] strInfoLog; } return shader; }
GLuint GLHelper::createShader(GLenum eShaderType, const std::string &strShaderFile) { GLuint shader = glCreateShader(eShaderType); std::string shaderCode; std::ifstream shaderStream(strShaderFile.c_str(), std::ios::in); if (shaderStream.is_open()) { std::string Line = ""; while (getline(shaderStream, Line)) shaderCode += "\n" + Line; shaderStream.close(); } else { std::cerr << strShaderFile.c_str() << " could not be read. Please ensure run directory if you used relative paths." << std::endl; getchar(); return 0; } const char *shaderCodePtr = shaderCode.c_str(); glShaderSource(shader, 1, &shaderCodePtr, NULL); glCompileShader(shader); GLint status; glGetShaderiv(shader, GL_COMPILE_STATUS, &status); if (status == GL_FALSE) { GLint infoLogLength; glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLength); GLchar *strInfoLog = new GLchar[infoLogLength + 1]; glGetShaderInfoLog(shader, infoLogLength, NULL, strInfoLog); const char *strShaderType = NULL; switch (eShaderType) { case GL_VERTEX_SHADER: strShaderType = "vertex"; break; case GL_GEOMETRY_SHADER: strShaderType = "geometry"; break; case GL_FRAGMENT_SHADER: strShaderType = "fragment"; break; } std::cerr << strShaderType << " type shader " << strShaderFile.c_str() << " could not be compiled:\n" << strInfoLog << std::endl; delete[] strInfoLog; } checkErrors("createShader"); return shader; }
GLuint CreateShader(GLenum a_eShaderType, const char *a_strShaderFile) { std::string strShaderCode; //open shader file std::ifstream shaderStream(a_strShaderFile); //if that worked ok, load file line by line if (shaderStream.is_open()) { std::string Line = ""; while (std::getline(shaderStream, Line)) { strShaderCode += "\n" + Line; } shaderStream.close(); } //convert to cstring char const *szShaderSourcePointer = strShaderCode.c_str(); //create shader ID GLuint uiShader = glCreateShader(a_eShaderType); //load source code glShaderSource(uiShader, 1, &szShaderSourcePointer, NULL); //compile shader glCompileShader(uiShader); //Check for compiliation errors and output them GLint iStatus; glGetShaderiv(uiShader, GL_COMPILE_STATUS, &iStatus); if (iStatus == GL_FALSE) { GLint infoLogLength; glGetShaderiv(uiShader, GL_INFO_LOG_LENGTH, &infoLogLength); GLchar *strInfoLog = new GLchar[infoLogLength + 1]; glGetShaderInfoLog(uiShader, infoLogLength, NULL, strInfoLog); const char *strShaderType = NULL; switch (a_eShaderType) { case GL_VERTEX_SHADER: strShaderType = "vertex"; break; case GL_FRAGMENT_SHADER: strShaderType = "fragment"; break; } fprintf(stderr, "Compile failure in %s shader:\n%s\n", strShaderType, strInfoLog); delete[] strInfoLog; } return uiShader; }
std::string ShaderProgram::readShaderFile(const char *path) { std::string shaderCode; std::ifstream shaderStream(path, std::ios::in); if(shaderStream.is_open()) { std::string line = ""; while(getline(shaderStream, line)) { shaderCode += "\n" + line; } shaderStream.close(); } else { throw ShaderException(std::string("Could not open file ") + path); } return shaderCode; }
GLuint compileShader(const char* shaderPath, GLenum shaderType) { // Determine the type of shader const char* shaderTypeName = getShaderName(shaderType); if(shaderTypeName == NULL) { Log::log_render(ERR) << "Unknown Shader Type '" << shaderType << "' Specified For: " << shaderPath; return 0; } // Attempt to read the file path given std::string shaderSource; std::ifstream shaderStream(shaderPath, std::ios::in); if(shaderStream.is_open()) { std::string line = ""; while(getline(shaderStream, line)) shaderSource += "\n" + line; shaderStream.close(); } else { Log::log_render(ERR) << "Failed to Open Shader: " << shaderPath; return 0; } GLuint shaderID = glCreateShader(shaderType); registeredShaders.push_back(shaderID); Log::log_render(INFO) << "Compiling " << shaderTypeName << " Shader [" << shaderID << "]: " << shaderPath; // Attempt to compile shader const char* sourcePointer = shaderSource.c_str(); glShaderSource(shaderID, 1, &sourcePointer, NULL); glCompileShader(shaderID); // Check on compile status GLint result = GL_FALSE; int infoLogLength; glGetShaderiv(shaderID, GL_COMPILE_STATUS, &result); glGetShaderiv(shaderID, GL_INFO_LOG_LENGTH, &infoLogLength); char shaderErrorMessage[infoLogLength+1]; glGetShaderInfoLog(shaderID, infoLogLength, NULL, &shaderErrorMessage[0]); if(!result) { Log::log_render(ERR) << shaderTypeName << " Shader Error: " << shaderErrorMessage; return 0; } return shaderID; }
bool CTechnique::AddShader(GLenum shaderType, const char* pFileName) { std::ifstream shaderStream(pFileName, std::ios::in); std::string shaderCode; if (shaderStream.is_open()) { std::string line = ""; while (std::getline(shaderStream, line)) shaderCode += "\n" + line; shaderStream.close(); } else return false; GLuint shaderObj = glCreateShader(shaderType); if (shaderObj == 0) return false; m_shaderObjList.push_back(shaderObj); const GLchar* p[1]; p[0] = shaderCode.c_str(); GLint lengths[1] = { (GLuint)shaderCode.size() }; glShaderSource(shaderObj, 1, p, lengths); glCompileShader(shaderObj); GLint success; glGetShaderiv(shaderObj, GL_COMPILE_STATUS, &success); if (!success) { GLchar infoLog[1024]; glGetShaderInfoLog(shaderObj, 1024, NULL, infoLog); OutputDebugStringA(infoLog); } glAttachShader(m_shaderProg, shaderObj); return true; }
std::string APP_OBJLoader::LoadShader(const char *a_filePath) { std::string strShaderCode; //file info holder //open shader file std::ifstream shaderStream(a_filePath); //if that worked ok, load file line by line if (shaderStream.is_open()) { std::string Line = ""; while (std::getline(shaderStream, Line)) { strShaderCode += "\n" + Line; } shaderStream.close(); } return strShaderCode; }
GLboolean Program::attachShader(std::string filename, GLenum type) { GLuint shaderId = glCreateShader(type); std::string shaderCode; std::ifstream shaderStream(filename, std::ios::in); if(shaderStream.is_open()) { std::string line = ""; while(getline(shaderStream, line)) shaderCode += "\n" + line; shaderStream.close(); } else { std::cerr << clog::err << "Cannot open " << filename << "." << std::endl; std::cin.get(); return GL_FALSE; } GLint result = GL_FALSE; GLint infoLogLength; //compile vertex shader std::cout << clog::inf << "Compiling shader (" << filename << ")..." << std::endl; char const* sourcePointer = shaderCode.c_str(); glShaderSource(shaderId, 1, &sourcePointer , NULL); glCompileShader(shaderId); //check vertex shader glGetShaderiv(shaderId, GL_COMPILE_STATUS, &result); glGetShaderiv(shaderId, GL_INFO_LOG_LENGTH, &infoLogLength); if(infoLogLength > 0) { std::vector<char> shaderErrorMessage(infoLogLength + 1); glGetShaderInfoLog(shaderId, infoLogLength, NULL, &shaderErrorMessage[0]); std::cerr << clog::err << &shaderErrorMessage[0] << std::endl; } glAttachShader(instance, shaderId); //glDeleteShader(vertexShaderId); return GL_TRUE; }
std::string shaderhelper::loadShader(const std::string & shaderFilename) { std::string appPath = pathhelper::getApplicationPath(); std::string shaderPath = appPath + "/" + shaderFilename; std::string shaderCode; std::ifstream shaderStream(shaderPath.c_str(), std::ios::in); if (shaderStream.is_open()) { std::string Line; while (getline(shaderStream, Line)) { shaderCode += "\n" + Line; } shaderStream.close(); } else { throw std::invalid_argument("Unable to open " + shaderPath); } return shaderCode; }
/// <summary> /// Loads the shader. /// </summary> /// <param name="filename">The filename.</param> /// <param name="type">The type.</param> /// <returns></returns> GLuint ShaderProgram::LoadShader( const std::string& filename, GLenum type ) { // Create the shader GLuint shaderID = glCreateShader( type ); // Read the Shader code from the file std::string shaderCode; std::ifstream shaderStream( filename, std::ios::in ); if( shaderStream.is_open() ) { std::string line = ""; while( getline( shaderStream, line ) ) shaderCode += "\n" + line; shaderStream.close(); } else { Debug::Log( "Could not find shader with path: " + filename ); return 0; } GLint result = GL_FALSE; int infoLogLength; // Compile Shader Debug::Log( "Compiling shader: " + filename ); char const * sourcePointer = shaderCode.c_str(); glShaderSource( shaderID, 1, &sourcePointer, NULL ); glCompileShader( shaderID ); // Check Shader glGetShaderiv( shaderID, GL_COMPILE_STATUS, &result ); glGetShaderiv( shaderID, GL_INFO_LOG_LENGTH, &infoLogLength ); std::vector<char> shaderErrorMessage( infoLogLength ); glGetShaderInfoLog( shaderID, infoLogLength, NULL, &shaderErrorMessage[0] ); Debug::Log( trim( std::string( shaderErrorMessage.begin(), shaderErrorMessage.end() ) ), LogType::Error ); CHECK_GL_ERROR(); return shaderID; }
void modifyShader(std::string& shader) { std::istringstream shaderStream(shader); std::string line; std::getline(shaderStream, line); std::string mod_shader("#version 300 es\n"); std::unordered_map<std::string, int>::iterator it; std::unordered_map<std::string, int>::iterator it1; while (std::getline(shaderStream, line)) { if (line.find("GL_ARB_separate_shader_objects") != std::string::npos || line.find("GL_ARB_shading_language_420pack") != std::string::npos) continue; std::unordered_map<std::string, int> tokens; getTokens(tokens, line); if ((it = tokens.find("uniform")) != tokens.end() && checkSamplers(tokens)){ int layout_pos = tokens["layout"]; mod_shader += ((layout_pos > 0) ? line.substr(0, layout_pos) : "") + line.substr(it->second) + "\n"; } else if ((it = tokens.find("layout")) != tokens.end() && tokens.find("uniform")==tokens.end() && tokens.find("num_views") == tokens.end()) { it1 = tokens.find("in"); if (it1 == tokens.end()) it1 = tokens.find("out"); int pos = it->second; if(it1 != tokens.end()) mod_shader += ((pos > 0) ? line.substr(0, pos) : "") + line.substr(it1->second) + "\n"; } else { mod_shader += line + "\n"; } } shader = mod_shader; }
GLuint loadShader(string file_path, GLuint shader) { GLuint shaderID = glCreateShader(shader); string shaderCode; ifstream shaderStream(file_path, std::ios::in); if (shaderStream.is_open()) { string Line = ""; while (getline(shaderStream, Line)) shaderCode += "\n" + Line; shaderStream.close(); } else { cerr << "Cannot open: " << file_path << endl; return 0; } cout << "Compiling shader: " << file_path << endl; char const* sourcePointer = shaderCode.c_str(); glShaderSource(shaderID, 1, &sourcePointer, NULL); glCompileShader(shaderID); GLint result = 0; glGetShaderiv(shaderID, GL_COMPILE_STATUS, &result); if (result == GL_FALSE) { GLint infoLogLength = 0; glGetShaderiv(shaderID, GL_INFO_LOG_LENGTH, &infoLogLength); vector<char> shaderErrorMessage(infoLogLength); glGetShaderInfoLog(shaderID, infoLogLength, NULL, &shaderErrorMessage[0]); cerr << &shaderErrorMessage[0] << endl; return 0; } return shaderID; }
bool Shader::loadShader(const char * filePath, shader_type_t shaderType) { std::string shaderCode; std::ifstream shaderStream(filePath, std::ios::in); if (shaderStream.is_open()) { std::string line = ""; while (getline(shaderStream, line)) { shaderCode += '\n' + line; } shaderStream.close(); } else { std::cerr << "Couldn't open file\n"; return false; } shaderID = glCreateShader(shaderType); const char * sourcePointer = shaderCode.c_str(); glShaderSource(shaderID, 1, &sourcePointer, NULL); glCompileShader(shaderID); int compilationStatus = 0; glGetShaderiv(shaderID, GL_COMPILE_STATUS, &compilationStatus); if (compilationStatus == GL_FALSE) { char infoLog[1024]; int logLength; glGetShaderInfoLog(shaderID, 1024, &logLength, infoLog); std::cerr << "Error! Shader File " << filePath << " wasn't compiled! The compiler returned:\n\n" << infoLog << '\n'; return false; } this->shaderType = shaderType; loaded = true; return true; }
std::string APP_SpotRotate::LoadShader(const char *a_filePath) { std::string strShaderCode; //file info holder //open shader file std::ifstream shaderStream(a_filePath); //if that worked ok, load file line by line if (shaderStream.is_open()) { std::string Line = ""; while (std::getline(shaderStream, Line)) { strShaderCode += "\n" + Line; } shaderStream.close(); } //a_shaderResult = strShaderCode.c_str(); //const char* result = strShaderCode.c_str(); //(_result) = (*result); return strShaderCode; //not in use }
bool ShaderD3D11::createEffect () { try { uint32_t hlslFlags = 0; { hlslFlags = D3D10_SHADER_ENABLE_BACKWARDS_COMPATIBILITY; } ID3D10Blob * shaderCode = 0; ID3D10Blob * errors = 0; std::vector<D3D10_SHADER_MACRO> vectorDefines; if (_defines.size() > 0) { for (auto it = _defines.begin(); it != _defines.end(); it++) { D3D10_SHADER_MACRO macro = {(*it).first.c_str(), (*it).second.c_str()}; vectorDefines.push_back (macro); } D3D10_SHADER_MACRO nullMacro = {0, 0}; vectorDefines.push_back (nullMacro); _hash.build(shaderStream()); if(FAILED(D3DCompile(shaderStream().c_str(), shaderStream().size(), 0, (const D3D_SHADER_MACRO*)&*vectorDefines.begin(), nullptr, "", "fx_5_0", hlslFlags, 0, &shaderCode, &errors))) { // LOG ("Failed to compile ... " << shaderStream() << "\n"); LOG ("Failed to compile " << IShader::filePathName()); if(errors) { char* buffer = new char[errors->GetBufferSize()+1]; memset(&buffer[0], 0, errors->GetBufferSize()+1); memcpy(&buffer[0], errors->GetBufferPointer(), errors->GetBufferSize()); // LOG ("Error Compiling ShaderD3D11" << buffer); generateDumpFile(IShader::filePathName(), buffer, shaderStream()); delete[] (buffer); } return false; } } else { _hash.build(shaderStream()); if(FAILED(D3DCompile(shaderStream().c_str(), shaderStream().size(), 0, 0, nullptr, "", "fx_5_0", D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY | D3DCOMPILE_SKIP_OPTIMIZATION , 0, &shaderCode, &errors))) { LOG ("Failed to compile " << IShader::filePathName()); // Open file and dump error information. if(errors) { char* buffer = new char[errors->GetBufferSize()+1]; memset(&buffer[0], 0, errors->GetBufferSize()+1); memcpy(&buffer[0], errors->GetBufferPointer(), errors->GetBufferSize()); generateDumpFile(IShader::filePathName(), buffer, shaderStream()); LOG ("Error Compiling ShaderD3D11" << buffer); delete[] (buffer); } return false; } } safedeletearray (_compiledBuffer); _compiledBufferSize = shaderCode->GetBufferSize(); _compiledBuffer = new char[_compiledBufferSize]; memcpy (_compiledBuffer, shaderCode->GetBufferPointer(), _compiledBufferSize * sizeof(char)); // Create effect ID3DX11Effect* effect = 0; if(FAILED(D3DX11CreateEffectFromMemory(_compiledBuffer, _compiledBufferSize, 0, _direct3d, &effect))) { LOG ("FAILED to create effect from memory ... \n"); } else { _effect = new EffectD3D11 (effect); return true; } } catch(...) { LOG ("Something bad and unknown happened while creating the shader"); } return false; }