: TestCase(context, params.name.c_str(), params.description.c_str())
, m_glslVersion(glslVersion)
, m_params(params)
+ , m_fboId(0)
+ , m_rboId(0)
{
switch(m_params.testType)
{
, m_texFormat {toTextureFormat(context, m_format)}
, m_texFormatInfo {tcu::getTextureFormatInfo(m_texFormat)}
, m_transFormat {glu::getTransferFormat(m_texFormat)}
+ , m_texture (0)
{
}
, m_nonDepthStencilFormatsCount(DE_LENGTH_OF_ARRAY(coreNonDepthStencilFormats))
, m_otherBaseFormats(coreOtherBaseFormats)
, m_otherBaseFormatsCount(DE_LENGTH_OF_ARRAY(coreOtherBaseFormats))
+ , m_attachmentParamsCount(0)
, m_typeFormat(tf)
, m_textureProgram(0)
, m_colorProgram(0)
if (type.special == true)
{
- std::memcpy(&resultTable[0], &type.bits, sizeof(int) * NUM_FLOAT_PIXEL_COUNT);
+ std::memcpy(&resultTable[0], &type.bits, sizeof(type.bits));
if (type.type == GL_UNSIGNED_INT_5_9_9_9_REV)
{
//this type is another special case: it is always converted to 3-channel color (no A).
int subcuboid_h,
int subcuboid_d,
glu::GLSLVersion glsl_version)
- : m_internalFormat(internalFormat)
+ : m_src_data(0)
+ , tex(0)
+ , prog(0)
+ , m_internalFormat(internalFormat)
, m_format(glu::getTransferFormat(glu::mapGLInternalFormat(internalFormat)).format)
, m_type(glu::getTransferFormat(glu::mapGLInternalFormat(internalFormat)).dataType)
, m_pixelsize(tcu::getPixelSize(glu::mapGLInternalFormat(internalFormat)))
RobustnessBase::RobustnessBase(tcu::TestContext& testCtx, const char* name, const char* description,
glu::ApiType apiType)
- : tcu::TestCase(testCtx, name, description), m_api_type(apiType), m_has_khr_robust_buffer_access(false)
+ : tcu::TestCase(testCtx, name, description), m_api_type(apiType), m_context_is_es(false), m_has_khr_robust_buffer_access(false)
{
}
{
// Detect indentation from first line.
int numIndentChars = 0;
- for (int ndx = 0; isWhitespace(source[ndx]) && ndx < (int)source.length(); ndx++)
+ for (int ndx = 0; ndx < (int)source.length() && isWhitespace(source[ndx]); ndx++)
numIndentChars += source[ndx] == '\t' ? 4 : 1;
// Process all lines and remove preceding indentation.
assumeToken(TOKEN_SHADER_SOURCE);
string source = parseShaderSource(m_curTokenStr.c_str());
advanceToken();
- if (token == TOKEN_BOTH)
+ switch (token)
+ {
+ case TOKEN_BOTH:
bothSource = source;
- else if (token == TOKEN_VERTEX)
+ break;
+ case TOKEN_VERTEX:
vertexSource = source;
- else if (token == TOKEN_FRAGMENT)
+ break;
+ case TOKEN_FRAGMENT:
fragmentSource = source;
- else
+ break;
+ default:
DE_ASSERT(DE_FALSE);
+ }
}
else if (m_curToken == TOKEN_VERSION)
{
SUBGROUP_FEATURE_PARTITIONED_BIT_NV = GL_SUBGROUP_FEATURE_PARTITIONED_BIT_NV,
SUBGROUP_FEATURE_ALL_VALID = (SUBGROUP_FEATURE_BASIC_BIT | SUBGROUP_FEATURE_VOTE_BIT | SUBGROUP_FEATURE_ARITHMETIC_BIT |
SUBGROUP_FEATURE_BALLOT_BIT | SUBGROUP_FEATURE_SHUFFLE_BIT | SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT |
- SUBGROUP_FEATURE_CLUSTERED_BIT | SUBGROUP_FEATURE_QUAD_BIT | SUBGROUP_FEATURE_QUAD_BIT |
- SUBGROUP_FEATURE_PARTITIONED_BIT_NV),
+ SUBGROUP_FEATURE_CLUSTERED_BIT | SUBGROUP_FEATURE_QUAD_BIT | SUBGROUP_FEATURE_PARTITIONED_BIT_NV),
} SubgroupFeatureFlags;
typedef enum Format
}
/* Check basic API queries for source texture. */
- is_ok = is_ok & checkSourceTextureSizeAndType(s_formats[i], s_source_texture_targets[j]);
+ if (is_ok) is_ok = checkSourceTextureSizeAndType(s_formats[i], s_source_texture_targets[j]);
/* For every [R, G, B, A] component. */
for (glw::GLuint k = 0; k < COMPONENTS_COUNT; ++k)
drawQuad();
/* Check results. */
- is_ok = is_ok & checkDestinationTexture(s_formats[i], ColorChannelSelector(k),
- s_source_texture_targets[j],
- s_source_texture_targets_names[j]);
+ if (is_ok) is_ok = checkDestinationTexture(s_formats[i], ColorChannelSelector(k),
+ s_source_texture_targets[j],
+ s_source_texture_targets_names[j]);
/* Cleanup. */
cleanDestinationTexture();
/* Fetch framebuffer. */
std::vector<glw::GLfloat> pixels(s_framebuffer_size * s_framebuffer_size);
- if ((s_framebuffer_size > 0) && (s_framebuffer_size > 0))
+ if (s_framebuffer_size > 0)
{
gl.readPixels(0, 0, s_framebuffer_size, s_framebuffer_size, GL_RED, GL_FLOAT, pixels.data());
GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels call failed.");
/* Fetch framebuffer. */
std::vector<glw::GLfloat> pixels(s_framebuffer_size * s_framebuffer_size);
- if ((s_framebuffer_size > 0) && (s_framebuffer_size > 0))
+ if (s_framebuffer_size > 0)
{
gl.readPixels(0, 0, s_framebuffer_size, s_framebuffer_size, GL_RED, GL_FLOAT, pixels.data());
GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels call failed.");
/* Fetch framebuffer. */
std::vector<glw::GLfloat> pixels(s_framebuffer_size * s_framebuffer_size);
- if ((s_framebuffer_size > 0) && (s_framebuffer_size > 0))
+ if (s_framebuffer_size > 0)
{
gl.readPixels(0, 0, s_framebuffer_size, s_framebuffer_size, GL_RED, GL_FLOAT, pixels.data());
GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels call failed.");
/* Fetch framebuffer. */
std::vector<glw::GLubyte> pixels(number_of_pixels * 4 /* components */);
- if ((s_view_size > 0) && (s_view_size > 0))
+ if (s_view_size > 0)
{
gl.readPixels(0, 0, s_view_size, s_view_size, GL_RGBA, GL_UNSIGNED_BYTE, pixels.data());
GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels call failed.");
if (0 != z_val)
{
- if ((GL_TEXTURE_2D_ARRAY != tex_target) || (GL_TEXTURE_2D_MULTISAMPLE_ARRAY != tex_target) ||
- (GL_TEXTURE_3D != tex_target) || (GL_TEXTURE_CUBE_MAP_ARRAY != tex_target))
+ if (!((GL_TEXTURE_2D_ARRAY == tex_target)
+ || (GL_TEXTURE_2D_MULTISAMPLE_ARRAY == tex_target)
+ || (GL_TEXTURE_3D == tex_target)
+ || (GL_TEXTURE_CUBE_MAP_ARRAY == tex_target)))
{
/* Skip z != 0 for 2d textures */
continue;
fp[4] = 5.0f;
fp[5] = 6.0f;
fp[6] = 7.0f;
- fp[8] = 8.0f;
fp[8] = 9.0f;
fp[12] = 10.0f;
fp[16] = 11.0f;
bool length_as_index;
AdvancedUnsizedArrayLength2()
- : stage(compute)
+ : m_program(0)
+ , m_vertex_array(0)
+ , stage(compute)
, etype(vector)
, layout(std430)
, other_members(false)
, bind_seq(bindbasebefore)
, length_as_index(false)
{
+ for (int i = 0; i < 8; i++)
+ {
+ m_storage_buffer[i] = 0;
+ }
}
};
, m_gohan(context)
, m_goten(context)
, m_chichi(context)
+ , m_goku_location(0)
+ , m_gohan_location(0)
+ , m_chichi_location(0)
{
}
**/
void GPUShaderFP64Test2::inspectProgram(glw::GLuint program_id, glw::GLint n_uniforms,
const uniformTypeDetails& uniform_type, glw::GLint& out_buffer_size,
- uniformDetails& out_uniform_details, glw::GLuint uniform_block_index) const
+ uniformDetails& out_uniform_details, glw::GLuint& uniform_block_index) const
{
glw::GLint array_stride = 0;
std::vector<glw::GLchar> extracted_uniform_name;
stage_ptr->uniform_structure_arrays[0].uniform_double_arr + 1,
stage_ptr->uniform_structure_arrays[0].uniform_dvec2 + 0,
stage_ptr->uniform_structure_arrays[0].uniform_dvec2 + 1,
- stage_ptr->uniform_structure_arrays[0].uniform_dvec2 + 2,
- stage_ptr->uniform_structure_arrays[0].uniform_dvec2 + 3,
stage_ptr->uniform_structure_arrays[0].uniform_dvec3 + 0,
stage_ptr->uniform_structure_arrays[0].uniform_dvec3 + 1,
stage_ptr->uniform_structure_arrays[0].uniform_dvec3 + 2,
- stage_ptr->uniform_structure_arrays[0].uniform_dvec3 + 3,
- stage_ptr->uniform_structure_arrays[0].uniform_dvec3 + 4,
- stage_ptr->uniform_structure_arrays[0].uniform_dvec3 + 5,
stage_ptr->uniform_structure_arrays[0].uniform_dvec4 + 0,
stage_ptr->uniform_structure_arrays[0].uniform_dvec4 + 1,
stage_ptr->uniform_structure_arrays[0].uniform_dvec4 + 2,
stage_ptr->uniform_structure_arrays[0].uniform_dvec4 + 3,
- stage_ptr->uniform_structure_arrays[0].uniform_dvec4 + 4,
- stage_ptr->uniform_structure_arrays[0].uniform_dvec4 + 5,
- stage_ptr->uniform_structure_arrays[0].uniform_dvec4 + 6,
- stage_ptr->uniform_structure_arrays[0].uniform_dvec4 + 7,
&stage_ptr->uniform_structure_arrays[1].uniform_double,
stage_ptr->uniform_structure_arrays[1].uniform_double_arr + 0,
stage_ptr->uniform_structure_arrays[1].uniform_double_arr + 1,
stage_ptr->uniform_structure_arrays[1].uniform_dvec2 + 0,
stage_ptr->uniform_structure_arrays[1].uniform_dvec2 + 1,
- stage_ptr->uniform_structure_arrays[1].uniform_dvec2 + 2,
- stage_ptr->uniform_structure_arrays[1].uniform_dvec2 + 3,
stage_ptr->uniform_structure_arrays[1].uniform_dvec3 + 0,
stage_ptr->uniform_structure_arrays[1].uniform_dvec3 + 1,
stage_ptr->uniform_structure_arrays[1].uniform_dvec3 + 2,
- stage_ptr->uniform_structure_arrays[1].uniform_dvec3 + 3,
- stage_ptr->uniform_structure_arrays[1].uniform_dvec3 + 4,
- stage_ptr->uniform_structure_arrays[1].uniform_dvec3 + 5,
stage_ptr->uniform_structure_arrays[1].uniform_dvec4 + 0,
stage_ptr->uniform_structure_arrays[1].uniform_dvec4 + 1,
stage_ptr->uniform_structure_arrays[1].uniform_dvec4 + 2,
stage_ptr->uniform_structure_arrays[1].uniform_dvec4 + 3,
- stage_ptr->uniform_structure_arrays[1].uniform_dvec4 + 4,
- stage_ptr->uniform_structure_arrays[1].uniform_dvec4 + 5,
- stage_ptr->uniform_structure_arrays[1].uniform_dvec4 + 6,
- stage_ptr->uniform_structure_arrays[1].uniform_dvec4 + 7,
&stage_ptr->uniforms.uniform_double,
stage_ptr->uniforms.uniform_double_arr + 0,
stage_ptr->uniforms.uniform_double_arr + 1,
void inspectProgram(glw::GLuint program_id, glw::GLint n_uniforms, const uniformTypeDetails& uniform_type,
glw::GLint& out_buffer_size, uniformDetails& out_offsets,
- glw::GLuint uniform_block_index) const;
+ glw::GLuint& uniform_block_index) const;
void prepareBoilerplateShader(const glw::GLchar* stage_specific_layout, const glw::GLchar* stage_specific_main_body,
std::string& out_source_code) const;
"Test verifies if MultiDrawElementsIndirectCountARB function works as expected.")
, m_vao(0)
, m_arrayBuffer(0)
+ , m_elementBuffer(0)
, m_drawIndirectBuffer(0)
, m_parameterBuffer(0)
{
, m_vbo_id(0)
, m_to_height(64)
, m_to_width(64)
+ , m_vbo_indirect_arrays_argument_offset(0)
+ , m_vbo_indirect_elements_argument_offset(0)
+ , m_vbo_index_data_offset(0)
+ , m_vbo_n_indices(0)
+ , m_vbo_vertex_data_offset(0)
, m_current_draw_call_type(PipelineStatisticsQueryUtilities::DRAW_CALL_TYPE_COUNT)
, m_current_primitive_type(PipelineStatisticsQueryUtilities::PRIMITIVE_TYPE_COUNT)
, m_indirect_draw_call_baseinstance_argument(0)
fp[4] = 5.0f;
fp[5] = 6.0f;
fp[6] = 7.0f;
- fp[8] = 8.0f;
fp[8] = 9.0f;
fp[12] = 10.0f;
fp[16] = 11.0f;
ImplicitConversionsInvalidTest::ImplicitConversionsInvalidTest(deqp::Context& context)
: NegativeTestBase(context, "implicit_conversions_invalid",
"Verifies that implicit conversions from uint to int are forbidden")
+ , m_current_test_case_index(0)
{
/* Nothing to be done here */
}
**/
ConstAssignmentTest::ConstAssignmentTest(deqp::Context& context)
: NegativeTestBase(context, "const_assignment", "Verifies that constants cannot be overwritten")
+ , m_current_test_case_index(0)
{
/* Nothing to be done here */
}
QualifierOrderTest::QualifierOrderTest(deqp::Context& context)
: GLSLTestBase(context, "qualifier_order",
"Test verifies that valid permutation of input and output qalifiers are accepted")
+ , m_current_test_case_index(0)
{
/* Nothing to be done */
}
QualifierOrderBlockTest::QualifierOrderBlockTest(deqp::Context& context)
: GLSLTestBase(context, "qualifier_order_block",
"Verifies that qualifiers of members of input block can be arranged in any order")
+ , m_current_test_case_index(0)
{
/* Nothing to be done here */
}
QualifierOrderUniformTest::QualifierOrderUniformTest(deqp::Context& context)
: GLSLTestBase(context, "qualifier_order_uniform",
"Test verifies that all valid permutation of input qalifiers are accepted")
+ , m_current_test_case_index(0)
{
/* Nothing to be done here */
}
**/
QualifierOrderFunctionInoutTest::QualifierOrderFunctionInoutTest(deqp::Context& context)
: GLSLTestBase(context, "qualifier_order_function_inout", "Verify order of qualifiers of inout function parameters")
+ , m_current_test_case_index(0)
{
/* Nothing to be done here */
}
**/
QualifierOrderFunctionInputTest::QualifierOrderFunctionInputTest(deqp::Context& context)
: GLSLTestBase(context, "qualifier_order_function_input", "Verify order of qualifiers of function input parameters")
+ , m_current_test_case_index(0)
{
/* Nothing to be done here */
}
QualifierOrderFunctionOutputTest::QualifierOrderFunctionOutputTest(deqp::Context& context)
: GLSLTestBase(context, "qualifier_order_function_output",
"Verify order of qualifiers of output function parameters")
+ , m_current_test_case_index(0)
{
/* Nothing to be done here */
}
BindingUniformSingleBlockTest::BindingUniformSingleBlockTest(deqp::Context& context)
: GLSLTestBase(context, "binding_uniform_single_block", "Test verifies uniform block binding")
, m_goku_buffer(context)
+ , m_test_stage(Utils::SHADER_STAGES_MAX)
{
/* Nothing to be done here */
}
**/
BindingUniformInvalidTest::BindingUniformInvalidTest(deqp::Context& context)
: NegativeTestBase(context, "binding_uniform_invalid", "Test verifies invalid binding values")
+ , m_case(TEST_CASES_MAX)
{
/* Nothing to be done here */
}
, m_vegeta_texture(context)
, m_trunks_texture(context)
, m_buffer(context)
+ , m_test_case(Utils::TEXTURE_TYPES_MAX)
{
/* Nothing to be done here */
}
**/
InitializerListTest::InitializerListTest(deqp::Context& context)
: GLSLTestBase(context, "initializer_list", "Test verifies initializer lists")
+ , m_current_test_case_index(0)
{
/* Nothing to be done here */
}
**/
InitializerListNegativeTest::InitializerListNegativeTest(deqp::Context& context)
: NegativeTestBase(context, "initializer_list_negative", "Verifies invalid initializers")
+ , m_current_test_case_index(0)
{
/* Nothing to be done here */
}
{
}
-Utils::shaderSource::shaderSource(const shaderSource& source) : m_parts(source.m_parts)
+Utils::shaderSource::shaderSource(const shaderSource& source) : m_parts(source.m_parts), m_use_lengths(false)
{
}
-Utils::shaderSource::shaderSource(const glw::GLchar* source_code)
+Utils::shaderSource::shaderSource(const glw::GLchar* source_code) : m_use_lengths(false)
{
if (0 != source_code)
{
*
* @param context CTS context.
**/
-Utils::texture::texture(deqp::Context& context) : m_id(0), m_context(context), m_texture_type(TEX_2D)
+Utils::texture::texture(deqp::Context& context) : m_id(0), m_buffer_id(0), m_context(context), m_texture_type(TEX_2D)
{
/* Nothing to done here */
}
return ERROR;
}
- if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_compute_shader") ||
- !m_context.getContextInfo().isExtensionSupported("GL_ARB_compute_shader"))
+ if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_compute_shader"))
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "Expected "
(const double*)(xfb_data_ptr + (m_n_batches * n_instance + xfb_index) * m_xfb_total_size +
m_xfb_bo1_dvec2_offset);
- if (memcmp(in_dvec2_data_ptr, in_dvec2_data_ptr, m_xfb_bo1_dvec2_size) != 0)
+ if (memcmp(in_dvec2_data_ptr, xfb_dvec2_data_ptr, m_xfb_bo1_dvec2_size) != 0)
{
m_testCtx.getLog() << tcu::TestLog::Message << "BO1 dvec2 attribute values mismatch for batch ["
<< n_element << "]"
(const signed int*)(xfb_data_ptr + (m_n_batches * n_instance + xfb_index) * m_xfb_total_size +
m_xfb_bo1_int_offset);
- if (de::abs((signed int)*in_char_data_ptr - *xfb_int_data_ptr) > epsilon)
+ if (de::abs((signed int)*in_char_data_ptr - *xfb_int_data_ptr) > 0)
{
m_testCtx.getLog() << tcu::TestLog::Message << "BO1 int attribute value mismatch for batch ["
<< n_element << "]"
if (src_topleft.data_internalformat != src_topright.data_internalformat ||
src_topleft.data_internalformat != src_bottomleft.data_internalformat ||
src_topleft.data_internalformat != src_bottomright.data_internalformat ||
- src_topleft.data_internalformat != src_topright.data_internalformat ||
- src_topleft.data_type != src_topright.data_type || src_topleft.data_type != src_bottomleft.data_type ||
+ src_topleft.data_type != src_topright.data_type || src_topleft.data_type != src_bottomleft.data_type ||
src_topleft.data_type != src_bottomright.data_type)
{
return;
NumberParsingCase::NumberParsingCase(deqp::Context& context, const string& name, const TestParams& params, const string& vertexShader, const string& fragmentShader)
: TestCase(context, name.c_str(), params.description.c_str())
+ , m_fboId(0)
+ , m_rboId(0)
, m_params(params)
, m_vertexShader(vertexShader)
, m_fragmentShader(fragmentShader)
{
std::string shader_source = "struct{\n" + this->extend_string(" float", "[2]", 2);
- shader_source += this->extend_string(" a", "[2]", API::MAX_ARRAY_DIMENSIONS - API::MAX_ARRAY_DIMENSIONS);
+ shader_source += this->extend_string(" a", "[2]", 0);
shader_source += ",";
shader_source += this->extend_string(" b", "[2]", 1);
shader_source += ",";
std::string shader_source = example_struct_begin;
shader_source += this->extend_string(" float", "[2]", 2);
- shader_source += this->extend_string(" a", "[2]", API::MAX_ARRAY_DIMENSIONS - API::MAX_ARRAY_DIMENSIONS);
+ shader_source += this->extend_string(" a", "[2]", 0);
shader_source += ", ";
shader_source += this->extend_string("b", "[2]", 2);
shader_source += ", ";
GLuint BuildShaderProgram(GLenum type, const std::string& source)
{
- if (type == GL_COMPUTE_SHADER)
- {
- const char* const src[2] = { kGLSLVer, source.c_str() };
- return glCreateShaderProgramv(type, 2, src);
- }
-
const char* const src[2] = { kGLSLVer, source.c_str() };
return glCreateShaderProgramv(type, 2, src);
}
{
if (getStage() != ComputeShader)
return m_program->getShaderInfo(glu::SHADERTYPE_FRAGMENT).compileOk &&
- m_program->getShaderInfo(glu::SHADERTYPE_FRAGMENT).compileOk && m_program->getProgramInfo().linkOk;
+ m_program->getShaderInfo(glu::SHADERTYPE_VERTEX).compileOk && m_program->getProgramInfo().linkOk;
return m_program->getShaderInfo(glu::SHADERTYPE_COMPUTE).compileOk && m_program->getProgramInfo().linkOk;
}
};
SampleShadingApiCaseGroup::SampleShadingApiCase::SampleShadingApiCase(Context& context, glu::GLSLVersion glslVersion)
- : TestCase(context, "verify", ""), m_glslVersion(glslVersion)
+ : TestCase(context, "verify", ""), m_glslVersion(glslVersion), m_pGLMinSampleShading(0)
{
DE_ASSERT(glslVersion == glu::GLSL_VERSION_310_ES || glslVersion >= glu::GLSL_VERSION_400);
}
GLfloat sampleShading)
: TestCase(context, name, description)
, m_glslVersion(glslVersion)
+ , m_pGLMinSampleShading(0)
, m_internalFormat(internalFormat)
, m_texFormat(texFormat)
, m_sampler(sampler)
fp[4] = 5.0f;
fp[5] = 6.0f;
fp[6] = 7.0f;
- fp[8] = 8.0f;
fp[8] = 9.0f;
fp[12] = 10.0f;
fp[16] = 11.0f;
DrawBuffersIndexedBlending::DrawBuffersIndexedBlending(Context& context, const ExtParameters& extParams,
const char* name, const char* description)
: DrawBuffersIndexedBase(context, extParams, name, description)
+ , m_fbo(0)
{
/* Left blank on purpose */
}
DrawBuffersIndexedColorMasks::DrawBuffersIndexedColorMasks(Context& context, const ExtParameters& extParams,
const char* name, const char* description)
: DrawBuffersIndexedBase(context, extParams, name, description)
+ , m_fbo(0)
{
/* Left blank on purpose */
}
/* Allocate memory for m_tex_height * m_tex_width texels, with each texel being 3 GLints. */
m_texels = new glw::GLint[m_tex_height * m_tex_width * 3];
- memset(m_texels, 255, m_tex_height * m_tex_width * 3);
+ memset(m_texels, 255, sizeof(glw::GLint) * m_tex_height * m_tex_width * 3);
}
/** Deinitializes GLES objects created during the test. */
const ExtParameters& extParams,
const char* name, const char* description)
: GeometryShaderLimitsRenderingBase(context, extParams, name, description)
+ , m_fragment_shader_code_c_str(0)
+ , m_geometry_shader_code_c_str(0)
, m_texture_width(0)
, m_max_output_components(0)
, m_max_output_vectors(0)
GeometryShaderMaxOutputComponentsSinglePointTest::GeometryShaderMaxOutputComponentsSinglePointTest(
Context& context, const ExtParameters& extParams, const char* name, const char* description)
: GeometryShaderLimitsRenderingBase(context, extParams, name, description)
+ , m_fragment_shader_code_c_str(0)
+ , m_geometry_shader_code_c_str(0)
, m_max_output_components(0)
, m_max_output_vectors(0)
, m_n_available_vectors(0)
irrelevant_tess_level1 = (int)irrelevant_tess_level1_rounded_clamped;
irrelevant_tess_level2 = (int)irrelevant_tess_level2_rounded_clamped;
- DE_ASSERT(de::abs(irrelevant_tess_level1 - irrelevant_tess_level2) > epsilon);
+ DE_ASSERT(de::abs(irrelevant_tess_level1 - irrelevant_tess_level2) > 0);
/* Iterate through all test runs for equal spacing */
for (_test_results_iterator test_result_iterator = test_result_iterator_start;
memset(inner_tess_levels, 0, sizeof(inner_tess_levels));
memset(outer_tess_levels, 0, sizeof(outer_tess_levels));
- data = DE_NULL;
- n_vertices = 0;
- primitive_mode = TESSELLATION_SHADER_PRIMITIVE_MODE_UNKNOWN;
- vertex_ordering = TESSELLATION_SHADER_VERTEX_ORDERING_UNKNOWN;
+ data = DE_NULL;
+ is_point_mode_enabled = false;
+ n_vertices = 0;
+ primitive_mode = TESSELLATION_SHADER_PRIMITIVE_MODE_UNKNOWN;
+ vertex_ordering = TESSELLATION_SHADER_VERTEX_ORDERING_UNKNOWN;
}
} _test_iteration;
{
memset(inner, 0, sizeof(inner));
memset(outer, 0, sizeof(outer));
-
- n_vertices = 0;
- primitive_mode = TESSELLATION_SHADER_PRIMITIVE_MODE_UNKNOWN;
- vertex_spacing = TESSELLATION_SHADER_VERTEX_SPACING_UNKNOWN;
+ data_cartesian = 0;
+ n_vertices = 0;
+ primitive_mode = TESSELLATION_SHADER_PRIMITIVE_MODE_UNKNOWN;
+ vertex_spacing = TESSELLATION_SHADER_VERTEX_SPACING_UNKNOWN;
}
} _run;
bool compileOk; //!< Did compilation succeed?
deUint64 compileTimeUs; //!< Compile time in microseconds (us).
- ShaderInfo (void) : compileOk(false), compileTimeUs(0) {}
+ ShaderInfo (void) : type(SHADERTYPE_LAST), compileOk(false), compileTimeUs(0) {}
};
/*--------------------------------------------------------------------*//*!
MaskProportionalityCase::MaskProportionalityCase (Context& context, const char* name, const char* description, CaseType type)
: MultisampleCase (context, name, description)
, m_type (type)
+ , m_numIterations (0)
, m_currentIteration (0)
, m_previousIterationColorSum (-1)
{
, m_numUnitsParam (numUnits)
, m_caseType (caseType)
, m_randSeed (randSeed)
+ , m_numTextures (0)
+ , m_numUnits (0)
, m_shader (DE_NULL)
{
}
multiTexShader.setUniforms (*getCurrentContext(), multiTexShaderID);
// Framebuffers.
- deUint32 fbo0, fbo1;
- deUint32 tex0, tex1;
+ deUint32 fbo0 = 0;
+ deUint32 fbo1 = 0;
+ deUint32 tex0 = 0;
+ deUint32 tex1 = 0;
for (int ndx = 0; ndx < 2; ndx++)
{
deUint32 gradShaderID = getCurrentContext()->createProgram(&gradShader);
deUint32 texShaderID = getCurrentContext()->createProgram(&texShader);
- deUint32 srcFbo, dstFbo;
- deUint32 srcRbo, dstRbo;
+ deUint32 srcFbo = 0;
+ deUint32 dstFbo = 0;
+ deUint32 srcRbo = 0;
+ deUint32 dstRbo = 0;
// Setup shaders
gradShader.setGradient(*getCurrentContext(), gradShaderID, Vec4(0.0f), Vec4(1.0f));
MaskProportionalityCase::MaskProportionalityCase (Context& context, const char* name, const char* description, CaseType type, int numFboSamples)
: MultisampleCase (context, name, description, 32, numFboSamples >= 0 ? FboParams(numFboSamples, false, false) : FboParams())
, m_type (type)
+ , m_numIterations (0)
, m_currentIteration (0)
, m_previousIterationColorSum (-1)
{
GLuint fbo;
GLuint buf;
GLuint tfID;
- GLfloat vertices[1];
+ GLfloat vertices[1] = { 0 };
m_log << tcu::TestLog::Section("", "GL_INVALID_ENUM is generated if mode is not an accepted value.");
glDrawElements(-1, 1, GL_UNSIGNED_BYTE, vertices);
{
glUseProgram(0);
GLuint fbo;
- GLfloat vertices[1];
+ GLfloat vertices[1] = { 0 };
m_log << tcu::TestLog::Section("", "GL_INVALID_ENUM is generated if mode is not an accepted value.");
glDrawElements(-1, 1, GL_UNSIGNED_BYTE, vertices);
GLuint fbo;
GLuint buf;
GLuint tfID;
- GLfloat vertices[1];
+ GLfloat vertices[1] = { 0 };
m_log << tcu::TestLog::Section("", "GL_INVALID_ENUM is generated if mode is not an accepted value.");
glDrawElements(-1, 1, GL_UNSIGNED_BYTE, vertices);
GLuint fbo;
GLuint buf;
GLuint tfID;
- GLfloat vertices[1];
+ GLfloat vertices[1] = { 0 };
glVertexAttribDivisor(0, 1);
expectError(GL_NO_ERROR);
{
glUseProgram(0);
GLuint fbo;
- GLfloat vertices[1];
+ GLfloat vertices[1] = { 0 };
glVertexAttribDivisor(0, 1);
expectError(GL_NO_ERROR);
GLuint fbo;
GLuint buf;
GLuint tfID;
- GLfloat vertices[1];
+ GLfloat vertices[1] = { 0 };
glVertexAttribDivisor(0, 1);
expectError(GL_NO_ERROR);
: TYPE_LAST;
ShaderEvalFunc evalFunc = DE_NULL;
- if (inScalarSize == 1) evalFunc = funcInfo.evalFuncScalar;
- else if (inScalarSize == 2) evalFunc = funcInfo.evalFuncVec2;
- else if (inScalarSize == 3) evalFunc = funcInfo.evalFuncVec3;
- else if (inScalarSize == 4) evalFunc = funcInfo.evalFuncVec4;
- else DE_ASSERT(false);
-
+ switch (inScalarSize)
+ {
+ case 1:
+ evalFunc = funcInfo.evalFuncScalar;
+ break;
+ case 2:
+ evalFunc = funcInfo.evalFuncVec2;
+ break;
+ case 3:
+ evalFunc = funcInfo.evalFuncVec3;
+ break;
+ case 4:
+ evalFunc = funcInfo.evalFuncVec4;
+ break;
+ default:
+ DE_ASSERT(false);
+ }
// Skip if no valid eval func.
// \todo [petri] Better check for V3 only etc. cases?
if (evalFunc == DE_NULL)
, m_numUnitsParam (numUnits)
, m_caseType (caseType)
, m_randSeed (randSeed)
+ , m_numTextures (0)
+ , m_numUnits (0)
, m_shader (DE_NULL)
{
}
int overdrawCount,
bool coherent,
RenderTargetType rtType)
- : TestCase (context, name, desc)
- , m_blendMode (mode)
- , m_overdrawCount (overdrawCount)
- , m_coherentBlending (coherent)
- , m_rtType (rtType)
- , m_numIters (5)
- , m_colorRbo (0)
- , m_fbo (0)
- , m_resolveColorRbo (0)
- , m_resolveFbo (0)
- , m_program (DE_NULL)
- , m_referenceRenderer (DE_NULL)
- , m_refColorBuffer (DE_NULL)
- , m_renderWidth (rtType != RENDERTARGETTYPE_DEFAULT ? 2*MAX_VIEWPORT_WIDTH : m_context.getRenderTarget().getWidth())
- , m_renderHeight (rtType != RENDERTARGETTYPE_DEFAULT ? 2*MAX_VIEWPORT_HEIGHT : m_context.getRenderTarget().getHeight())
- , m_viewportWidth (de::min<int>(m_renderWidth, MAX_VIEWPORT_WIDTH))
- , m_viewportHeight (de::min<int>(m_renderHeight, MAX_VIEWPORT_HEIGHT))
- , m_iterNdx (0)
+ : TestCase (context, name, desc)
+ , m_blendMode (mode)
+ , m_overdrawCount (overdrawCount)
+ , m_coherentBlending (coherent)
+ , m_rtType (rtType)
+ , m_numIters (5)
+ , m_coherentExtensionSupported (false)
+ , m_colorRbo (0)
+ , m_fbo (0)
+ , m_resolveColorRbo (0)
+ , m_resolveFbo (0)
+ , m_program (DE_NULL)
+ , m_referenceRenderer (DE_NULL)
+ , m_refColorBuffer (DE_NULL)
+ , m_renderWidth (rtType != RENDERTARGETTYPE_DEFAULT ? 2*MAX_VIEWPORT_WIDTH : m_context.getRenderTarget().getWidth())
+ , m_renderHeight (rtType != RENDERTARGETTYPE_DEFAULT ? 2*MAX_VIEWPORT_HEIGHT : m_context.getRenderTarget().getHeight())
+ , m_viewportWidth (de::min<int>(m_renderWidth, MAX_VIEWPORT_WIDTH))
+ , m_viewportHeight (de::min<int>(m_renderHeight, MAX_VIEWPORT_HEIGHT))
+ , m_iterNdx (0)
{
}
TestFunctionWrapper::TestFunctionWrapper (void)
: m_type(TYPE_NULL)
{
+ m_func.coreFn = 0;
}
TestFunctionWrapper::TestFunctionWrapper (CoreTestFunc func)
m_gl->bufferData(GL_ARRAY_BUFFER, (glw::GLsizei)(m_data.size() * sizeof(glw::GLfloat)), &m_data[0], GL_STATIC_DRAW);
m_gl->enableVertexAttribArray(0);
- m_gl->vertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * (glw::GLsizei)sizeof(GL_FLOAT), (glw::GLvoid *)0);
+ m_gl->vertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * (glw::GLsizei)sizeof(float), (glw::GLvoid *)0);
m_gl->enableVertexAttribArray(1);
- m_gl->vertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * (glw::GLsizei)sizeof(GL_FLOAT), (glw::GLvoid *)(3 * sizeof(GL_FLOAT)));
+ m_gl->vertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * (glw::GLsizei)sizeof(float), (glw::GLvoid *)(3 * sizeof(float)));
m_gl->bindVertexArray(0);
m_gl->bindBuffer(GL_ARRAY_BUFFER, 0);
FboSRGBTestCase::FboSRGBTestCase (Context& context, const char* const name, const char* const desc)
: TestCase (context, name, desc)
, m_hasTestConfig (false)
+ , m_testcaseRequiresBlend (false)
{
}
return false;
}
+ // Note: never reached
if (logging)
m_testCtx.getLog() << tcu::TestLog::Image("LayerContent", "Layer content", layer);
for (int x = 0; x < result.getWidth(); ++x)
{
const tcu::IVec4 pixel = result.getPixelInt(x, y);
- const bool insideMeshArea = x >= insideBorder.x() && x <= insideBorder.x();
+ const bool insideMeshArea = x >= insideBorder.x() && x <= insideBorder.x();
const bool outsideMeshArea = x <= outsideBorder.x() && x >= outsideBorder.x();
// inside mesh, allow green, yellow and any shade between
Toggling paramsToggleRequired)
: outputTotal (paramsOutputTotal)
, uniformTotal (paramsUniformTotal)
+ , samplingType (TEXTURESAMPLING_TEXTURE)
, blendRequired (paramsBlendRequired)
, toggleRequired (paramsToggleRequired)
{
SRGBTestCase::SRGBTestCase (Context& context, const char* name, const char* description, const tcu::TextureFormat internalFormat)
: TestCase (context, name, description)
, m_epsilonError (EpsilonError::CPU)
+ , m_resultOutputTotal (0)
, m_resultTextureFormat (tcu::TextureFormat(tcu::TextureFormat::sRGBA, tcu::TextureFormat::UNORM_INT8))
, m_vaoID (0)
, m_vertexDataID (0)
, m_samplingGroup (SHADERSAMPLINGGROUP_TEXTURE)
+ , m_px (0)
+ , m_py (0)
, m_internalFormat (internalFormat)
{
}
gl.bindBuffer(GL_ARRAY_BUFFER, m_vertexDataID);
gl.bufferData(GL_ARRAY_BUFFER, (glw::GLsizei)sizeof(squareVertexData), squareVertexData, GL_STATIC_DRAW);
- gl.vertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * (glw::GLsizei)sizeof(GL_FLOAT), (glw::GLvoid *)0);
+ gl.vertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * (glw::GLsizei)sizeof(float), (glw::GLvoid *)0);
gl.enableVertexAttribArray(0);
- gl.vertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * (glw::GLsizei)sizeof(GL_FLOAT), (glw::GLvoid *)(3 * sizeof(GL_FLOAT)));
+ gl.vertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * (glw::GLsizei)sizeof(float), (glw::GLvoid *)(3 * sizeof(float)));
gl.enableVertexAttribArray(1);
gl.bindVertexArray(0);
std::string description;
TextureGenerationSpec (void)
- : immutable (true)
+ : bindTarget (0)
+ , queryTarget (0)
+ , immutable (true)
, fixedSamplePos (true)
, sampleCount (0)
, texBufferDataOffset (0)
// Khronos bug 11180 consensus: if exp2(exponent) cannot be represented,
// the result is undefined.
- if (ret.contains(TCU_INFINITY) | ret.contains(-TCU_INFINITY))
+ if (ret.contains(TCU_INFINITY) || ret.contains(-TCU_INFINITY))
ret |= TCU_NAN;
return call<Mul>(ctx, iargs.a, ret);
break;
default: // Random (evenly distributed) significand.
{
- deUint64 intFraction = rnd.getUint64() & ((1 << fractionBits) - 1);
+ deUint64 intFraction = rnd.getUint64() & ((1ull << fractionBits) - 1);
significand = float(intFraction) * quantum;
}
}
}
ShaderPerformanceMeasurer::ShaderPerformanceMeasurer (const glu::RenderContext& renderCtx, PerfCaseType measureType)
- : m_renderCtx (renderCtx)
- , m_gridSizeX (measureType == CASETYPE_FRAGMENT ? 1 : 255)
- , m_gridSizeY (measureType == CASETYPE_FRAGMENT ? 1 : 255)
- , m_viewportWidth (measureType == CASETYPE_VERTEX ? 32 : renderCtx.getRenderTarget().getWidth())
- , m_viewportHeight (measureType == CASETYPE_VERTEX ? 32 : renderCtx.getRenderTarget().getHeight())
- , m_state (STATE_UNINITIALIZED)
- , m_result (-1.0f, -1.0f)
- , m_indexBuffer (0)
- , m_vao (0)
+ : m_renderCtx (renderCtx)
+ , m_gridSizeX (measureType == CASETYPE_FRAGMENT ? 1 : 255)
+ , m_gridSizeY (measureType == CASETYPE_FRAGMENT ? 1 : 255)
+ , m_viewportWidth (measureType == CASETYPE_VERTEX ? 32 : renderCtx.getRenderTarget().getWidth())
+ , m_viewportHeight (measureType == CASETYPE_VERTEX ? 32 : renderCtx.getRenderTarget().getHeight())
+ , m_state(STATE_UNINITIALIZED)
+ , m_isFirstIteration (false)
+ , m_prevRenderStartTime (0)
+ , m_result (-1.0f, -1.0f)
+ , m_indexBuffer (0)
+ , m_vao (0)
{
}
{
return es31::isCoreQuery(query) ||
query == QUERY_TEXTURE_PARAM_PURE_INTEGER ||
- query == QUERY_TEXTURE_PARAM_PURE_INTEGER ||
query == QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER ||
query == QUERY_TEXTURE_PARAM_PURE_INTEGER_VEC4 ||
query == QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER_VEC4 ||
projects / platform / upstream / VK-GL-CTS.git / commitdiff