GLint ComputeWaterSimulation::createShaderPipelineProgram(GLuint target, const char* src, GLuint &pipeline, GLuint &program) { GLint status; glGenProgramPipelines(1, &pipeline); program = glCreateShaderProgramv(target, 1, (const GLchar **)&src); glBindProgramPipeline(pipeline); glUseProgramStages(pipeline, GL_COMPUTE_SHADER_BIT, program); glValidateProgramPipeline(pipeline); glGetProgramPipelineiv(pipeline, GL_VALIDATE_STATUS, &status); if (status != GL_TRUE) { GLint logLength; glGetProgramPipelineiv(pipeline, GL_INFO_LOG_LENGTH, &logLength); char *log = new char [logLength]; glGetProgramPipelineInfoLog(pipeline, logLength, 0, log); LOGI("Shader pipeline not valid:\n%s\n", log); delete [] log; } glBindProgramPipeline(0); return status; }
GLuint ShaderPipeline::createShaderPipelineProgram(GLuint target, const char* src, const char* m_shaderPrefix, GLuint m_programPipeline) { GLuint object; GLint status; const GLchar* fullSrc[2] = { m_shaderPrefix, src }; object = glCreateShaderProgramv(target, 2, fullSrc); { GLint logLength; glGetProgramiv(object, GL_INFO_LOG_LENGTH, &logLength); if (logLength > 0) { // This log contains shader compile errors. char *log = new char[logLength]; glGetProgramInfoLog(object, logLength, 0, log); LOGI("Shader pipeline program not valid:\n%s\n", log); delete[] log; } } glBindProgramPipeline(m_programPipeline); glUseProgramStages(m_programPipeline, GL_COMPUTE_SHADER_BIT, object); glValidateProgramPipeline(m_programPipeline); glGetProgramPipelineiv(m_programPipeline, GL_VALIDATE_STATUS, &status); if (status != GL_TRUE) { GLint logLength; glGetProgramPipelineiv(m_programPipeline, GL_INFO_LOG_LENGTH, &logLength); if (logLength > 0) { char *log = new char[logLength]; glGetProgramPipelineInfoLog(m_programPipeline, logLength, 0, log); LOGI("Shader pipeline not valid:\n%s\n", log); delete[] log; } } glBindProgramPipeline(0); CHECK_GL_ERROR(); return object; }
string Pipeline :: getLog () const { int len; string log; glGetProgramPipelineiv ( id, GL_INFO_LOG_LENGTH, &len ); if ( len < 1 ) return ""; char * buf = (char *) malloc ( len + 1 ); glGetProgramPipelineInfoLog ( id, len+1, NULL, buf ); log = buf; free ( buf ); return log; }
GeneralGL::GLError::GLError(GLErrorType type, GLuint handle, std::string message) { this->type = type; this->handle = handle; this->msg = message; char log[512]; switch (type) { case SHADER: glGetShaderInfoLog(handle, 512, 0, log); break; case PROGRAM: glGetProgramInfoLog(handle, 512, 0, log); break; case PROGRAM_PIPELINE: glGetProgramPipelineInfoLog(handle, 512, 0, log); } std::string infoLog = std::string(log); this->log = infoLog; }
bool GSShaderOGL::ValidatePipeline(GLuint p) { if (!m_debug_shader) return true; // FIXME: might be mandatory to validate the pipeline glValidateProgramPipeline(p); GLint status = 0; glGetProgramPipelineiv(p, GL_VALIDATE_STATUS, &status); if (status) return true; GLint log_length = 0; glGetProgramPipelineiv(p, GL_INFO_LOG_LENGTH, &log_length); if (log_length > 0) { char* log = new char[log_length]; glGetProgramPipelineInfoLog(p, log_length, NULL, log); fprintf(stderr, "%s", log); delete[] log; } fprintf(stderr, "\n"); return false; }
std::string GlslShaderSource::get_pipeline_info_log(GLuint op) { #if defined(DNLOAD_GLESV2) (void)op; return std::string(); #else std::string ret; GLint len; glGetProgramPipelineiv(op, GL_INFO_LOG_LENGTH, &len); if(len) { GLchar *log = new GLchar[len]; GLsizei acquired; glGetProgramPipelineInfoLog(op, len, &acquired, log); ret.assign(log); delete[] log; } return ret; #endif }
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL41_nglGetProgramPipelineInfoLog(JNIEnv *env, jclass clazz, jint pipeline, jint bufSize, jlong length, jlong infoLog, jlong function_pointer) { GLsizei *length_address = (GLsizei *)(intptr_t)length; GLchar *infoLog_address = (GLchar *)(intptr_t)infoLog; glGetProgramPipelineInfoLogPROC glGetProgramPipelineInfoLog = (glGetProgramPipelineInfoLogPROC)((intptr_t)function_pointer); glGetProgramPipelineInfoLog(pipeline, bufSize, length_address, infoLog_address); }
bool validate(GLuint const & ProgramName) { bool Error = false; // Pipeline object validation { GLint Status(0); GLint LengthMax(0); glValidateProgramPipeline(PipelineName); glGetProgramPipelineiv(PipelineName, GL_VALIDATE_STATUS, &Status); glGetProgramPipelineiv(PipelineName, GL_INFO_LOG_LENGTH, &LengthMax); GLsizei LengthQuery(0); std::vector<GLchar> InfoLog(LengthMax + 1, '\0'); glGetProgramPipelineInfoLog(PipelineName, GLsizei(InfoLog.size()), &LengthQuery, &InfoLog[0]); glDebugMessageInsertARB( GL_DEBUG_SOURCE_APPLICATION_ARB, GL_DEBUG_TYPE_OTHER_ARB, 76, GL_DEBUG_SEVERITY_LOW_ARB, LengthQuery, &InfoLog[0]); } GLint ActiveAttributeMaxLength(0); GLint ActiveAttribute(0); glGetProgramiv(ProgramName, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &ActiveAttributeMaxLength); glGetProgramiv(ProgramName, GL_ACTIVE_ATTRIBUTES, &ActiveAttribute); GLsizei AttribLength(0); GLint AttribSize(0); GLenum AttribType(0); std::vector<GLchar> AttribName(ActiveAttributeMaxLength, '\0'); for(GLint i = 0; i < ActiveAttribute; ++i) { glGetActiveAttrib(ProgramName, GLuint(i), GLsizei(ActiveAttributeMaxLength), &AttribLength, &AttribSize, &AttribType, &AttribName[0]); std::string NameString; NameString.insert(NameString.begin(), AttribName.begin(), AttribName.end()); std::vector<GLchar> NameSwap(ActiveAttributeMaxLength, '\0'); std::swap(AttribName, NameSwap); GLint AttribLocation = glGetAttribLocation(ProgramName, NameString.c_str()); vertexattrib VertexAttrib; glGetVertexAttribiv(AttribLocation, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &VertexAttrib.Enabled); //glGetVertexAttribiv(AttribLocation, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, &VertexAttrib.Binding); glGetVertexAttribiv(AttribLocation, GL_VERTEX_ATTRIB_ARRAY_SIZE, &VertexAttrib.Size); glGetVertexAttribiv(AttribLocation, GL_VERTEX_ATTRIB_ARRAY_STRIDE, &VertexAttrib.Stride); glGetVertexAttribiv(AttribLocation, GL_VERTEX_ATTRIB_ARRAY_TYPE, &VertexAttrib.Type); glGetVertexAttribiv(AttribLocation, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, &VertexAttrib.Normalized); glGetVertexAttribiv(AttribLocation, GL_VERTEX_ATTRIB_ARRAY_INTEGER, &VertexAttrib.Integer); glGetVertexAttribiv(AttribLocation, GL_VERTEX_ATTRIB_ARRAY_DIVISOR, &VertexAttrib.Divisor); glGetVertexAttribPointerv(AttribLocation, GL_VERTEX_ATTRIB_ARRAY_POINTER, &VertexAttrib.Pointer); if(GL_VERTEX_ATTRIB_ARRAY_INTEGER == GL_TRUE) { if(!( VertexAttrib.Type == GL_INT || VertexAttrib.Type == GL_INT_VEC2 || VertexAttrib.Type == GL_INT_VEC3 || VertexAttrib.Type == GL_INT_VEC4 || VertexAttrib.Type == GL_UNSIGNED_INT || VertexAttrib.Type == GL_UNSIGNED_INT_VEC2 || VertexAttrib.Type == GL_UNSIGNED_INT_VEC3 || VertexAttrib.Type == GL_UNSIGNED_INT_VEC4)) return true; if(!( VertexAttrib.Type == GL_BYTE || VertexAttrib.Type == GL_UNSIGNED_BYTE || VertexAttrib.Type == GL_SHORT || VertexAttrib.Type == GL_UNSIGNED_SHORT || VertexAttrib.Type == GL_INT || VertexAttrib.Type == GL_UNSIGNED_INT)) return true; //if(AttribSize > 1) //GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, and GL_DOUBLE } else if(VertexAttrib.Long == GL_TRUE) // OpenGL Spec bug { if( VertexAttrib.Type == GL_DOUBLE || VertexAttrib.Type == GL_DOUBLE_VEC2 || VertexAttrib.Type == GL_DOUBLE_VEC3 || VertexAttrib.Type == GL_DOUBLE_VEC4 || VertexAttrib.Type == GL_DOUBLE_MAT2 || VertexAttrib.Type == GL_DOUBLE_MAT3 || VertexAttrib.Type == GL_DOUBLE_MAT4 || VertexAttrib.Type == GL_DOUBLE_MAT2x3 || VertexAttrib.Type == GL_DOUBLE_MAT2x4 || VertexAttrib.Type == GL_DOUBLE_MAT3x2 || VertexAttrib.Type == GL_DOUBLE_MAT3x4 || VertexAttrib.Type == GL_DOUBLE_MAT4x2 || VertexAttrib.Type == GL_DOUBLE_MAT4x3) { if(VertexAttrib.Type != GL_DOUBLE) return true; } else// if((VertexAttrib.Normalized == GL_TRUE) || (GL_VERTEX_ATTRIB_ARRAY_FLOAT == GL_TRUE)) { if(!( VertexAttrib.Type == GL_FLOAT || VertexAttrib.Type == GL_FLOAT_VEC2 || VertexAttrib.Type == GL_FLOAT_VEC3 || VertexAttrib.Type == GL_FLOAT_VEC4 || VertexAttrib.Type == GL_FLOAT_MAT2 || VertexAttrib.Type == GL_FLOAT_MAT3 || VertexAttrib.Type == GL_FLOAT_MAT4 || VertexAttrib.Type == GL_FLOAT_MAT2x3 || VertexAttrib.Type == GL_FLOAT_MAT2x4 || VertexAttrib.Type == GL_FLOAT_MAT3x2 || VertexAttrib.Type == GL_FLOAT_MAT3x4 || VertexAttrib.Type == GL_FLOAT_MAT4x2 || VertexAttrib.Type == GL_FLOAT_MAT4x3)) return true; // It could be any vertex array attribute type } } printf("glGetActiveAttrib(\n\t%d, \n\t%d, \n\t%d, \n\t%d, \n\t%d, \n\t%s)\n", i, AttribLocation, AttribLength, AttribSize, AttribType, NameString.c_str()); } return Error; }
int main(int argc, char* argv[]) { MyGame* game = nullptr; // pointer to allow game termination when exceptions are caught try { load(WINDOW_WIDTH, WINDOW_HEIGHT); SDL_Window* window = SDL_GL_GetCurrentWindow(); SDL_GLContext glContext = SDL_GL_GetCurrentContext(); MyGame myGame(window, glContext, WINDOW_WIDTH, WINDOW_HEIGHT); // should MyGame become owner of window and glcontext when passed them? would change ~MyGame() // also, should MyGame::Terminate and Initialize even exist? Initialize could be constructor, terminate destructor game = &myGame; myGame.Initialize(); myGame.Draw(); unsigned int lastUpdate = SDL_GetTicks(); while (myGame.isRunning()) { if (lastUpdate + 66 < SDL_GetTicks()) { myGame.Update(); myGame.Draw(); lastUpdate = SDL_GetTicks(); } } myGame.Terminate(); unload(); } catch (SDLInitError err) { printf("%s, err: %s", err.getMessage().c_str(), SDL_GetError()); std::cin.get(); } catch (InitError err) { printf("Initialization failed, err: %s", err.getMessage().c_str()); std::cin.get(); } catch (GLError err) { char* type = ""; GLchar log[512]; switch (err.getType()) { case GLErrorType::PROGRAM: type = "Program"; glGetProgramInfoLog(err.getHandle(), 512, NULL, log); break; case GLErrorType::PROGRAM_PIPELINE: type = "Program Pipeline"; glGetProgramPipelineInfoLog(err.getHandle(), 512, NULL, log); break; case GLErrorType::SHADER: type = "Shaders"; glGetShaderInfoLog(err.getHandle(), 512, NULL, log); break; } printf("Error with GL %s. \nError Message: %s.\n", type, err.getMessage().c_str()); std::cout << "GL Log: " << log << std::endl; std::cin.get(); } if (game) { game->Terminate(); } unload(); return 0; }
String logObjectInfo(const String& msg, const GLuint obj) { String logMessage = msg; // Invalid object. if (obj <= 0) { return logMessage; } GLint infologLength = 0; GLboolean isShader = glIsShader(obj); GLboolean isProgramPipeline = glIsProgramPipeline(obj); GLboolean isProgram = glIsProgram(obj); if (isShader) { OGRE_CHECK_GL_ERROR(glGetShaderiv(obj, GL_INFO_LOG_LENGTH, &infologLength)); } else if (isProgramPipeline && Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_SEPARATE_SHADER_OBJECTS)) { //FIXME Crashes on NVIDIA? See GL3+ GSoC forum // posts around 2013-11-25. OGRE_CHECK_GL_ERROR(glGetProgramPipelineiv(obj, GL_INFO_LOG_LENGTH, &infologLength)); } else if (isProgram) { OGRE_CHECK_GL_ERROR(glGetProgramiv(obj, GL_INFO_LOG_LENGTH, &infologLength)); } // No info log available. // if (infologLength <= 1) if (infologLength < 1) { return logMessage; } GLint charsWritten = 0; char * infoLog = new char [infologLength]; infoLog[0] = 0; if (isShader) { OGRE_CHECK_GL_ERROR(glGetShaderInfoLog(obj, infologLength, &charsWritten, infoLog)); } else if (isProgramPipeline && Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_SEPARATE_SHADER_OBJECTS)) { OGRE_CHECK_GL_ERROR(glGetProgramPipelineInfoLog(obj, infologLength, &charsWritten, infoLog)); } else if (isProgram) { OGRE_CHECK_GL_ERROR(glGetProgramInfoLog(obj, infologLength, &charsWritten, infoLog)); } if (strlen(infoLog) > 0) { logMessage += "\n" + String(infoLog); } delete [] infoLog; if (logMessage.size() > 0) { // Remove empty lines from the end of the log. while (logMessage[logMessage.size() - 1] == '\n') { logMessage.erase(logMessage.size() - 1, 1); } LogManager::getSingleton().logMessage(logMessage); } return logMessage; }