/* ======================== compileAndAttachShader assumes the shader is available. ======================== */ bool CShader::compileAndAttachShader( int shaderType ) { GLint status; char text[ 4096 ]; // must be deleted before use! assert( m_shaders[ shaderType ] == 0 ); // shader type not supported, skip if( !isShaderTypeAvailable( shaderType ) ) return true; // check if we have source code defined for this shader if( m_shaderSources[ shaderType ].isEmpty() ) return true; // shader not used. m_log += QString( "Compiling %1\n" ).arg( getShaderTypeName(shaderType) ); // create the shader object. m_shaders[ shaderType ] = glCreateShader( toGlShaderType( shaderType ) ); if( m_shaders[ shaderType ] == 0 ) { m_log += QString( "ERROR: failed on glCreateShader( %1 )\n" ). arg( getShaderTypeName( shaderType ) ); return false; } // recompile shader int length = m_shaderSources[ shaderType ].length() + 1; char* buf = new char[ length ]; const GLchar* src = buf; strncpy( buf, m_shaderSources[ shaderType ].toAscii(), length ); glShaderSource ( m_shaders[ shaderType ], 1, &src, NULL ); glCompileShader( m_shaders[ shaderType ] ); delete [] buf; // read the log memset( text, 0, sizeof(text) ); glGetShaderInfoLog( m_shaders[ shaderType ], sizeof(text), NULL, text ); text[ sizeof(text)-1 ] = '\0'; m_log += QString( "%1\n" ).arg( text ); // attach/detach glGetShaderiv( m_shaders[ shaderType ], GL_COMPILE_STATUS, &status ); if( status != GL_FALSE ) { // success glAttachShader( m_program, m_shaders[ shaderType ] ); return true; } return false; }
bool is_compiled(unsigned shader, GLenum type){ int params = -1; glGetShaderiv (shader, GL_COMPILE_STATUS, ¶ms); if (GL_TRUE != params) { std::cout << " == " << getShaderTypeName(type) << " compilation failed == " << std::endl; int max_length = 2048; int actual_length = 0; char log[2048]; glGetShaderInfoLog (shader, max_length, &actual_length, log); std::cout << log << std::endl; return false; } return true; }
int Shader::compileShader(GLuint program, GLenum shaderType, const char *shaderCode) { if (glIsProgram(program)) { GLuint shader = glCreateShader(shaderType); glShaderSource(shader, 1, &shaderCode, nullptr); glCompileShader(shader); GLint status = GL_FALSE, infoLogLength = 10; glGetShaderiv(shader, GL_COMPILE_STATUS, &status); if (status == GL_TRUE) { glAttachShader(program, shader); //logOpenGLError("ATTACH_" + getShaderTypeName(shaderType)); return shader; } else { glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLength); std::vector<char> infoLog(infoLogLength, 'X'); glGetShaderInfoLog(shader, infoLogLength, nullptr, &infoLog[0]); std::cerr << "OpenGL Error compiling " << getShaderTypeName(shaderType) << " of Shader Program '" << name << "':" << std::endl; std::cerr << &infoLog[0] << std::endl; //logOpenGLError("COMPILE_" + getShaderTypeName(shaderType)); } } return -1; }
/** Compiles and links program with variable amount of shaders * * @param po_id Program handle * @param out_has_compilation_failed Deref will be set to true, if shader compilation * failed for any of the submitted shaders. * Will be set to false otherwise. Can be NULL. * @param sh_stages Shader stages * @for all shader stages * { * @param sh_id Shader handle. 0 means "skip" * @param sh_parts Number of shader source code parts. * 0 means that it's already compiled. * @param sh_code Shader source code. * } **/ bool TestCaseBase::buildProgramVA(glw::GLuint po_id, bool* out_has_compilation_failed, unsigned int sh_stages, ...) { const glw::Functions& gl = m_context.getRenderContext().getFunctions(); std::vector<glw::GLuint> vec_sh_id; va_list values; va_start(values, sh_stages); /* Shaders compilation */ glw::GLint compilation_status = GL_FALSE; for (unsigned int stage = 0; stage < sh_stages; ++stage) { glw::GLuint sh_id = va_arg(values, glw::GLuint); unsigned int sh_parts = va_arg(values, unsigned int); const char* const* sh_code = va_arg(values, const char* const*); if (sh_id == 0) { continue; } if (sh_parts != 0) { std::string sh_merged_string = specializeShader(sh_parts, sh_code); const char* sh_merged_ptr = sh_merged_string.c_str(); gl.shaderSource(sh_id, 1, &sh_merged_ptr, NULL); GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() failed!"); gl.compileShader(sh_id); GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader() failed!"); gl.getShaderiv(sh_id, GL_COMPILE_STATUS, &compilation_status); GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() failed!"); if (compilation_status != GL_TRUE) { glw::GLint shader_type = 0; std::string info_log = getCompilationInfoLog(sh_id); gl.getShaderiv(sh_id, GL_SHADER_TYPE, &shader_type); std::string shader_type_str = getShaderTypeName(shader_type); m_testCtx.getLog() << tcu::TestLog::Message << shader_type_str << " compilation failure:\n\n" << info_log << "\n\n" << shader_type_str << " source:\n\n" << sh_merged_string << "\n\n" << tcu::TestLog::EndMessage; break; } } gl.attachShader(po_id, sh_id); GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader(VERTEX_SHADER) call failed"); vec_sh_id.push_back(sh_id); } va_end(values); if (out_has_compilation_failed != NULL) { *out_has_compilation_failed = (compilation_status == GL_FALSE); } if (compilation_status != GL_TRUE) { return false; } /* Linking the program */ glw::GLint link_status = GL_FALSE; gl.linkProgram(po_id); GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram() failed!"); gl.getProgramiv(po_id, GL_LINK_STATUS, &link_status); GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() failed!"); if (link_status != GL_TRUE) { /* Dump link log */ std::string link_log = getLinkingInfoLog(po_id); m_testCtx.getLog() << tcu::TestLog::Message << "Link failure:\n\n" << link_log << "\n\n" << tcu::TestLog::EndMessage; /* Dump shader source */ for (std::vector<glw::GLuint>::iterator it = vec_sh_id.begin(); it != vec_sh_id.end(); ++it) { glw::GLint shader_type = 0; gl.getShaderiv(*it, GL_SHADER_TYPE, &shader_type); std::string shader_type_str = getShaderTypeName(shader_type); std::string shader_source = getShaderSource(*it); m_testCtx.getLog() << tcu::TestLog::Message << shader_type_str << " source:\n\n" << shader_source << "\n\n" << tcu::TestLog::EndMessage; } return false; } return true; }
void ShaderLoopTests::init (void) { // Loop cases. static const ShaderType s_shaderTypes[] = { SHADERTYPE_VERTEX, SHADERTYPE_FRAGMENT }; static const DataType s_countDataType[] = { TYPE_INT, TYPE_FLOAT }; for (int loopType = 0; loopType < LOOPTYPE_LAST; loopType++) { const char* loopTypeName = getLoopTypeName((LoopType)loopType); for (int loopCountType = 0; loopCountType < LOOPCOUNT_LAST; loopCountType++) { const char* loopCountName = getLoopCountTypeName((LoopCountType)loopCountType); string groupName = string(loopTypeName) + "_" + string(loopCountName) + "_iterations"; string groupDesc = string("Loop tests with ") + loopCountName + " loop counter."; TestCaseGroup* group = new TestCaseGroup(m_context, groupName.c_str(), groupDesc.c_str()); addChild(group); // Generic cases. for (int precision = 0; precision < PRECISION_LAST; precision++) { const char* precisionName = getPrecisionName((Precision)precision); for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_countDataType); dataTypeNdx++) { DataType loopDataType = s_countDataType[dataTypeNdx]; const char* dataTypeName = getDataTypeName(loopDataType); for (int shaderTypeNdx = 0; shaderTypeNdx < DE_LENGTH_OF_ARRAY(s_shaderTypes); shaderTypeNdx++) { ShaderType shaderType = s_shaderTypes[shaderTypeNdx]; const char* shaderTypeName = getShaderTypeName(shaderType); bool isVertexCase = (shaderType == SHADERTYPE_VERTEX); string name = string("basic_") + precisionName + "_" + dataTypeName + "_" + shaderTypeName; string desc = string(loopTypeName) + " loop with " + precisionName + dataTypeName + " " + loopCountName + " iteration count in " + shaderTypeName + " shader."; group->addChild(createGenericLoopCase(m_context, name.c_str(), desc.c_str(), isVertexCase, (LoopType)loopType, (LoopCountType)loopCountType, (Precision)precision, loopDataType)); } } } // Special cases. for (int loopCase = 0; loopCase < LOOPCASE_LAST; loopCase++) { const char* loopCaseName = getLoopCaseName((LoopCase)loopCase); // no-iterations not possible with do-while. if ((loopCase == LOOPCASE_NO_ITERATIONS) && (loopType == LOOPTYPE_DO_WHILE)) continue; for (int shaderTypeNdx = 0; shaderTypeNdx < DE_LENGTH_OF_ARRAY(s_shaderTypes); shaderTypeNdx++) { ShaderType shaderType = s_shaderTypes[shaderTypeNdx]; const char* shaderTypeName = getShaderTypeName(shaderType); bool isVertexCase = (shaderType == SHADERTYPE_VERTEX); string name = string(loopCaseName) + "_" + shaderTypeName; string desc = string(loopCaseName) + " loop with " + loopTypeName + " iteration count in " + shaderTypeName + " shader."; group->addChild(createSpecialLoopCase(m_context, name.c_str(), desc.c_str(), isVertexCase, (LoopCase)loopCase, (LoopType)loopType, (LoopCountType)loopCountType)); } } } } }