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; }
bool Pipeline :: validate () { GLint status; glValidateProgramPipeline ( id ); glGetProgramPipelineiv ( id, GL_VALIDATE_STATUS, &status ); return status != 0; }
static inline bool check_shader_pipeline_validity(device_t device) { int valid = false; glValidateProgramPipeline(device->pipeline); if (!gl_success("glValidateProgramPipeline")) return false; glGetProgramPipelineiv(device->pipeline, GL_VALIDATE_STATUS, &valid); if (!gl_success("glGetProgramPipelineiv")) return false; if (!valid) blog(LOG_ERROR, "Shader pipeline appears to be invalid"); return valid != 0; }
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; }
void ZZshSetupShader() { VERTEXSHADER* vs = (VERTEXSHADER*)g_vsprog.link; FRAGMENTSHADER* ps = (FRAGMENTSHADER*)g_psprog.link; if (vs == NULL || ps == NULL) return; // From the glValidateProgram docs: "The implementation may use this as an opportunity to perform any internal // shader modifications that may be required to ensure correct operation of the installed // shaders given the current GL state" // It might be a good idea to validate the pipeline also in release mode??? #if defined(DEVBUILD) || defined(_DEBUG) glValidateProgramPipeline(s_pipeline); GLint isValid; glGetProgramPipelineiv(s_pipeline, GL_VALIDATE_STATUS, &isValid); if (!isValid) ZZLog::Error_Log("Something weird happened on pipeline validation."); #endif PutParametersInProgram(vs, ps); GL_REPORT_ERRORD(); }
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; }
void GLSLSeparableProgram::compileAndLink() { // Ensure no monolithic programs are in use. OGRE_CHECK_GL_ERROR(glUseProgram(0)); OGRE_CHECK_GL_ERROR(glGenProgramPipelines(1, &mGLProgramPipelineHandle)); //OGRE_CHECK_GL_ERROR(glBindProgramPipeline(mGLProgramPipelineHandle)); mVertexArrayObject->bind(); loadIndividualProgram(mVertexShader); loadIndividualProgram(mDomainShader); loadIndividualProgram(mHullShader); loadIndividualProgram(mGeometryShader); loadIndividualProgram(mFragmentShader); loadIndividualProgram(mComputeShader); if (mLinked) { // if (GpuProgramManager::getSingleton().getSaveMicrocodesToCache() ) // { // // Add to the microcode to the cache // String name; // name = getCombinedName(); // // Get buffer size // GLint binaryLength = 0; // //OGRE_CHECK_GL_ERROR(glGetProgramiv(mGLProgramPipelineHandle, GL_PROGRAM_BINARY_LENGTH, &binaryLength)); // OGRE_CHECK_GL_ERROR(glGetProgramiv(, GL_PROGRAM_BINARY_LENGTH, &binaryLength)); // // Create microcode // GpuProgramManager::Microcode newMicrocode = // GpuProgramManager::getSingleton().createMicrocode((unsigned long)binaryLength + sizeof(GLenum)); // // Get binary // OGRE_CHECK_GL_ERROR(glGetProgramBinary(, binaryLength, NULL, (GLenum *)newMicrocode->getPtr(), newMicrocode->getPtr() + sizeof(GLenum))); // // Add to the microcode to the cache // GpuProgramManager::getSingleton().addMicrocodeToCache(name, newMicrocode); // } if (mVertexShader && mVertexShader->isLinked()) { OGRE_CHECK_GL_ERROR(glUseProgramStages(mGLProgramPipelineHandle, GL_VERTEX_SHADER_BIT, mVertexShader->getGLProgramHandle())); } if (mDomainShader && mDomainShader->isLinked()) { OGRE_CHECK_GL_ERROR(glUseProgramStages(mGLProgramPipelineHandle, GL_TESS_EVALUATION_SHADER_BIT, mDomainShader->getGLProgramHandle())); } if (mHullShader && mHullShader->isLinked()) { OGRE_CHECK_GL_ERROR(glUseProgramStages(mGLProgramPipelineHandle, GL_TESS_CONTROL_SHADER_BIT, mHullShader->getGLProgramHandle())); } if (mGeometryShader && mGeometryShader->isLinked()) { OGRE_CHECK_GL_ERROR(glUseProgramStages(mGLProgramPipelineHandle, GL_GEOMETRY_SHADER_BIT, mGeometryShader->getGLProgramHandle())); } if (mFragmentShader && mFragmentShader->isLinked()) { OGRE_CHECK_GL_ERROR(glUseProgramStages(mGLProgramPipelineHandle, GL_FRAGMENT_SHADER_BIT, mFragmentShader->getGLProgramHandle())); } if (mComputeShader && mComputeShader->isLinked()) { OGRE_CHECK_GL_ERROR(glUseProgramStages(mGLProgramPipelineHandle, GL_COMPUTE_SHADER_BIT, mComputeShader->getGLProgramHandle())); } // Validate pipeline OGRE_CHECK_GL_ERROR(glValidateProgramPipeline(mGLProgramPipelineHandle)); logObjectInfo( getCombinedName() + String("GLSL program pipeline validation result: "), mGLProgramPipelineHandle ); // if (getGLSupport()->checkExtension("GL_KHR_debug") || gl3wIsSupported(4, 3)) // glObjectLabel(GL_PROGRAM_PIPELINE, mGLProgramPipelineHandle, 0, // (mVertexShader->getName() + "/" + mFragmentShader->getName()).c_str()); } }
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL41_nglValidateProgramPipeline(JNIEnv *env, jclass clazz, jint pipeline, jlong function_pointer) { glValidateProgramPipelinePROC glValidateProgramPipeline = (glValidateProgramPipelinePROC)((intptr_t)function_pointer); glValidateProgramPipeline(pipeline); }
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; }