/*
========================
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));
}
}
}
}
}
