ExecuteBinaryMessage (const deUint8* data, size_t dataSize);
ExecuteBinaryMessage (void) : Message(MESSAGETYPE_EXECUTE_BINARY) {}
- ~ExecuteBinaryMessage (void) {};
+ ~ExecuteBinaryMessage (void) {}
void write (std::vector<deUint8>& buf) const;
};
* @param error_message Message logged if generated error is not the expected one
**/
#define CHECK_ERROR(expected_error, error_message) \
- { \
+ do { \
GLenum generated_error = m_gl->getError(); \
\
if (expected_error != generated_error) \
TestBase::done(); \
TCU_FAIL("Invalid error generated"); \
} \
- }
+ } while (0)
/** Pop all groups from stack
*
for (GLuint i = 0; i < m_n_shared_contexts + 1; ++i)
{
subroutine_indices[i].set(bit_field[i], m_subroutine_indices);
- };
+ }
/* Update subroutine uniforms, each context gets different set */
for (GLuint i = 0; i < m_n_shared_contexts; ++i)
break;
default:
TCU_FAIL("Unsupported type");
- };
+ }
}
template <typename Type>
// internal format positive range (otherwise it may wrap and
// yield negative internalformat values)
inputValue = clampUnsignedValue(bit3 - 1, inputValue);
- ;
inputValue = clampSignedValue(bit3, inputValue);
if (isCopy)
break;
default:
TCU_FAIL("Invalid enum");
- };
+ }
m_specializationMap["SRC_COORD_OFFSET"] = "0";
m_specializationMap["SRC_SAMPLE_OFFSET"] = "0";
namespace tcu
{
class WaiverUtil;
-};
+}
namespace deqp
{
{
array.elementType = DE_NULL;
array.size = 0;
- };
+ }
} m_data;
};
class DepthFuncWrapper
{
public:
- DepthFuncWrapper(deqp::Context& context) : m_gl(context.getRenderContext().getFunctions()){};
- ~DepthFuncWrapper(){};
+ DepthFuncWrapper(deqp::Context& context) : m_gl(context.getRenderContext().getFunctions()){}
+ ~DepthFuncWrapper(){}
void depthRangeArray(glw::GLuint first, glw::GLsizei count, const glw::GLfloat* v)
{
Tests(const CullDistance::Tests& other);
Tests& operator=(const CullDistance::Tests& other);
};
-};
+}
/* CullDistance namespace */
} /* glcts namespace */
default:
TCU_FAIL("Invalid value");
break;
- };
+ }
switch (desc->m_internal_format)
{
break;
default:
throw 0;
- };
+ }
}
void gl3cts::TransformFeedback::DrawXFB::bindBOForDraw(glw::GLuint program_id, glw::GLenum capture_mode,
virtual IterateResult iterate(void)
{
return CaptureGeometryInterleaved::iterate();
- };
+ }
protected:
glw::GLuint* m_buffers;
virtual void draw(glw::GLenum primitive_type)
{
CaptureGeometryInterleaved::draw(primitive_type);
- };
+ }
virtual void fetchLimits(void)
{
CaptureVertexSeparate::fetchLimits();
- };
+ }
virtual void createTransformFeedbackBuffer(void)
{
CaptureVertexSeparate::createTransformFeedbackBuffer();
- };
+ }
virtual void bindBuffer(BindBufferCase bind_case)
{
CaptureVertexSeparate::bindBuffer(bind_case);
- };
+ }
virtual void cleanBuffer(void)
{
CaptureVertexSeparate::cleanBuffer();
- };
+ }
virtual bool checkTransformFeedbackBuffer(BindBufferCase bind_case, glw::GLenum primitive_type)
{
return CaptureVertexSeparate::checkTransformFeedbackBuffer(bind_case, primitive_type);
- };
+ }
};
/** GetXFBVaryingVertexInterleaved
case GL_RIGHT:
case GL_FRONT_AND_BACK:
is_attachment = true;
- };
+ }
for (glw::GLint i = 0; i < m_max_color_attachments; ++i)
{
case GL_STENCIL_ATTACHMENT:
case GL_DEPTH_STENCIL_ATTACHMENT:
continue;
- };
+ }
break;
- };
+ }
/* Invalid color attachment. */
glw::GLint max_color_attachments = 8; /* Spec default. */
case GL_DEPTH:
case GL_STENCIL:
continue;
- };
+ }
break;
}
{
ShaderInterface(Shader::STAGES stage);
- DEFINE_VARIABLE_CLASS(Input, Variable::VARYING_INPUT, m_inputs);
- DEFINE_VARIABLE_CLASS(Output, Variable::VARYING_OUTPUT, m_outputs);
- DEFINE_VARIABLE_CLASS(Uniform, Variable::UNIFORM, m_uniforms);
- DEFINE_VARIABLE_CLASS(SSB, Variable::SSB, m_ssb_blocks);
+ DEFINE_VARIABLE_CLASS(Input, Variable::VARYING_INPUT, m_inputs)
+ DEFINE_VARIABLE_CLASS(Output, Variable::VARYING_OUTPUT, m_outputs)
+ DEFINE_VARIABLE_CLASS(Uniform, Variable::UNIFORM, m_uniforms)
+ DEFINE_VARIABLE_CLASS(SSB, Variable::SSB, m_ssb_blocks)
/**/
std::string GetDefinitionsGlobals() const;
{
TCU_FAIL("Unrecognized variable type");
}
- }; /* switch (type) */
+ } /* switch (type) */
return result;
}
{
TCU_FAIL("Unrecognized variable type");
}
- }; /* switch (type) */
+ } /* switch (type) */
return result;
}
break;
default:
break;
- }; /* switch (type) */
+ } /* switch (type) */
return result;
}
default:
break;
- };
+ }
/* Select shaders that will be used by program */
const glw::GLchar* cs_c_str = 0;
TCU_FAIL("Not implemented");
return;
break;
- };
+ }
switch (function_object.getFunctionEnum())
{
break;
default:
throw 0;
- };
+ }
}
else
{
break;
default:
throw 0;
- };
+ }
}
}
* @param error_message Message logged if generated error is not the expected one
**/
#define CHECK_ERROR(expected_error, error_message) \
- { \
+ do { \
GLenum generated_error = gl.getError(); \
\
if (expected_error != generated_error) \
<< tcu::TestLog::EndMessage; \
TCU_FAIL("Invalid error generated"); \
} \
- }
+ } while (0)
/* Prototypes */
void replaceToken(const GLchar* token, size_t& search_position, const GLchar* text, std::string& string);
" gl_TessLevelOuter[1] = 1.0; \n"
" gl_TessLevelOuter[2] = 1.0; \n"
"}";
- };
+ }
virtual std::string TessEvalShader()
{
{
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, rt_[i], 0);
draw_buffers[i] = GL_COLOR_ATTACHMENT0 + i;
- };
+ }
glDrawBuffers(8, draw_buffers);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
default:
TCU_FAIL("Not implemented");
break;
- };
+ }
return string;
}
default:
TCU_FAIL("Not implemented");
break;
- };
+ }
return string;
}
if (array_size > 1)
{
result_sstream << "[" << array_size << "]";
- };
+ }
result_sstream << ";\n";
result_sstream << "subroutine void subroutineTestTypeFS(out vec4 test);\n"
"\n"
"subroutine uniform subroutineTestTypeFS test_subroutineFS;\n";
- };
+ }
result_sstream << "\n"
"out vec4 result;\n"
result_sstream << "subroutine void subroutineTestTypeGS(out vec4 test);\n"
"\n"
"subroutine uniform subroutineTestTypeGS test_subroutineGS;\n";
- };
+ }
result_sstream << "\n"
"void main()\n"
result_sstream << "subroutine void subroutineTestTypeTC(out vec4 test);\n"
"\n"
"subroutine uniform subroutineTestTypeTC test_subroutineTC;\n";
- };
+ }
result_sstream << "\n"
"void main()\n"
result_sstream << "subroutine void subroutineTestTypeTE(out vec4 test);\n"
"\n"
"subroutine uniform subroutineTestTypeTE test_subroutineTE;\n";
- };
+ }
result_sstream << "\n"
"void main()\n"
result_sstream << "subroutine void subroutineTestTypeVS(out vec4 test);\n"
"\n"
"subroutine uniform subroutineTestTypeVS test_subroutineVS;\n";
- };
+ }
result_sstream << "\n"
"void main()\n"
"}\n"
"\n"
"subroutine uniform subroutineTestTypeFS test_subroutineFS;\n";
- };
+ }
result_sstream << "\n"
"out vec4 result;\n"
"}\n"
"\n"
"subroutine uniform subroutineTestTypeGS test_subroutineGS;\n";
- };
+ }
result_sstream << "\n"
"void main()\n"
"}\n"
"\n"
"subroutine uniform subroutineTestTypeTC test_subroutineTC;\n";
- };
+ }
result_sstream << "\n"
"void main()\n"
"}\n"
"\n"
"subroutine uniform subroutineTestTypeTE test_subroutineTE;\n";
- };
+ }
result_sstream << "\n"
"void main()\n"
"}\n"
"\n"
"subroutine uniform subroutineTestTypeVS test_subroutineVS;\n";
- };
+ }
result_sstream << "\n"
"void main()\n"
"subroutine(subroutineTestTypeFS) void test_impl1(out vec4 test);\n"
"\n"
"subroutine uniform subroutineTestTypeFS test_subroutineFS;\n";
- };
+ }
result_sstream << "\n"
"out vec4 result;\n"
"subroutine(subroutineTestTypeGS) void test_impl1(out vec4 test);\n"
"\n"
"subroutine uniform subroutineTestTypeGS test_subroutineGS;\n";
- };
+ }
result_sstream << "\n"
"void main()\n"
"subroutine(subroutineTestTypeTC) void test_impl1(out vec4 test);\n"
"\n"
"subroutine uniform subroutineTestTypeTC test_subroutineTC;\n";
- };
+ }
result_sstream << "\n"
"void main()\n"
"subroutine(subroutineTestTypeTE) void test_impl1(out vec4 test);\n"
"\n"
"subroutine uniform subroutineTestTypeTE test_subroutineTE;\n";
- };
+ }
result_sstream << "\n"
"void main()\n"
"subroutine(subroutineTestTypeVS) void test_impl1(out vec4 test);\n"
"\n"
"subroutine uniform subroutineTestTypeVS test_subroutineVS;\n";
- };
+ }
result_sstream << "\n"
"void main()\n"
break;
default:
TCU_FAIL("Invalid enum");
- };
+ }
return result;
}
if (false == doesStageSupportQualifier(stage, storage, qualifier))
{
continue;
- };
+ }
/* Replace wrong storage qualifiers */
if ((Utils::INPUT == storage) && ((Utils::QUAL_UNIFORM == qualifier) || (Utils::QUAL_OUT == qualifier)))
break;
default:
break;
- };
+ }
const GLuint store_results_length = static_cast<GLuint>(strlen(store_results));
const GLuint pass_condition_length = static_cast<GLuint>(strlen(pass_condition));
case PART_NEXT_TO_TERMINATION_NON_NULL:
result = true;
break;
- };
+ }
return result;
}
case DEBUG_CASE: /* intended fall through */
default:
break; /* no line continuations */
- };
+ }
Utils::replaceAllTokens(token_assignment_after_operator_case, assignment_after_operator_case, source);
Utils::replaceAllTokens(token_assignment_before_operator_case, assignment_before_operator_case, source);
case PART_NEXT_TO_TERMINATION_NON_NULL:
result = true;
break;
- };
+ }
return result;
}
if ((glw::GLuint)-1 == test_case_index)
{
- /* Nothing to be done here */;
+ /* Nothing to be done here */
}
else if (m_test_cases.size() <= test_case_index)
{
if ((glw::GLuint)-1 == test_case_index)
{
- /* Nothing to be done here */;
+ /* Nothing to be done here */
}
else if (m_test_cases.size() <= test_case_index)
{
if ((glw::GLuint)-1 == test_case_index)
{
- /* Nothing to be done here */;
+ /* Nothing to be done here */
}
else if (m_test_cases.size() <= test_case_index)
{
if ((glw::GLuint)-1 == test_case_index)
{
- /* Nothing to be done here */;
+ /* Nothing to be done here */
}
else if (m_test_cases.size() <= test_case_index)
{
if ((glw::GLuint)-1 == test_case_index)
{
- /* Nothing to be done here */;
+ /* Nothing to be done here */
}
else if (m_test_cases.size() <= test_case_index)
{
if ((glw::GLuint)-1 == test_case_index)
{
- /* Nothing to be done here */;
+ /* Nothing to be done here */
}
else if (m_test_cases.size() <= test_case_index)
{
default:
TCU_FAIL("Invalid enum");
break;
- };
+ }
out_source.m_parts[0].m_code = shader_template;
public:
SupportedTextureType(glw::GLenum type, const std::string& shaderTexcoordType,
const std::string& shaderSamplerType);
- virtual ~SupportedTextureType(){};
+ virtual ~SupportedTextureType(){}
inline glw::GLenum getType() const
{
" gl_Position = vec4(0, 0, 0, 1); \n"
" d = v_in_0; \n"
"}";
- };
+ }
virtual std::string GeometryShader()
{
namespace tcu
{
class WaiverUtil;
-};
+}
namespace es2cts
{
deInt32 partWidth = de::max(width >> levelIndex, 1);
deInt32 partHeight = de::max(height >> levelIndex, 1);
deInt32 partDepth = de::max(depth >> levelIndex, 1);
- ;
tcu::CompressedTexture dataPart(format, partWidth, partHeight, partDepth);
const int dataSize = dataPart.getDataSize();
attachment_name_map[GL_TEXTURE_2D_ARRAY] = "texture_array";
attachment_name_map[GL_TEXTURE_3D] = "texture3d";
attachment_name_map[GL_RENDERBUFFER] = "renderbuffer";
- };
+ }
m_name = attachment_name_map[m_source_attachment_type] + "_" + attachment_name_map[m_destination_attachment_type];
}
unsigned int* result_traveller32 = (unsigned int*)result_traveller;
*result_traveller32 = channels[0]->unsigned_integer_data;
- ;
result_traveller += 4;
}
else
namespace tcu
{
class WaiverUtil;
-};
+}
namespace es3cts
{
* @param SOURCE Tested shader source
**/
#define DEFAULT_MAIN_ENDING(TYPE, SOURCE) \
- { \
+ do { \
/* Apply stage specific stuff */ \
switch (TYPE) \
{ \
\
/* End main function */ \
SOURCE += shader_end; \
- }
+ } while (0)
/** Macro executes positive test selected on USE_ALL_SHADER_STAGES
*
* @param DELETE Selects if program should be deleted afterwards
**/
#define EXECUTE_POSITIVE_TEST(TYPE, SOURCE, DELETE, GPU5) \
- { \
+ do { \
const std::string* cs = &empty_string; \
const std::string* vs = &default_vertex_shader_source; \
const std::string* tcs = &default_tc_shader_source; \
{ \
this->execute_positive_test(*vs, *fs, DELETE, GPU5); \
} \
- }
+ } while (0)
/** Macro executes either positive or negative test
*
* @param TYPE Tested shader stage
* @param SOURCE Tested shader source
**/
-#define EXECUTE_SHADER_TEST(S, TYPE, SOURCE) \
- if (S) \
- { \
- EXECUTE_POSITIVE_TEST(TYPE, SOURCE, true, false); \
- } \
- else \
- { \
- this->execute_negative_test(TYPE, SOURCE); \
- }
+#define EXECUTE_SHADER_TEST(S, TYPE, SOURCE) \
+ do { \
+ if (S) \
+ { \
+ EXECUTE_POSITIVE_TEST(TYPE, SOURCE, true, false); \
+ } \
+ else \
+ { \
+ this->execute_negative_test(TYPE, SOURCE); \
+ } \
+ } while (0)
/** Test case constructor.
*
default:
TCU_FAIL("Invalid enum");
break;
- };
+ }
/* Prepare valid source */
valid_shader_source += varying_definition;
default:
TCU_FAIL("Invalid enum");
break;
- };
+ }
if (API::USE_ALL_SHADER_STAGES)
{
namespace tcu
{
class WaiverUtil;
-};
+}
namespace esextcts
{
protected:
/* Protected methods */
GeometryShaderOutput(Context& context, const ExtParameters& extParams, const char* name, const char* description);
- virtual ~GeometryShaderOutput(){};
+ virtual ~GeometryShaderOutput(){}
/* Protected variables */
static const char* const m_fragment_shader_code_white_color;
/* Public methods */
GeometryShaderDuplicateOutputLayoutQualifierTest(Context& context, const ExtParameters& extParams, const char* name,
const char* description);
- virtual ~GeometryShaderDuplicateOutputLayoutQualifierTest(){};
+ virtual ~GeometryShaderDuplicateOutputLayoutQualifierTest(){}
virtual IterateResult iterate(void);
/* Public methods */
GeometryShaderDuplicateMaxVerticesLayoutQualifierTest(Context& context, const ExtParameters& extParams,
const char* name, const char* description);
- virtual ~GeometryShaderDuplicateMaxVerticesLayoutQualifierTest(){};
+ virtual ~GeometryShaderDuplicateMaxVerticesLayoutQualifierTest(){}
virtual IterateResult iterate(void);
/* Protected methods */
GeometryShaderOutputRenderingBase(Context& context, const ExtParameters& extParams, const char* name,
const char* description, const char* geometry_shader_code);
- virtual ~GeometryShaderOutputRenderingBase(){};
+ virtual ~GeometryShaderOutputRenderingBase(){}
void initTest(void);
/* Public methods */
GeometryShaderIfVertexEmitIsDoneAtEndTest(Context& context, const ExtParameters& extParams, const char* name,
const char* description);
- virtual ~GeometryShaderIfVertexEmitIsDoneAtEndTest(){};
+ virtual ~GeometryShaderIfVertexEmitIsDoneAtEndTest(){}
virtual bool verifyResult(const unsigned char* result_image, unsigned int width, unsigned int height,
unsigned int pixel_size) const;
/* Public methods */
GeometryShaderMissingEndPrimitiveCallTest(Context& context, const ExtParameters& extParams, const char* name,
const char* description);
- virtual ~GeometryShaderMissingEndPrimitiveCallTest(){};
+ virtual ~GeometryShaderMissingEndPrimitiveCallTest(){}
virtual bool verifyResult(const unsigned char* result_image, unsigned int width, unsigned int height,
unsigned int pixel_size) const;
/* Public methods */
GeometryShaderMissingEndPrimitiveCallForSinglePrimitiveTest(Context& context, const ExtParameters& extParams,
const char* name, const char* description);
- virtual ~GeometryShaderMissingEndPrimitiveCallForSinglePrimitiveTest(){};
+ virtual ~GeometryShaderMissingEndPrimitiveCallForSinglePrimitiveTest(){}
virtual IterateResult iterate(void);
wrap_matrix[1] = 1;
}
break;
- };
+ }
/* Apply integral part of texture coordinates to wrap_matrix */
for (unsigned int i = 0; i < m_n_components_per_varying; ++i)
default:
throw tcu::TestError("Unsupported sized internal format. Should never happen!", "", __FILE__, __LINE__);
break;
- };
+ }
GLU_EXPECT_NO_ERROR(gl.getError(), "Error setting border color parameter!");
/* Set sampler's GL_TEXTURE_WRAP_* parameters values to GL_CLAMP_TO_BORDER_EXT */
{
TCU_FAIL("Framebuffer incomplete, status not recognized");
}
- };
+ }
} /* if (GL_FRAMEBUFFER_COMPLETE != framebuffer_status) */
}
{
TCU_FAIL("Framebuffer incomplete, status not recognized");
}
- }; /* switch (framebuffer_status) */
+ } /* switch (framebuffer_status) */
} /* if (GL_FRAMEBUFFER_COMPLETE != framebuffer_status) */
}
vectorSet4(data, 7, middle, bottom, negative, layer);
vectorSet4(data, 8, right, bottom, negative, layer);
break;
- };
+ }
vectorNormalize<3, 4>(data, 0);
vectorNormalize<3, 4>(data, 1);
vectorSet4(data, 7, middle, bottom, negative, layer);
vectorSet4(data, 8, right, bottom, negative, layer);
break;
- };
+ }
vectorNormalize<3, 4>(data, 0);
vectorNormalize<3, 4>(data, 1);
out_attribute_definitions = 0;
out_n_attributes = 0;
break;
- };
+ }
}
/** Get attributes specific for sampling function
out_attribute_definitions = textureGather_attributes;
out_n_attributes = n_textureGather_attributes;
break;
- };
+ }
}
/** Get information about color type for type of sampler
out_n_components = 1;
out_is_shadow = false;
break;
- };
+ }
}
/** Get information about color type for type of sampler
out_image_type = image_uint;
out_image_layout = "r32ui";
break;
- };
+ }
}
/** Prepare code for passthrough fragment shader
/* imageStore(image, image_coord, color);*/
stream << compute_shader_color;
break;
- };
+ }
stream << ");\n";
case TextureGather:
return &m_programs_for_textureGather;
break;
- };
+ }
return 0;
}
{
TCU_FAIL("Framebuffer incomplete, status not recognized");
}
- }; /* switch (framebuffer_status) */
+ } /* switch (framebuffer_status) */
} /* if (GL_FRAMEBUFFER_COMPLETE != framebuffer_status) */
}
static const VkAccessFlagBits2KHR VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000ULL;
static const VkAccessFlagBits2KHR VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI = 0x8000000000ULL;
-VK_DEFINE_PLATFORM_TYPE(XlibDisplayPtr, void*);
-VK_DEFINE_PLATFORM_TYPE(XlibWindow, uintptr_t);
-VK_DEFINE_PLATFORM_TYPE(XlibVisualID, uint32_t);
-VK_DEFINE_PLATFORM_TYPE(XcbConnectionPtr, void*);
-VK_DEFINE_PLATFORM_TYPE(XcbWindow, uintptr_t);
-VK_DEFINE_PLATFORM_TYPE(XcbVisualid, uint32_t);
-VK_DEFINE_PLATFORM_TYPE(WaylandDisplayPtr, void*);
-VK_DEFINE_PLATFORM_TYPE(WaylandSurfacePtr, void*);
-VK_DEFINE_PLATFORM_TYPE(MirConnectionPtr, void*);
-VK_DEFINE_PLATFORM_TYPE(MirSurfacePtr, void*);
-VK_DEFINE_PLATFORM_TYPE(AndroidNativeWindowPtr, void*);
-VK_DEFINE_PLATFORM_TYPE(Win32InstanceHandle, void*);
-VK_DEFINE_PLATFORM_TYPE(Win32WindowHandle, void*);
-VK_DEFINE_PLATFORM_TYPE(Win32Handle, void*);
-VK_DEFINE_PLATFORM_TYPE(Win32SecurityAttributesPtr, const void*);
-VK_DEFINE_PLATFORM_TYPE(AndroidHardwareBufferPtr, void*);
-VK_DEFINE_PLATFORM_TYPE(Win32MonitorHandle, void*);
-VK_DEFINE_PLATFORM_TYPE(Win32LPCWSTR, const void*);
-VK_DEFINE_PLATFORM_TYPE(RROutput, void*);
-VK_DEFINE_PLATFORM_TYPE(zx_handle_t, int32_t);
-VK_DEFINE_PLATFORM_TYPE(GgpFrameToken, int32_t);
-VK_DEFINE_PLATFORM_TYPE(GgpStreamDescriptor, int32_t);
-VK_DEFINE_PLATFORM_TYPE(CAMetalLayer, void*);
+VK_DEFINE_PLATFORM_TYPE(XlibDisplayPtr, void*)
+VK_DEFINE_PLATFORM_TYPE(XlibWindow, uintptr_t)
+VK_DEFINE_PLATFORM_TYPE(XlibVisualID, uint32_t)
+VK_DEFINE_PLATFORM_TYPE(XcbConnectionPtr, void*)
+VK_DEFINE_PLATFORM_TYPE(XcbWindow, uintptr_t)
+VK_DEFINE_PLATFORM_TYPE(XcbVisualid, uint32_t)
+VK_DEFINE_PLATFORM_TYPE(WaylandDisplayPtr, void*)
+VK_DEFINE_PLATFORM_TYPE(WaylandSurfacePtr, void*)
+VK_DEFINE_PLATFORM_TYPE(MirConnectionPtr, void*)
+VK_DEFINE_PLATFORM_TYPE(MirSurfacePtr, void*)
+VK_DEFINE_PLATFORM_TYPE(AndroidNativeWindowPtr, void*)
+VK_DEFINE_PLATFORM_TYPE(Win32InstanceHandle, void*)
+VK_DEFINE_PLATFORM_TYPE(Win32WindowHandle, void*)
+VK_DEFINE_PLATFORM_TYPE(Win32Handle, void*)
+VK_DEFINE_PLATFORM_TYPE(Win32SecurityAttributesPtr, const void*)
+VK_DEFINE_PLATFORM_TYPE(AndroidHardwareBufferPtr, void*)
+VK_DEFINE_PLATFORM_TYPE(Win32MonitorHandle, void*)
+VK_DEFINE_PLATFORM_TYPE(Win32LPCWSTR, const void*)
+VK_DEFINE_PLATFORM_TYPE(RROutput, void*)
+VK_DEFINE_PLATFORM_TYPE(zx_handle_t, int32_t)
+VK_DEFINE_PLATFORM_TYPE(GgpFrameToken, int32_t)
+VK_DEFINE_PLATFORM_TYPE(GgpStreamDescriptor, int32_t)
+VK_DEFINE_PLATFORM_TYPE(CAMetalLayer, void*)
#define VK_KHR_SURFACE_SPEC_VERSION 25
#define VK_KHR_SWAPCHAIN_SPEC_VERSION 70
#define VK_KHR_DISPLAY_SPEC_VERSION 23
struct initVulkanStructure
{
- initVulkanStructure (void* pNext = DE_NULL) : m_next(pNext) {};
+ initVulkanStructure (void* pNext = DE_NULL) : m_next(pNext) {}
template<class StructType>
operator StructType()
struct initVulkanStructureConst
{
- initVulkanStructureConst (const void* pNext = DE_NULL) : m_next(pNext) {};
+ initVulkanStructureConst (const void* pNext = DE_NULL) : m_next(pNext) {}
template<class StructType>
operator const StructType()
struct getPhysicalDeviceExtensionProperties
{
- getPhysicalDeviceExtensionProperties (const InstanceInterface& vki, VkPhysicalDevice physicalDevice) : m_vki(vki), m_physicalDevice(physicalDevice) {};
+ getPhysicalDeviceExtensionProperties (const InstanceInterface& vki, VkPhysicalDevice physicalDevice) : m_vki(vki), m_physicalDevice(physicalDevice) {}
template<class ExtensionProperties>
operator ExtensionProperties ()
case VK_INDEX_TYPE_UINT32: return de::SharedPtr<RaytracedGeometryBase>(buildRaytracedGeometry<tcu::Vec2, deUint32>(builderParams));
case VK_INDEX_TYPE_NONE_KHR: return de::SharedPtr<RaytracedGeometryBase>(buildRaytracedGeometry<tcu::Vec2, EmptyIndex>(builderParams));
default: TCU_THROW(InternalError, "Wrong index type");
- };
+ }
case VK_FORMAT_R32G32B32_SFLOAT:
switch (indexType)
{
case VK_INDEX_TYPE_UINT32: return de::SharedPtr<RaytracedGeometryBase>(buildRaytracedGeometry<tcu::Vec3, deUint32>(builderParams));
case VK_INDEX_TYPE_NONE_KHR: return de::SharedPtr<RaytracedGeometryBase>(buildRaytracedGeometry<tcu::Vec3, EmptyIndex>(builderParams));
default: TCU_THROW(InternalError, "Wrong index type");
- };
+ }
case VK_FORMAT_R32G32B32A32_SFLOAT:
switch (indexType)
{
case VK_INDEX_TYPE_UINT32: return de::SharedPtr<RaytracedGeometryBase>(buildRaytracedGeometry<tcu::Vec4, deUint32>(builderParams));
case VK_INDEX_TYPE_NONE_KHR: return de::SharedPtr<RaytracedGeometryBase>(buildRaytracedGeometry<tcu::Vec4, EmptyIndex>(builderParams));
default: TCU_THROW(InternalError, "Wrong index type");
- };
+ }
case VK_FORMAT_R16G16_SFLOAT:
switch (indexType)
{
case VK_INDEX_TYPE_UINT32: return de::SharedPtr<RaytracedGeometryBase>(buildRaytracedGeometry<Vec2_16, deUint32>(builderParams));
case VK_INDEX_TYPE_NONE_KHR: return de::SharedPtr<RaytracedGeometryBase>(buildRaytracedGeometry<Vec2_16, EmptyIndex>(builderParams));
default: TCU_THROW(InternalError, "Wrong index type");
- };
+ }
case VK_FORMAT_R16G16B16_SFLOAT:
switch (indexType)
{
case VK_INDEX_TYPE_UINT32: return de::SharedPtr<RaytracedGeometryBase>(buildRaytracedGeometry<Vec3_16, deUint32>(builderParams));
case VK_INDEX_TYPE_NONE_KHR: return de::SharedPtr<RaytracedGeometryBase>(buildRaytracedGeometry<Vec3_16, EmptyIndex>(builderParams));
default: TCU_THROW(InternalError, "Wrong index type");
- };
+ }
case VK_FORMAT_R16G16B16A16_SFLOAT:
switch (indexType)
{
case VK_INDEX_TYPE_UINT32: return de::SharedPtr<RaytracedGeometryBase>(buildRaytracedGeometry<Vec4_16, deUint32>(builderParams));
case VK_INDEX_TYPE_NONE_KHR: return de::SharedPtr<RaytracedGeometryBase>(buildRaytracedGeometry<Vec4_16, EmptyIndex>(builderParams));
default: TCU_THROW(InternalError, "Wrong index type");
- };
+ }
case VK_FORMAT_R16G16_SNORM:
switch (indexType)
{
case VK_INDEX_TYPE_UINT32: return de::SharedPtr<RaytracedGeometryBase>(buildRaytracedGeometry<Vec2_16SNorm, deUint32>(builderParams));
case VK_INDEX_TYPE_NONE_KHR: return de::SharedPtr<RaytracedGeometryBase>(buildRaytracedGeometry<Vec2_16SNorm, EmptyIndex>(builderParams));
default: TCU_THROW(InternalError, "Wrong index type");
- };
+ }
case VK_FORMAT_R16G16B16_SNORM:
switch (indexType)
{
case VK_INDEX_TYPE_UINT32: return de::SharedPtr<RaytracedGeometryBase>(buildRaytracedGeometry<Vec3_16SNorm, deUint32>(builderParams));
case VK_INDEX_TYPE_NONE_KHR: return de::SharedPtr<RaytracedGeometryBase>(buildRaytracedGeometry<Vec3_16SNorm, EmptyIndex>(builderParams));
default: TCU_THROW(InternalError, "Wrong index type");
- };
+ }
case VK_FORMAT_R16G16B16A16_SNORM:
switch (indexType)
{
case VK_INDEX_TYPE_UINT32: return de::SharedPtr<RaytracedGeometryBase>(buildRaytracedGeometry<Vec4_16SNorm, deUint32>(builderParams));
case VK_INDEX_TYPE_NONE_KHR: return de::SharedPtr<RaytracedGeometryBase>(buildRaytracedGeometry<Vec4_16SNorm, EmptyIndex>(builderParams));
default: TCU_THROW(InternalError, "Wrong index type");
- };
+ }
case VK_FORMAT_R64G64_SFLOAT:
switch (indexType)
{
case VK_INDEX_TYPE_UINT32: return de::SharedPtr<RaytracedGeometryBase>(buildRaytracedGeometry<tcu::DVec2, deUint32>(builderParams));
case VK_INDEX_TYPE_NONE_KHR: return de::SharedPtr<RaytracedGeometryBase>(buildRaytracedGeometry<tcu::DVec2, EmptyIndex>(builderParams));
default: TCU_THROW(InternalError, "Wrong index type");
- };
+ }
case VK_FORMAT_R64G64B64_SFLOAT:
switch (indexType)
{
case VK_INDEX_TYPE_UINT32: return de::SharedPtr<RaytracedGeometryBase>(buildRaytracedGeometry<tcu::DVec3, deUint32>(builderParams));
case VK_INDEX_TYPE_NONE_KHR: return de::SharedPtr<RaytracedGeometryBase>(buildRaytracedGeometry<tcu::DVec3, EmptyIndex>(builderParams));
default: TCU_THROW(InternalError, "Wrong index type");
- };
+ }
case VK_FORMAT_R64G64B64A64_SFLOAT:
switch (indexType)
{
case VK_INDEX_TYPE_UINT32: return de::SharedPtr<RaytracedGeometryBase>(buildRaytracedGeometry<tcu::DVec4, deUint32>(builderParams));
case VK_INDEX_TYPE_NONE_KHR: return de::SharedPtr<RaytracedGeometryBase>(buildRaytracedGeometry<tcu::DVec4, EmptyIndex>(builderParams));
default: TCU_THROW(InternalError, "Wrong index type");
- };
+ }
case VK_FORMAT_R8G8_SNORM:
switch (indexType)
{
case VK_INDEX_TYPE_UINT32: return de::SharedPtr<RaytracedGeometryBase>(buildRaytracedGeometry<Vec2_8SNorm, deUint32>(builderParams));
case VK_INDEX_TYPE_NONE_KHR: return de::SharedPtr<RaytracedGeometryBase>(buildRaytracedGeometry<Vec2_8SNorm, EmptyIndex>(builderParams));
default: TCU_THROW(InternalError, "Wrong index type");
- };
+ }
case VK_FORMAT_R8G8B8_SNORM:
switch (indexType)
{
case VK_INDEX_TYPE_UINT32: return de::SharedPtr<RaytracedGeometryBase>(buildRaytracedGeometry<Vec3_8SNorm, deUint32>(builderParams));
case VK_INDEX_TYPE_NONE_KHR: return de::SharedPtr<RaytracedGeometryBase>(buildRaytracedGeometry<Vec3_8SNorm, EmptyIndex>(builderParams));
default: TCU_THROW(InternalError, "Wrong index type");
- };
+ }
case VK_FORMAT_R8G8B8A8_SNORM:
switch (indexType)
{
case VK_INDEX_TYPE_UINT32: return de::SharedPtr<RaytracedGeometryBase>(buildRaytracedGeometry<Vec4_8SNorm, deUint32>(builderParams));
case VK_INDEX_TYPE_NONE_KHR: return de::SharedPtr<RaytracedGeometryBase>(buildRaytracedGeometry<Vec4_8SNorm, EmptyIndex>(builderParams));
default: TCU_THROW(InternalError, "Wrong index type");
- };
+ }
default:
TCU_THROW(InternalError, "Wrong vertex format");
- };
+ }
}
const VkPhysicalDevice physicalDevice);
virtual ~RayTracingPropertiesKHR ();
- virtual deUint32 getShaderGroupHandleSize (void) { return m_rayTracingPipelineProperties.shaderGroupHandleSize; };
- virtual deUint32 getMaxRecursionDepth (void) { return m_rayTracingPipelineProperties.maxRayRecursionDepth; };
- virtual deUint32 getMaxShaderGroupStride (void) { return m_rayTracingPipelineProperties.maxShaderGroupStride; };
- virtual deUint32 getShaderGroupBaseAlignment (void) { return m_rayTracingPipelineProperties.shaderGroupBaseAlignment; };
- virtual deUint64 getMaxGeometryCount (void) { return m_accelerationStructureProperties.maxGeometryCount; };
- virtual deUint64 getMaxInstanceCount (void) { return m_accelerationStructureProperties.maxInstanceCount; };
- virtual deUint64 getMaxPrimitiveCount (void) { return m_accelerationStructureProperties.maxPrimitiveCount; };
- virtual deUint32 getMaxDescriptorSetAccelerationStructures (void) { return m_accelerationStructureProperties.maxDescriptorSetAccelerationStructures; };
- deUint32 getMaxRayDispatchInvocationCount (void) { return m_rayTracingPipelineProperties.maxRayDispatchInvocationCount; };
- deUint32 getMaxRayHitAttributeSize (void) { return m_rayTracingPipelineProperties.maxRayHitAttributeSize; };
+ virtual deUint32 getShaderGroupHandleSize (void) { return m_rayTracingPipelineProperties.shaderGroupHandleSize; }
+ virtual deUint32 getMaxRecursionDepth (void) { return m_rayTracingPipelineProperties.maxRayRecursionDepth; }
+ virtual deUint32 getMaxShaderGroupStride (void) { return m_rayTracingPipelineProperties.maxShaderGroupStride; }
+ virtual deUint32 getShaderGroupBaseAlignment (void) { return m_rayTracingPipelineProperties.shaderGroupBaseAlignment; }
+ virtual deUint64 getMaxGeometryCount (void) { return m_accelerationStructureProperties.maxGeometryCount; }
+ virtual deUint64 getMaxInstanceCount (void) { return m_accelerationStructureProperties.maxInstanceCount; }
+ virtual deUint64 getMaxPrimitiveCount (void) { return m_accelerationStructureProperties.maxPrimitiveCount; }
+ virtual deUint32 getMaxDescriptorSetAccelerationStructures (void) { return m_accelerationStructureProperties.maxDescriptorSetAccelerationStructures; }
+ deUint32 getMaxRayDispatchInvocationCount (void) { return m_rayTracingPipelineProperties.maxRayDispatchInvocationCount; }
+ deUint32 getMaxRayHitAttributeSize (void) { return m_rayTracingPipelineProperties.maxRayHitAttributeSize; }
protected:
VkPhysicalDeviceAccelerationStructurePropertiesKHR m_accelerationStructureProperties;
class RayTracingProperties
{
protected:
- RayTracingProperties () {};
+ RayTracingProperties () {}
public:
RayTracingProperties (const InstanceInterface& vki,
- const VkPhysicalDevice physicalDevice) { DE_UNREF(vki); DE_UNREF(physicalDevice); };
- virtual ~RayTracingProperties () {};
+ const VkPhysicalDevice physicalDevice) { DE_UNREF(vki); DE_UNREF(physicalDevice); }
+ virtual ~RayTracingProperties () {}
virtual deUint32 getShaderGroupHandleSize (void) = DE_NULL;
virtual deUint32 getMaxRecursionDepth (void) = DE_NULL;
{
buildOptions = buildOptions_;
return *this;
- };
+ }
SpirVAsmBuildOptions buildOptions;
std::string source;
// record resetting event
vk.cmdResetEvent(*primCmdBuf, *event,stageMask);
- };
+ }
}
endCommandBuffer(vk, *primCmdBuf);
// record resetting event
vk.cmdResetEvent(*primCmdBuf, *event,stageMask);
- };
+ }
}
// end recording of secondary buffers
// create semaphores for use in this test
semaphoreArray[idx] = createSemaphore(vk, vkDevice);
semaphores[idx] = semaphoreArray[idx].get();
- };
+ }
{
// create submit info for buffer - signal semaphores
}
// end recording of secondary buffers
endCommandBuffer(vk, cmdBuffers[ndx]);
- };
+ }
// record primary command buffer one
VK_CHECK(vk.beginCommandBuffer(*primCmdBufOne, &primCmdBufBeginInfo));
group->addChild(new CopyImageToImageMipmapTestCase(testCtx, testName.str(), "copy 2d array mipmap image to 2d array mipmap image all at once", paramsArrayToArray));
}
}
-};
+}
void addImageToImageTests (tcu::TestCaseGroup* group, AllocationKind allocationKind, ExtensionUse extensionUse)
{
class IObjectAllocator
{
public:
- IObjectAllocator () {};
- virtual ~IObjectAllocator () {};
+ IObjectAllocator () {}
+ virtual ~IObjectAllocator () {}
virtual void allocate (Context& context) = 0;
virtual void deallocate (Context& context) = 0;
virtual size_t getSize (Context& context) = 0;
template<> inline bool isNullHandleOnAllocationFailure<VkDescriptorSet> (Context& context) { return hasDeviceExtension(context, "VK_KHR_maintenance1"); }
template<> inline bool isNullHandleOnAllocationFailure<VkPipeline> (Context&) { return true; }
-template<typename T> inline bool isPooledObject (void) { return false; };
-template<> inline bool isPooledObject<VkCommandBuffer> (void) { return true; };
-template<> inline bool isPooledObject<VkDescriptorSet> (void) { return true; };
+template<typename T> inline bool isPooledObject (void) { return false; }
+template<> inline bool isPooledObject<VkCommandBuffer> (void) { return true; }
+template<> inline bool isPooledObject<VkDescriptorSet> (void) { return true; }
template<typename Object>
tcu::TestStatus allocCallbackFailMultipleObjectsTest (Context& context, typename Object::Parameters params)
public:
BindingAcceleratioStructureTestInstance (Context& context,
const TestParams& testParams);
- virtual ~BindingAcceleratioStructureTestInstance () {};
+ virtual ~BindingAcceleratioStructureTestInstance () {}
virtual tcu::TestStatus iterate (void);
protected:
BindingAcceleratioStructureGraphicsTestInstance (Context& context,
const TestParams& testParams);
- virtual ~BindingAcceleratioStructureGraphicsTestInstance () {};
+ virtual ~BindingAcceleratioStructureGraphicsTestInstance () {}
protected:
virtual void initPipeline (void) override;
void initVertexBuffer (void);
Move<VkPipeline> makeGraphicsPipeline (void);
- virtual deUint32 getExtraAccelerationDescriptorCount (void) override { return 0; };
+ virtual deUint32 getExtraAccelerationDescriptorCount (void) override { return 0; }
virtual VkShaderStageFlags getShaderStageFlags (void) override { return VK_SHADER_STAGE_ALL_GRAPHICS; }
- virtual VkPipelineBindPoint getPipelineBindPoint (void) override { return VK_PIPELINE_BIND_POINT_GRAPHICS; };
+ virtual VkPipelineBindPoint getPipelineBindPoint (void) override { return VK_PIPELINE_BIND_POINT_GRAPHICS; }
VkFormat m_framebufferFormat;
Move<VkImage> m_framebufferImage;
BindingAcceleratioStructureComputeTestInstance (Context& context,
const TestParams& testParams);
- virtual ~BindingAcceleratioStructureComputeTestInstance () {};
+ virtual ~BindingAcceleratioStructureComputeTestInstance () {}
static void checkSupport (Context& context,
const TestParams& testParams);
virtual void initPipeline (void) override;
virtual void fillCommandBuffer (VkCommandBuffer commandBuffer) override;
- virtual deUint32 getExtraAccelerationDescriptorCount (void) override { return 0; };
+ virtual deUint32 getExtraAccelerationDescriptorCount (void) override { return 0; }
virtual VkShaderStageFlags getShaderStageFlags (void) override { return VK_SHADER_STAGE_COMPUTE_BIT; }
- virtual VkPipelineBindPoint getPipelineBindPoint (void) override { return VK_PIPELINE_BIND_POINT_COMPUTE; };
+ virtual VkPipelineBindPoint getPipelineBindPoint (void) override { return VK_PIPELINE_BIND_POINT_COMPUTE; }
Move<VkShaderModule> m_shaderModule;
};
public:
BindingAcceleratioStructureRayTracingTestInstance (Context& context,
const TestParams& testParams);
- virtual ~BindingAcceleratioStructureRayTracingTestInstance () {};
+ virtual ~BindingAcceleratioStructureRayTracingTestInstance () {}
static void checkSupport (Context& context,
const TestParams& testParams);
de::MovePtr<RayTracingPipeline>& rayTracingPipeline,
const deUint32 group);
- virtual deUint32 getExtraAccelerationDescriptorCount (void) override { return 1; };
+ virtual deUint32 getExtraAccelerationDescriptorCount (void) override { return 1; }
virtual VkShaderStageFlags getShaderStageFlags (void) override { return ALL_RAY_TRACING_STAGES; }
- virtual VkPipelineBindPoint getPipelineBindPoint (void) override { return VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR; };
+ virtual VkPipelineBindPoint getPipelineBindPoint (void) override { return VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR; }
deUint32 m_shaders;
deUint32 m_raygenShaderGroup;
public:
BindingAcceleratioStructureRayTracingRayTracingTestInstance (Context& context,
const TestParams& testParams);
- virtual ~BindingAcceleratioStructureRayTracingRayTracingTestInstance () {};
+ virtual ~BindingAcceleratioStructureRayTracingRayTracingTestInstance () {}
static void checkSupport (Context& context,
const TestParams& testParams);
const deUint32 group,
const deUint32 groupCount = 1);
- virtual deUint32 getExtraAccelerationDescriptorCount (void) override { return 1; };
+ virtual deUint32 getExtraAccelerationDescriptorCount (void) override { return 1; }
virtual VkShaderStageFlags getShaderStageFlags (void) override { return ALL_RAY_TRACING_STAGES; }
- virtual VkPipelineBindPoint getPipelineBindPoint (void) override { return VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR; };
+ virtual VkPipelineBindPoint getPipelineBindPoint (void) override { return VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR; }
deUint32 m_shaders;
deUint32 m_raygenShaderGroup;
deUint32 numDescriptorSets,
const vk::VkDescriptorSetLayout* descriptorSetLayouts);
- inline vk::VkPipeline getPipeline (void) const { return *m_pipeline; };
- inline vk::VkPipelineLayout getPipelineLayout (void) const { return *m_pipelineLayout; };
+ inline vk::VkPipeline getPipeline (void) const { return *m_pipeline; }
+ inline vk::VkPipelineLayout getPipelineLayout (void) const { return *m_pipelineLayout; }
private:
static vk::Move<vk::VkPipelineLayout> createPipelineLayout (const vk::DeviceInterface& vki,
default:
DE_FATAL("Impossible");
- };
+ }
return builder.build(m_vki, m_device, extraFlags);
}
default:
DE_FATAL("Impossible");
- };
+ }
return builder.build(m_vki, m_device, extraFlags);
}
default:
DE_FATAL("Impossible");
- };
+ }
return builder.build(m_vki, m_device, extraFlags);
}
default:
DE_FATAL("Impossible");
- };
+ }
return builder.build(m_vki, m_device, extraFlags);
}
TestInstance* createInstance (Context& context) const
{
return new ComputeBuiltinVarInstance(context, m_subCases, m_varType, this);
- };
+ }
virtual void initPrograms (SourceCollections& programCollection) const;
virtual UVec3 computeReference (const UVec3& numWorkGroups, const UVec3& workGroupSize, const UVec3& workGroupID, const UVec3& localInvocationID) const = 0;
s << type << "(" << std::to_string(values[i]) << ")";
if (i != values.size() - 1)
s << ", ";
- };
+ }
s << ")";
return s.str();
}
initialize();
m_secondaryCmdBuffer = vk::allocateCommandBuffer(m_vk, m_context.getDevice(), *m_cmdPool, vk::VK_COMMAND_BUFFER_LEVEL_SECONDARY);
-};
+}
tcu::TestStatus ConditionalClearAttachmentTest::iterate (void)
{
}
return tcu::TestStatus(res, qpGetTestResultName(res));
-};
+}
} // anonymous
, m_numCalls(testSpec.numCalls)
, m_conditionalData(testSpec.conditionalData)
{
-};
+}
void ConditionalDispatchTestInstance::recordDispatch (const vk::DeviceInterface& vk,
vk::VkCommandBuffer cmdBuffer,
}
return tcu::TestStatus(res, qpGetTestResultName(res));
-};
+}
} // anonymous
initialize();
m_secondaryCmdBuffer = vk::allocateCommandBuffer(m_vk, m_context.getDevice(), *m_cmdPool, vk::VK_COMMAND_BUFFER_LEVEL_SECONDARY);
-};
+}
void ConditionalDraw::createAndBindIndexBuffer (vk::VkCommandBuffer cmdBuffer)
{
}
return tcu::TestStatus(res, qpGetTestResultName(res));
-};
+}
} // anonymous
{
imageExtent.width *= 2;
imageExtent.height *= 2;
- };
+ }
createImages(variables.descriptorsImages, variables.descriptorsBufferInfos, variables.descriptorsBuffer,
VK_BUFFER_USAGE_TRANSFER_SRC_BIT, imageExtent, m_colorFormat, VK_IMAGE_LAYOUT_UNDEFINED, 1, m_testParams.usesMipMaps);
case VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT:
readAccess = static_cast<VkAccessFlagBits>(VK_ACCESS_UNIFORM_READ_BIT | VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_INPUT_ATTACHMENT_READ_BIT);
- writeAccess = VK_ACCESS_SHADER_READ_BIT;;
+ writeAccess = VK_ACCESS_SHADER_READ_BIT;
break;
case VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT:
public:
DiscardRectanglesTestInstance (Context& context,
TestParams params);
- virtual ~DiscardRectanglesTestInstance (void) {};
+ virtual ~DiscardRectanglesTestInstance (void) {}
virtual tcu::TestStatus iterate (void);
private:
const char *name,
const char *description,
TestParams params);
- virtual ~DiscardRectanglesTestCase (void) {};
+ virtual ~DiscardRectanglesTestCase (void) {}
virtual TestInstance* createInstance (Context& context) const;
virtual void initPrograms (SourceCollections& programCollection) const;
PositionValueVertex(tcu::Vec4 pos, float val)
: position(pos)
, value(val)
- {};
+ {}
public:
tcu::Vec4 position;
float value;
vk::VkImageAspectFlagBits aspect,
void * data)
{
- DE_ASSERT(layout == vk::VK_IMAGE_LAYOUT_GENERAL || layout == vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);;
+ DE_ASSERT(layout == vk::VK_IMAGE_LAYOUT_GENERAL || layout == vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
de::SharedPtr<Buffer> stagingResource;
m_data.push_back(VertexElementData(tcu::Vec4( -1.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::blue().toVec(), -1));
initialize();
-};
+}
tcu::TestStatus DrawIndexed::iterate (void)
{
}
return tcu::TestStatus(res, qpGetTestResultName(res));
-};
+}
DrawInstancedIndexed::DrawInstancedIndexed (Context &context, TestSpec testSpec)
: DrawIndexed (context, testSpec)
: drawType(DRAWTYPE_LAST)
, testFirstInstanceNdx(false)
, testIndirectCountExt(IndirectCountType::NONE)
- {};
+ {}
DrawType drawType;
bool testFirstInstanceNdx;
VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)); // finalLayout
const ImageViewCreateInfo depthTargetViewInfo (m_depthTargetImage->object(), VK_IMAGE_VIEW_TYPE_2D, m_params.depthFormat);
- m_depthTargetView = createImageView(vk, device, &depthTargetViewInfo);;
+ m_depthTargetView = createImageView(vk, device, &depthTargetViewInfo);
attachments.push_back(*m_depthTargetView);
}
const VkAttachmentReference colorAttachmentReference = hasColor ? makeAttachmentReference(0u, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL) : AttachmentReference();
class TestCommand
{
public:
- TestCommand (void) {};
- virtual ~TestCommand (void) {};
+ TestCommand (void) {}
+ virtual ~TestCommand (void) {}
virtual vector<PositionColorVertex> getVertices (deUint32 offset) { DE_UNREF(offset); return vector<PositionColorVertex>(); }
virtual void addCommands (const DeviceInterface& vk, VkCommandBuffer cmdBuffer) = 0;
struct TestParams
{
- TestParams() : framebufferSize({WIDTH,HEIGHT}) {};
+ TestParams() : framebufferSize({WIDTH,HEIGHT}) {}
bool dynamicScissor;
vector<VkRect2D> staticScissors;
if (fsr.sampleCounts & highestSampleCount)
break;
highestSampleCount >>= 1;
- };
+ }
// Check that the highest sample count in sampleCounts is less than or equal to maxFragmentShadingRateRasterizationSamples limit
if (highestSampleCount > static_cast<deUint32>(fragmentShadingRateProperties.maxFragmentShadingRateRasterizationSamples))
const vk::VkDevice /*device*/,
vk::Allocator& /*memAlloc*/,
const vk::VkCommandBuffer& /*cmdBuffer*/,
- const vk::VkPipelineLayout& /*pipelineLayout*/){};
+ const vk::VkPipelineLayout& /*pipelineLayout*/){}
virtual void drawCommand (const vk::VkCommandBuffer& cmdBuffer);
const vk::VkPrimitiveTopology m_primitiveType;
default:
DE_ASSERT(0);
return false;
- };
+ }
}
std::string getLayerDescription (const VkImageViewType viewType, const int layer)
DE_ASSERT(params.image.viewType == VK_IMAGE_VIEW_TYPE_3D);
imageViewString = "image3D";
break;
- };
+ }
std::ostringstream src;
src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
default:
src << " ivec3 coord = ivec3(int(gl_FragCoord.x), int(gl_FragCoord.y), gl_Layer);\n";
break;
- };
+ }
src << " vec4 src_color = imageLoad(storageImage, coord);\n"
<< " o_color = (vert_color + src_color) / 2.0;\n"
break;
default:
break;
- };
+ }
const VkPipelineInputAssemblyStateCreateInfo pipelineInputAssemblyStateInfo =
{
offset += getCompressedImageSizeInBytes(m_parameters.formatCompressed, mipMapSizes[mipNdx]);
}
}
- };
+ }
if (!decompressImage(*cmdBuffer, imageData, mipMapSizes))
return TestStatus::fail("Fail");
const VkFormat writeFormat,
bool relaxedPrecision);
- virtual ~ImageExtendOperandTestInstance (void) {};
+ virtual ~ImageExtendOperandTestInstance (void) {}
protected:
{
const deUint32 layerUsed = cube0LayerStart + layerNdx;
const float componentValue = float(16 * layerUsed) / 255.0f;
- const tcu::Vec4 expectedColor = tcu::Vec4(componentValue, componentValue, componentValue, 1.0f);;
+ const tcu::Vec4 expectedColor = tcu::Vec4(componentValue, componentValue, componentValue, 1.0f);
const tcu::Vec4 resultColor = readVec4(resultBufferAlloc.getHostPtr(), layerNdx);
const tcu::Vec4 delta = expectedColor - resultColor;
{
const deUint32 layerUsed = cube1LayerStart + layerNdx;
const float componentValue = float(16 * layerUsed) / 255.0f;
- const tcu::Vec4 expectedColor = tcu::Vec4(componentValue, componentValue, componentValue, 1.0f);;
+ const tcu::Vec4 expectedColor = tcu::Vec4(componentValue, componentValue, componentValue, 1.0f);
const tcu::Vec4 resultColor = readVec4(resultBufferAlloc.getHostPtr(), layerNdx + 6u);
const tcu::Vec4 delta = expectedColor - resultColor;
const tcu::UVec3& imageSize,
const tcu::TextureFormat& format);
- virtual ~MemoryQualifierInstanceBase (void) {};
+ virtual ~MemoryQualifierInstanceBase (void) {}
virtual tcu::TestStatus iterate (void);
const tcu::TextureFormat& format)
: MemoryQualifierInstanceBase(context, name, imageType, imageSize, format) {}
- virtual ~MemoryQualifierInstanceImage (void) {};
+ virtual ~MemoryQualifierInstanceImage (void) {}
virtual void prepareResources (const VkDeviceSize bufferSizeInBytes);
const tcu::TextureFormat& format)
: MemoryQualifierInstanceBase(context, name, imageType, imageSize, format) {}
- virtual ~MemoryQualifierInstanceBuffer (void) {};
+ virtual ~MemoryQualifierInstanceBuffer (void) {}
virtual void prepareResources (const VkDeviceSize bufferSizeInBytes);
currentOffset += level.size;
++levelCount;
- };
+ }
}
VkDeviceSize BufferLevels::totalSize () const
int dimension (void) const; //!< Coordinate dimension used for addressing (e.g. 3 (x,y,z) for 2d array)
int layerDimension (void) const; //!< Coordinate dimension used for addressing a single layer (e.g. 2 (x,y) for 2d array)
- int numMipmapLevels (void) const { return m_numMipmapLevels; }; //!< Number of levels of detail (mipmap texture)
+ int numMipmapLevels (void) const { return m_numMipmapLevels; } //!< Number of levels of detail (mipmap texture)
private:
void checkInvariants (void) const;
vk.getBufferMemoryRequirements(vkDevice, **targets[i], &memReqs);
- ConstDedicatedInfo dedicatedAllocationInfo = makeDedicatedAllocationInfo(**targets[i]);;
+ ConstDedicatedInfo dedicatedAllocationInfo = makeDedicatedAllocationInfo(**targets[i]);
VkMemoryPriorityAllocateInfoEXT priority = makeMemoryPriorityAllocateInfo(&dedicatedAllocationInfo, ((float)i)/((float)count));
const VkMemoryAllocateInfo memAlloc = makeMemoryAllocateInfo(memReqs, params.usePriority ? &priority : (const void *)&dedicatedAllocationInfo);
VkDeviceMemory rawMemory = DE_NULL;
const std::string getInstanceName (void) const { return m_instanceName; }
void addMember (SharedStructVar var) { m_members.push_back(var); }
- int getNumMembers (void) { return static_cast<int>(m_members.size()); };
+ int getNumMembers (void) { return static_cast<int>(m_members.size()); }
inline iterator begin (void) { return m_members.begin(); }
inline const_iterator begin (void) const { return m_members.begin(); }
class ShaderInterface
{
public:
- ShaderInterface (void) {};
- ~ShaderInterface (void) {};
+ ShaderInterface (void) {}
+ ~ShaderInterface (void) {}
SharedStruct& allocSharedObject (const std::string& name, const std::string& instanceName);
NamedStructSP allocStruct (const std::string& name);
- std::vector<NamedStructSP>& getStructs (void) { return m_structs; };
- int getNumStructs (void) { return static_cast<int>(m_structs.size()); };
+ std::vector<NamedStructSP>& getStructs (void) { return m_structs; }
+ int getNumStructs (void) { return static_cast<int>(m_structs.size()); }
int getNumSharedObjects (void) const { return static_cast<int>(m_sharedMemoryObjects.size()); }
std::vector<SharedStruct>& getSharedObjects (void) { return m_sharedMemoryObjects; }
default:
DE_ASSERT(0);
break;
- };
+ }
VkPipelineShaderStageCreateInfo pipelineShaderStage =
{
default:
DE_ASSERT(0);
break;
- };
+ }
}
targetGroup->addChild(groupViewIndex.release());
break;
default:
DE_FATAL("Unsupported Advanced Blend Overlap Mode");
- };
+ }
return p;
}
default:
DE_FATAL("Unsupported f/X/Y/Z Advanced Blend Operations Mode");
- };
+ }
return xyz;
}
default:
DE_FATAL("Unsupported f/X/Y/Z Advanced Blend Operations Mode");
- };
+ }
return f;
}
default:
DE_FATAL("Unsupported blend operation");
- };
+ }
return res;
}
desc << "unknown shader stage!";
DE_FATAL("Unknown shader Stage!");
break;
- };
+ }
return desc.str();
}
default:
DE_FATAL("Unknown Shader Stage!");
break;
- };
+ }
}
}
}
break;
default:
break;
- };
+ }
}
}
default:
DE_FATAL("Unknown Shader Stage!");
break;
- };
+ }
}
// Create pipeline layout
static constexpr VariantArray BATCH_NOCOMPILE_COMPILE_NOCOMPILE = VariantArray{NO_COMPILE, NORMAL, NO_COMPILE};
static constexpr VariantArray BATCH_RETURN_COMPILE_NOCOMPILE = VariantArray{EARLY_RETURN, NORMAL, NO_COMPILE};
- inline constexpr Iteration() : variants{}, validators{} {};
- inline constexpr Iteration(const VariantArray& v, const ValidatorArray& f) : variants{v}, validators{f} {};
+ inline constexpr Iteration() : variants{}, validators{} {}
+ inline constexpr Iteration(const VariantArray& v, const ValidatorArray& f) : variants{v}, validators{f} {}
VariantArray variants;
ValidatorArray validators;
desc << "unknown shader stage!";
DE_FATAL("Unknown shader Stage!");
break;
- };
+ }
return desc.str();
}
desc << "Unknown case";
DE_FATAL("Unknown case!");
break;
- };
+ }
return desc.str();
}
default:
DE_FATAL("Unknown Shader Stage!");
break;
- };
+ }
}
}
break;
default:
break;
- };
+ }
}
}
default:
DE_FATAL("Unknown Shader Stage!");
break;
- };
+ }
}
if (ndx == PIPELINE_CACHE_NDX_CACHED && !param->isDelayedDestroy())
{
return DE_FALSE;
default:
DE_FATAL("No depth format");
- };
+ }
return DE_FALSE;
}
return DE_FALSE;
default:
DE_FATAL("No depth format");
- };
+ }
return DE_FALSE;
}
default:
result = false;
break;
- };
+ }
return result;
}
// Create pipeline
{
const std::vector<VkViewport> viewports (1, makeViewport(m_renderSize));
- const std::vector<VkRect2D> scissors (1, makeRect2D(m_renderSize));;
+ const std::vector<VkRect2D> scissors (1, makeRect2D(m_renderSize));
const VkVertexInputBindingDescription vertexInputBindingDescription =
{
desc << "unknown shader stage!";
DE_FATAL("Unknown shader Stage!");
break;
- };
+ }
return desc.str();
}
default:
DE_FATAL("Unknown Shader Stage!");
break;
- };
+ }
}
}
default:
DE_FATAL("Unknown Shader Stage!");
break;
- };
+ }
}
<< " gl_in[1].gl_Position * gl_TessCoord.y + \n"
<< " gl_in[2].gl_Position * gl_TessCoord.z);\n"
<< "}\n";
- ;
}
break;
default:
DE_FATAL("Unsupported shader");
- };
+ }
return data;
}
<< " vec2 data[];\n"
<< "} sb_data;\n";
return str.str();
-};
+}
void addProgramsVerifyLocationGeometry (SourceCollections& programCollection, const TestParams)
{
struct SampleCoverage
{
- SampleCoverage() {};
+ SampleCoverage() {}
SampleCoverage(deUint32 min_, deUint32 max_)
- : min(min_), max(max_) {};
+ : min(min_), max(max_) {}
deUint32 min;
deUint32 max;
VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL // VkImageLayout finalLayout;
};
attachmentDescriptions.push_back(depthStencilAttachmentDescription);
- };
+ }
const VkAttachmentReference colorAttachmentReference =
{
};
imageLayoutBarriers.push_back(depthStencilImageBarrier);
dstStageMask |= VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
- };
+ }
m_cmdBuffer = allocateCommandBuffer(vk, vkDevice, *m_cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
const std::string arrayNdx = (size == 128u) ? "[7]"
: (size == 32u) ? "[1]"
: "";
- const std::string colorReadStr = getSwizzleStr(size) + " += matInst.color" + arrayNdx + ";\n";;
+ const std::string colorReadStr = getSwizzleStr(size) + " += matInst.color" + arrayNdx + ";\n";
return colorReadStr;
}
default:
DE_FATAL("unexpected descriptor type");
break;
- };
+ }
const VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCreateInfo =
{
default:
DE_FATAL("unexpected descriptor type");
break;
- };
+ }
const VkDescriptorSetLayoutBinding descriptorSetLayoutBindingOutputBuffer =
{
default:
DE_FATAL("unexpected descriptor type");
break;
- };
+ }
// Verify result
const auto bufferDataPtr = reinterpret_cast<const char*>(m_outputBufferAlloc->getHostPtr());
default:
DE_FATAL("Unexpected descriptor type");
break;
- };
+ }
}
pushDescriptorTests->addChild(graphicsTests.release());
GEN_DESC_STRING(p, stage); \
break; \
}
- STAGE_CASE(TOP_OF_PIPE);
- STAGE_CASE(DRAW_INDIRECT);
- STAGE_CASE(VERTEX_INPUT);
- STAGE_CASE(VERTEX_SHADER);
- STAGE_CASE(TESSELLATION_CONTROL_SHADER);
- STAGE_CASE(TESSELLATION_EVALUATION_SHADER);
- STAGE_CASE(GEOMETRY_SHADER);
- STAGE_CASE(FRAGMENT_SHADER);
- STAGE_CASE(EARLY_FRAGMENT_TESTS);
- STAGE_CASE(LATE_FRAGMENT_TESTS);
- STAGE_CASE(COLOR_ATTACHMENT_OUTPUT);
- STAGE_CASE(COMPUTE_SHADER);
- STAGE_CASE(TRANSFER);
- STAGE_CASE(HOST);
- STAGE_CASE(ALL_GRAPHICS);
- STAGE_CASE(ALL_COMMANDS);
+ STAGE_CASE(TOP_OF_PIPE)
+ STAGE_CASE(DRAW_INDIRECT)
+ STAGE_CASE(VERTEX_INPUT)
+ STAGE_CASE(VERTEX_SHADER)
+ STAGE_CASE(TESSELLATION_CONTROL_SHADER)
+ STAGE_CASE(TESSELLATION_EVALUATION_SHADER)
+ STAGE_CASE(GEOMETRY_SHADER)
+ STAGE_CASE(FRAGMENT_SHADER)
+ STAGE_CASE(EARLY_FRAGMENT_TESTS)
+ STAGE_CASE(LATE_FRAGMENT_TESTS)
+ STAGE_CASE(COLOR_ATTACHMENT_OUTPUT)
+ STAGE_CASE(COMPUTE_SHADER)
+ STAGE_CASE(TRANSFER)
+ STAGE_CASE(HOST)
+ STAGE_CASE(ALL_GRAPHICS)
+ STAGE_CASE(ALL_COMMANDS)
#undef STAGE_CASE
default:
desc << "unknown stage!";
DE_FATAL("Unknown Stage!");
break;
- };
+ }
return desc.str();
}
desc << "unknown method!";
DE_FATAL("Unknown method!");
break;
- };
+ }
return desc.str();
}
case VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT:
default:
break;
- };
+ }
}
}
default:
DE_FATAL("Unknown Transfer Method!");
break;
- };
+ }
deUint32 timestampEntry = 0u;
const Unique<VkShaderModule> vertexShader (createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0));
const Unique<VkShaderModule> fragmentShader (createShaderModule(vk, device, m_context.getBinaryCollection().get("frag"), 0));
const std::vector<VkViewport> viewports (1, makeViewport(tcu::UVec2(m_params.size)));
- const std::vector<VkRect2D> scissors (1, makeRect2D(tcu::UVec2(m_params.size)));;
+ const std::vector<VkRect2D> scissors (1, makeRect2D(tcu::UVec2(m_params.size)));
const Move<VkPipelineLayout> pipelineLayout = makePipelineLayout(vk, device, 0, DE_NULL);
const VkVertexInputBindingDescription vertexInputBindingDescription =
VkImage image, VkImage resolvedImage, VkFramebuffer frameBuffer, const deUint32 renderSize, VkBuffer resultBuffer, const Allocation& resultBufferMemory);
virtual float getLineWidth (void) const;
virtual float getPointSize (void) const;
- virtual bool getLineStippleDynamic (void) const { return false; };
+ virtual bool getLineStippleDynamic (void) const { return false; }
virtual
const VkPipelineRasterizationStateCreateInfo* getRasterizationStateCreateInfo (void) const;
virtual tcu::TestStatus iterate (void);
virtual float getLineWidth (void) const;
bool getLineStippleEnable (void) const { return m_stipple != LINESTIPPLE_DISABLED; }
- virtual bool getLineStippleDynamic (void) const { return m_stipple == LINESTIPPLE_DYNAMIC; };
+ virtual bool getLineStippleDynamic (void) const { return m_stipple == LINESTIPPLE_DYNAMIC; }
virtual
VkPipelineRasterizationLineStateCreateInfoEXT initLineRasterizationStateCreateInfo (void) const;
}
bool getLineStippleEnable (void) const { return m_stipple != LINESTIPPLE_DISABLED; }
- virtual bool getLineStippleDynamic (void) const { return m_stipple == LINESTIPPLE_DYNAMIC; };
+ virtual bool getLineStippleDynamic (void) const { return m_stipple == LINESTIPPLE_DYNAMIC; }
protected:
const PrimitiveWideness m_wideness;
break;
default:
TCU_THROW(InternalError, "Wrong shader source type");
- };
+ }
const VkVertexInputBindingDescription vertexInputBindingDescription =
{
break;
default:
TCU_THROW(InternalError, "Wrong shader source type");
- };
+ }
// compare result and reference
return tcu::intThresholdCompare(context.getTestContext().getLog(), "Result comparison", "", referenceAccess, resultAccess, tcu::UVec4(0), tcu::COMPARE_LOG_RESULT);
class PipelineConfiguration
{
public:
- PipelineConfiguration() {};
- virtual ~PipelineConfiguration() {};
+ PipelineConfiguration() {}
+ virtual ~PipelineConfiguration() {}
virtual void initConfiguration(const TestEnvironment& env,
TestParams& testParams) = 0;
const TestParams& testParams);
GraphicsConfiguration();
- virtual ~GraphicsConfiguration() {};
+ virtual ~GraphicsConfiguration() {}
void initVertexBuffer(const TestEnvironment& env,
TestParams& testParams);
{
public:
ComputeConfiguration();
- virtual ~ComputeConfiguration() {};
+ virtual ~ComputeConfiguration() {}
static void checkSupport(Context& context,
const TestParams& testParams);
{
public:
RayTracingConfiguration();
- virtual ~RayTracingConfiguration() {};
+ virtual ~RayTracingConfiguration() {}
static void checkSupport(Context& context,
const TestParams& testParams);
" }\n"
"\n"
" imageStore(result, pos, ivec4(result_i32, 0, 0, 0));\n";
- ;
return result;
}
break;
default:
TCU_THROW(InternalError, "Wrong shader source type");
- };
+ }
const VkVertexInputBindingDescription vertexInputBindingDescription =
{
break;
default:
TCU_THROW(InternalError, "Wrong shader source type");
- };
+ }
// compare result and reference
return tcu::intThresholdCompare(context.getTestContext().getLog(), "Result comparison", "", referenceAccess, resultAccess, tcu::UVec4(0), tcu::COMPARE_LOG_RESULT);
<< " }\n"
<< " result.candidateFound = candidateFoundVal;\n"
<< "}\n";
- ;
programCollection.glslSources.add("comp") << glu::ComputeSource(comp.str()) << buildOptions;
}
break;
default:
TCU_THROW(InternalError, "Wrong shader source type");
- };
+ }
const VkVertexInputBindingDescription vertexInputBindingDescription =
{
break;
default:
TCU_THROW(InternalError, "Wrong shader source type");
- };
+ }
// compare result and reference
return tcu::intThresholdCompare(context.getTestContext().getLog(), "Result comparison", "", referenceAccess, resultAccess, tcu::UVec4(0), tcu::COMPARE_LOG_RESULT);
class PipelineConfiguration
{
public:
- PipelineConfiguration () {};
- virtual ~PipelineConfiguration () {};
+ PipelineConfiguration () {}
+ virtual ~PipelineConfiguration () {}
virtual void initConfiguration (Context& context,
TestParams& testParams) = 0;
const TestParams& testParams);
GraphicsConfiguration ();
- virtual ~GraphicsConfiguration () {};
+ virtual ~GraphicsConfiguration () {}
void initVertexBuffer (Context& context,
TestParams& testParams);
{
public:
ComputeConfiguration ();
- virtual ~ComputeConfiguration () {};
+ virtual ~ComputeConfiguration () {}
static void checkSupport (Context& context,
const TestParams& testParams);
{
public:
RayTracingConfiguration ();
- virtual ~RayTracingConfiguration () {};
+ virtual ~RayTracingConfiguration () {}
static void checkSupport (Context& context,
const TestParams& testParams);
<< writerCalcAndWrite
<< " hitAttribute = vec3(0.0f, 0.0f, 0.0f);\n"
<< " reportIntersectionEXT(1.0f, 0);\n"
- << "}\n";
+ << "}\n"
;
programCollection.glslSources.add("writer_isect") << glu::IntersectionSource(updateRayTracingGLSL(isect.str())) << buildOptions;
}
<< "{\n"
<< rayTracingIds
<< writerCalcAndWrite
- << "}\n";
+ << "}\n"
;
programCollection.glslSources.add("writer_ahit") << glu::AnyHitSource(updateRayTracingGLSL(ahit.str())) << buildOptions;
}
<< "{\n"
<< rayTracingIds
<< writerCalcAndWrite
- << "}\n";
+ << "}\n"
;
programCollection.glslSources.add("writer_chit") << glu::ClosestHitSource(updateRayTracingGLSL(chit.str())) << buildOptions;
}
<< "{\n"
<< rayTracingIds
<< writerCalcAndWrite
- << "}\n";
+ << "}\n"
;
programCollection.glslSources.add("writer_miss") << glu::MissSource(updateRayTracingGLSL(miss.str())) << buildOptions;
}
<< "{\n"
<< rayTracingIds
<< writerCalcAndWrite
- << "}\n";
+ << "}\n"
;
programCollection.glslSources.add("writer_callable") << glu::CallableSource(updateRayTracingGLSL(callable.str())) << buildOptions;
}
<< readerReadAndSave
<< " hitAttribute = vec3(0.0f, 0.0f, 0.0f);\n"
<< " reportIntersectionEXT(1.0f, 0);\n"
- << "}\n";
+ << "}\n"
;
programCollection.glslSources.add("reader_isect") << glu::IntersectionSource(updateRayTracingGLSL(isect.str())) << buildOptions;
}
<< "{\n"
<< rayTracingIds
<< readerReadAndSave
- << "}\n";
+ << "}\n"
;
programCollection.glslSources.add("reader_ahit") << glu::AnyHitSource(updateRayTracingGLSL(ahit.str())) << buildOptions;
}
<< "{\n"
<< rayTracingIds
<< readerReadAndSave
- << "}\n";
+ << "}\n"
;
programCollection.glslSources.add("reader_chit") << glu::ClosestHitSource(updateRayTracingGLSL(chit.str())) << buildOptions;
}
<< "{\n"
<< rayTracingIds
<< readerReadAndSave
- << "}\n";
+ << "}\n"
;
programCollection.glslSources.add("reader_miss") << glu::MissSource(updateRayTracingGLSL(miss.str())) << buildOptions;
}
<< "{\n"
<< rayTracingIds
<< readerReadAndSave
- << "}\n";
+ << "}\n"
;
programCollection.glslSources.add("reader_callable") << glu::CallableSource(updateRayTracingGLSL(callable.str())) << buildOptions;
}
<< "{\n"
<< " coordinates.values[gl_LaunchIDEXT.x] = vec4(-1.0, -1.0, -1.0, -1.0);\n"
<< "}\n";
- ;
programCollection.glslSources.add("rgen") << glu::RaygenSource(updateRayTracingGLSL(rgen.str())) << buildOptions;
programCollection.glslSources.add("miss") << glu::MissSource(updateRayTracingGLSL(miss.str())) << buildOptions;
case 2: { v0 = v1 = v3 = p.b; v2 = p.c & id; break; }
case 3: { v0 = v1 = v2 = p.b; v3 = p.c & id; break; }
default: { v0 = v1 = v2 = v3 = 0; break; }
- };
+ }
if (!fixed)
result[plain8Ofs + id] = p.c & id;
calcEqual
<< "%component_after_" << i << " = OpLoad %" << componentTypeName << " %component_ptr_" << i << "\n"
<< "%equal_" << i << " = " << opEqual << " %bool %component_" << i << " %component_after_" << i << "\n";
- ;
if (i > 0)
calcEqual << "%and_" << i << " = OpLogicalAnd %bool %equal_" << (i - 1) << " %equal_" << i << "\n";
if (i == numComponents - 1)
<< "void main()\n"
<< "{\n"
<< " calleeBuffer.val = 1u;\n"
- << "}\n";
+ << "}\n"
;
programCollection.glslSources.add("chit") << glu::ClosestHitSource(updateRayTracingGLSL(chit.str())) << buildOptions;
}
<< "void main()\n"
<< "{\n"
<< " calleeBuffer.val = 1u;\n"
- << "}\n";
+ << "}\n"
;
programCollection.glslSources.add("ahit") << glu::AnyHitSource(updateRayTracingGLSL(ahit.str())) << buildOptions;
}
<< "{\n"
<< " storageBuffer.val[1] = uint(hitValue.x + hitValue.y + hitValue.z);\n"
<< " hitValue = vec3(hitValue.x + 1.0, hitValue.y + 1.0, hitValue.z + 1.0);\n"
- << "}\n";
+ << "}\n"
;
programCollection.glslSources.add("chit") << glu::ClosestHitSource(updateRayTracingGLSL(chit.str())) << buildOptions;
}
<< "void main()\n"
<< "{\n"
<< " storageBuffer.val[2] = uint(attribs.x + attribs.y + attribs.z);\n"
- << "}\n";
+ << "}\n"
;
programCollection.glslSources.add("chit") << glu::ClosestHitSource(updateRayTracingGLSL(chit.str())) << buildOptions;
<< "{\n"
<< " outBuffer.val = -10000.0f;\n"
<< "}\n";
- ;
programCollection.glslSources.add("miss") << glu::MissSource(updateRayTracingGLSL(miss.str())) << buildOptions;
}
memBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;
memBarrier.pNext = nullptr;
- memBarrier.srcAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;;
+ memBarrier.srcAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;
memBarrier.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER;
context.getDeviceInterface().cmdPipelineBarrier(commandBuffer,
<< " args.direction.xyz,\n"
<< " args.Tmax,\n"
<< " 0);\n"
- << "}\n";
+ << "}\n"
;
std::ostringstream chit;
<< "void main()\n"
<< "{\n"
<< " result.shaderId = chitShaderId;\n"
- << "}\n";
+ << "}\n"
;
std::ostringstream miss;
<< "void main()\n"
<< "{\n"
<< " result.shaderId = missShaderId;\n"
- << "}\n";
+ << "}\n"
;
programCollection.glslSources.add("rgen") << glu::RaygenSource(rgen.str()) << buildOptions;
dependencies.push_back(dependency);
}
- };
+ }
// the last subpass must synchronize with all prior subpasses
for (deUint32 splitSubpassIndex = 0; splitSubpassIndex < (splitSubpassCount - 1); splitSubpassIndex++)
{
"}\n";
}
break;
- };
+ }
dst.glslSources.add("quad-frag") << glu::FragmentSource(fragmentShader.str());
}
deUint32 getColorAttachmentIndex (deUint32 attachmentNdx) const { return m_colorAttachments[attachmentNdx].getAttachment(); }
const Attachment& getColorAttachment (deUint32 attachmentNdx) const { return m_colorAttachmentInfo[attachmentNdx]; }
Maybe<VkImageLayout> getDepthStencilAttachmentLayout (void) const { return m_depthStencilAttachment ? tcu::just(m_depthStencilAttachment->getImageLayout()) : tcu::nothing<VkImageLayout>(); }
- Maybe<deUint32> getDepthStencilAttachmentIndex (void) const { return m_depthStencilAttachment ? tcu::just(m_depthStencilAttachment->getAttachment()) : tcu::nothing<deUint32>(); };
+ Maybe<deUint32> getDepthStencilAttachmentIndex (void) const { return m_depthStencilAttachment ? tcu::just(m_depthStencilAttachment->getAttachment()) : tcu::nothing<deUint32>(); }
const Maybe<Attachment>& getDepthStencilAttachment (void) const { return m_depthStencilAttachmentInfo; }
VkSubpassDescriptionFlags getSubpassFlags (void) const { return m_flags; }
default:
DE_FATAL("unexpected attachment load op");
return "";
- };
+ }
}
std::string storeOpToString (VkAttachmentStoreOp storeOp)
default:
DE_FATAL("unexpected attachment store op");
return "";
- };
+ }
}
} // anonymous
virtual void checkResults(tcu::ResultCollector& resultCollector) = 0;
- virtual ~BufferInterface() {};
+ virtual ~BufferInterface() {}
};
template<typename dataTypeT>
default:
DE_FATAL("Unexpected atomic operation.");
break;
- };
+ }
const T resIo = result.inout[elementNdx];
const T resOutput0 = result.output[elementNdx];
default:
DE_FATAL("Unexpected atomic operation.");
break;
- };
+ }
const T resIo = result.inout[elementNdx];
const T resOutput0 = result.output[elementNdx];
typedef InverseSqrt< Signature<float, float> > InverseSqrt32Bit;
typedef InverseSqrt< Signature<double, double> > InverseSqrt64Bit;
-DEFINE_DERIVED_FLOAT1(Sqrt32Bit, sqrt, x, constant(1.0f) / app<InverseSqrt32Bit>(x));
-DEFINE_DERIVED_FLOAT1_16BIT(Sqrt16Bit, sqrt, x, constant((deFloat16)FLOAT16_1_0) / app<InverseSqrt16Bit>(x));
-DEFINE_DERIVED_DOUBLE1(Sqrt64Bit, sqrt, x, constant(1.0) / app<InverseSqrt64Bit>(x));
-DEFINE_DERIVED_FLOAT2(Pow, pow, x, y, exp2<float>(y * log2(x)));
-DEFINE_DERIVED_FLOAT2_16BIT(Pow16, pow, x, y, exp2<deFloat16>(y * log2(x)));
-DEFINE_DERIVED_DOUBLE2(Pow64, pow, x, y, exp2<double>(y * log2(x)));
-DEFINE_DERIVED_FLOAT1(Radians, radians, d, (constant(DE_PI) / constant(180.0f)) * d);
-DEFINE_DERIVED_FLOAT1_16BIT(Radians16, radians, d, (constant((deFloat16)DE_PI_16BIT) / constant((deFloat16)FLOAT16_180_0)) * d);
-DEFINE_DERIVED_DOUBLE1(Radians64, radians, d, (constant((double)(DE_PI)) / constant(180.0)) * d);
-DEFINE_DERIVED_FLOAT1(Degrees, degrees, r, (constant(180.0f) / constant(DE_PI)) * r);
-DEFINE_DERIVED_FLOAT1_16BIT(Degrees16, degrees, r, (constant((deFloat16)FLOAT16_180_0) / constant((deFloat16)DE_PI_16BIT)) * r);
-DEFINE_DERIVED_DOUBLE1(Degrees64, degrees, r, (constant(180.0) / constant((double)(DE_PI))) * r);
+DEFINE_DERIVED_FLOAT1(Sqrt32Bit, sqrt, x, constant(1.0f) / app<InverseSqrt32Bit>(x))
+DEFINE_DERIVED_FLOAT1_16BIT(Sqrt16Bit, sqrt, x, constant((deFloat16)FLOAT16_1_0) / app<InverseSqrt16Bit>(x))
+DEFINE_DERIVED_DOUBLE1(Sqrt64Bit, sqrt, x, constant(1.0) / app<InverseSqrt64Bit>(x))
+DEFINE_DERIVED_FLOAT2(Pow, pow, x, y, exp2<float>(y * log2(x)))
+DEFINE_DERIVED_FLOAT2_16BIT(Pow16, pow, x, y, exp2<deFloat16>(y * log2(x)))
+DEFINE_DERIVED_DOUBLE2(Pow64, pow, x, y, exp2<double>(y * log2(x)))
+DEFINE_DERIVED_FLOAT1(Radians, radians, d, (constant(DE_PI) / constant(180.0f)) * d)
+DEFINE_DERIVED_FLOAT1_16BIT(Radians16, radians, d, (constant((deFloat16)DE_PI_16BIT) / constant((deFloat16)FLOAT16_180_0)) * d)
+DEFINE_DERIVED_DOUBLE1(Radians64, radians, d, (constant((double)(DE_PI)) / constant(180.0)) * d)
+DEFINE_DERIVED_FLOAT1(Degrees, degrees, r, (constant(180.0f) / constant(DE_PI)) * r)
+DEFINE_DERIVED_FLOAT1_16BIT(Degrees16, degrees, r, (constant((deFloat16)FLOAT16_180_0) / constant((deFloat16)DE_PI_16BIT)) * r)
+DEFINE_DERIVED_DOUBLE1(Degrees64, degrees, r, (constant(180.0) / constant((double)(DE_PI))) * r)
/*Proper parameters for template T
Signature<float, float> 32bit tests
ExprP<deFloat16> cos (const ExprP<deFloat16>& x) { return app<Cos<Signature<deFloat16, deFloat16> > >(x); }
ExprP<double> cos (const ExprP<double>& x) { return app<Cos<Signature<double, double> > >(x); }
-DEFINE_DERIVED_FLOAT1_INPUTRANGE(Tan, tan, x, sin(x) * (constant(1.0f) / cos(x)), Interval(false, -DE_PI_DOUBLE, DE_PI_DOUBLE));
-DEFINE_DERIVED_FLOAT1_INPUTRANGE_16BIT(Tan16Bit, tan, x, sin(x) * (constant((deFloat16)FLOAT16_1_0) / cos(x)), Interval(false, -DE_PI_DOUBLE, DE_PI_DOUBLE));
-DEFINE_DERIVED_DOUBLE1_INPUTRANGE(Tan64Bit, tan, x, sin(x) * (constant(1.0) / cos(x)), Interval(false, -DE_PI_DOUBLE, DE_PI_DOUBLE));
+DEFINE_DERIVED_FLOAT1_INPUTRANGE(Tan, tan, x, sin(x) * (constant(1.0f) / cos(x)), Interval(false, -DE_PI_DOUBLE, DE_PI_DOUBLE))
+DEFINE_DERIVED_FLOAT1_INPUTRANGE_16BIT(Tan16Bit, tan, x, sin(x) * (constant((deFloat16)FLOAT16_1_0) / cos(x)), Interval(false, -DE_PI_DOUBLE, DE_PI_DOUBLE))
+DEFINE_DERIVED_DOUBLE1_INPUTRANGE(Tan64Bit, tan, x, sin(x) * (constant(1.0) / cos(x)), Interval(false, -DE_PI_DOUBLE, DE_PI_DOUBLE))
template <class T>
class ATan : public CFloatFunc1<T>
ExprP<double> atan2 (const ExprP<double>& x, const ExprP<double>& y) { return app<ATan2<Signature<double, double, double> > >(x, y); }
-DEFINE_DERIVED_FLOAT1(Sinh, sinh, x, (exp<float>(x) - exp<float>(-x)) / constant(2.0f));
-DEFINE_DERIVED_FLOAT1(Cosh, cosh, x, (exp<float>(x) + exp<float>(-x)) / constant(2.0f));
-DEFINE_DERIVED_FLOAT1(Tanh, tanh, x, sinh(x) / cosh(x));
+DEFINE_DERIVED_FLOAT1(Sinh, sinh, x, (exp<float>(x) - exp<float>(-x)) / constant(2.0f))
+DEFINE_DERIVED_FLOAT1(Cosh, cosh, x, (exp<float>(x) + exp<float>(-x)) / constant(2.0f))
+DEFINE_DERIVED_FLOAT1(Tanh, tanh, x, sinh(x) / cosh(x))
-DEFINE_DERIVED_FLOAT1_16BIT(Sinh16Bit, sinh, x, (exp(x) - exp(-x)) / constant((deFloat16)FLOAT16_2_0));
-DEFINE_DERIVED_FLOAT1_16BIT(Cosh16Bit, cosh, x, (exp(x) + exp(-x)) / constant((deFloat16)FLOAT16_2_0));
-DEFINE_DERIVED_FLOAT1_16BIT(Tanh16Bit, tanh, x, sinh(x) / cosh(x));
+DEFINE_DERIVED_FLOAT1_16BIT(Sinh16Bit, sinh, x, (exp(x) - exp(-x)) / constant((deFloat16)FLOAT16_2_0))
+DEFINE_DERIVED_FLOAT1_16BIT(Cosh16Bit, cosh, x, (exp(x) + exp(-x)) / constant((deFloat16)FLOAT16_2_0))
+DEFINE_DERIVED_FLOAT1_16BIT(Tanh16Bit, tanh, x, sinh(x) / cosh(x))
-DEFINE_DERIVED_DOUBLE1(Sinh64Bit, sinh, x, (exp<double>(x) - exp<double>(-x)) / constant(2.0));
-DEFINE_DERIVED_DOUBLE1(Cosh64Bit, cosh, x, (exp<double>(x) + exp<double>(-x)) / constant(2.0));
-DEFINE_DERIVED_DOUBLE1(Tanh64Bit, tanh, x, sinh(x) / cosh(x));
+DEFINE_DERIVED_DOUBLE1(Sinh64Bit, sinh, x, (exp<double>(x) - exp<double>(-x)) / constant(2.0))
+DEFINE_DERIVED_DOUBLE1(Cosh64Bit, cosh, x, (exp<double>(x) + exp<double>(-x)) / constant(2.0))
+DEFINE_DERIVED_DOUBLE1(Tanh64Bit, tanh, x, sinh(x) / cosh(x))
-DEFINE_DERIVED_FLOAT1(ASin, asin, x, atan2(x, sqrt(constant(1.0f) - x * x)));
-DEFINE_DERIVED_FLOAT1(ACos, acos, x, atan2(sqrt(constant(1.0f) - x * x), x));
-DEFINE_DERIVED_FLOAT1(ASinh, asinh, x, log(x + sqrt(x * x + constant(1.0f))));
+DEFINE_DERIVED_FLOAT1(ASin, asin, x, atan2(x, sqrt(constant(1.0f) - x * x)))
+DEFINE_DERIVED_FLOAT1(ACos, acos, x, atan2(sqrt(constant(1.0f) - x * x), x))
+DEFINE_DERIVED_FLOAT1(ASinh, asinh, x, log(x + sqrt(x * x + constant(1.0f))))
DEFINE_DERIVED_FLOAT1(ACosh, acosh, x, log(x + sqrt(alternatives((x + constant(1.0f)) * (x - constant(1.0f)),
- (x * x - constant(1.0f))))));
+ (x * x - constant(1.0f))))))
DEFINE_DERIVED_FLOAT1(ATanh, atanh, x, constant(0.5f) * log((constant(1.0f) + x) /
- (constant(1.0f) - x)));
+ (constant(1.0f) - x)))
-DEFINE_DERIVED_FLOAT1_16BIT(ASin16Bit, asin, x, atan2(x, sqrt(constant((deFloat16)FLOAT16_1_0) - x * x)));
-DEFINE_DERIVED_FLOAT1_16BIT(ACos16Bit, acos, x, atan2(sqrt(constant((deFloat16)FLOAT16_1_0) - x * x), x));
-DEFINE_DERIVED_FLOAT1_16BIT(ASinh16Bit, asinh, x, log(x + sqrt(x * x + constant((deFloat16)FLOAT16_1_0))));
+DEFINE_DERIVED_FLOAT1_16BIT(ASin16Bit, asin, x, atan2(x, sqrt(constant((deFloat16)FLOAT16_1_0) - x * x)))
+DEFINE_DERIVED_FLOAT1_16BIT(ACos16Bit, acos, x, atan2(sqrt(constant((deFloat16)FLOAT16_1_0) - x * x), x))
+DEFINE_DERIVED_FLOAT1_16BIT(ASinh16Bit, asinh, x, log(x + sqrt(x * x + constant((deFloat16)FLOAT16_1_0))))
DEFINE_DERIVED_FLOAT1_16BIT(ACosh16Bit, acosh, x, log(x + sqrt(alternatives((x + constant((deFloat16)FLOAT16_1_0)) * (x - constant((deFloat16)FLOAT16_1_0)),
- (x * x - constant((deFloat16)FLOAT16_1_0))))));
+ (x * x - constant((deFloat16)FLOAT16_1_0))))))
DEFINE_DERIVED_FLOAT1_16BIT(ATanh16Bit, atanh, x, constant((deFloat16)FLOAT16_0_5) * log((constant((deFloat16)FLOAT16_1_0) + x) /
- (constant((deFloat16)FLOAT16_1_0) - x)));
+ (constant((deFloat16)FLOAT16_1_0) - x)))
-DEFINE_DERIVED_DOUBLE1(ASin64Bit, asin, x, atan2(x, sqrt(constant(1.0) - pow(x, constant(2.0)))));
-DEFINE_DERIVED_DOUBLE1(ACos64Bit, acos, x, atan2(sqrt(constant(1.0) - pow(x, constant(2.0))), x));
-DEFINE_DERIVED_DOUBLE1(ASinh64Bit, asinh, x, log(x + sqrt(x * x + constant(1.0))));
+DEFINE_DERIVED_DOUBLE1(ASin64Bit, asin, x, atan2(x, sqrt(constant(1.0) - pow(x, constant(2.0)))))
+DEFINE_DERIVED_DOUBLE1(ACos64Bit, acos, x, atan2(sqrt(constant(1.0) - pow(x, constant(2.0))), x))
+DEFINE_DERIVED_DOUBLE1(ASinh64Bit, asinh, x, log(x + sqrt(x * x + constant(1.0))))
DEFINE_DERIVED_DOUBLE1(ACosh64Bit, acosh, x, log(x + sqrt(alternatives((x + constant(1.0)) * (x - constant(1.0)),
- (x * x - constant(1.0))))));
+ (x * x - constant(1.0))))))
DEFINE_DERIVED_DOUBLE1(ATanh64Bit, atanh, x, constant(0.5) * log((constant(1.0) + x) /
- (constant(1.0) - x)));
+ (constant(1.0) - x)))
template <typename T>
class GetComponent : public PrimitiveFunc<Signature<typename T::Element, T, int> >
typedef Trunc< Signature<float, float> > Trunc32Bit;
typedef Trunc< Signature<deFloat16, deFloat16> > Trunc16Bit;
-DEFINE_DERIVED_FLOAT1(Fract, fract, x, x - app<Floor32Bit>(x));
-DEFINE_DERIVED_FLOAT1_16BIT(Fract16Bit, fract, x, x - app<Floor16Bit>(x));
-DEFINE_DERIVED_DOUBLE1(Fract64Bit, fract, x, x - app<Floor64Bit>(x));
+DEFINE_DERIVED_FLOAT1(Fract, fract, x, x - app<Floor32Bit>(x))
+DEFINE_DERIVED_FLOAT1_16BIT(Fract16Bit, fract, x, x - app<Floor16Bit>(x))
+DEFINE_DERIVED_DOUBLE1(Fract64Bit, fract, x, x - app<Floor64Bit>(x))
template <class T>
class PreciseFunc2 : public CFloatFunc2<T>
double precision (const EvalContext&, double, double, double) const { return 0.0; }
};
-DEFINE_DERIVED_FLOAT2(Mod32Bit, mod, x, y, x - y * app<Floor32Bit>(x / y));
-DEFINE_DERIVED_FLOAT2_16BIT(Mod16Bit, mod, x, y, x - y * app<Floor16Bit>(x / y));
-DEFINE_DERIVED_DOUBLE2(Mod64Bit, mod, x, y, x - y * app<Floor64Bit>(x / y));
+DEFINE_DERIVED_FLOAT2(Mod32Bit, mod, x, y, x - y * app<Floor32Bit>(x / y))
+DEFINE_DERIVED_FLOAT2_16BIT(Mod16Bit, mod, x, y, x - y * app<Floor16Bit>(x / y))
+DEFINE_DERIVED_DOUBLE2(Mod64Bit, mod, x, y, x - y * app<Floor64Bit>(x / y))
-DEFINE_CASED_DERIVED_FLOAT2(FRem32Bit, frem, x, y, x - y * app<Trunc32Bit>(x / y), SPIRV_CASETYPE_FREM);
-DEFINE_CASED_DERIVED_FLOAT2_16BIT(FRem16Bit, frem, x, y, x - y * app<Trunc16Bit>(x / y), SPIRV_CASETYPE_FREM);
-DEFINE_CASED_DERIVED_DOUBLE2(FRem64Bit, frem, x, y, x - y * app<Trunc64Bit>(x / y), SPIRV_CASETYPE_FREM);
+DEFINE_CASED_DERIVED_FLOAT2(FRem32Bit, frem, x, y, x - y * app<Trunc32Bit>(x / y), SPIRV_CASETYPE_FREM)
+DEFINE_CASED_DERIVED_FLOAT2_16BIT(FRem16Bit, frem, x, y, x - y * app<Trunc16Bit>(x / y), SPIRV_CASETYPE_FREM)
+DEFINE_CASED_DERIVED_DOUBLE2(FRem64Bit, frem, x, y, x - y * app<Trunc64Bit>(x / y), SPIRV_CASETYPE_FREM)
template <class T>
class Modf : public PrimitiveFunc<T>
}
DEFINE_DERIVED_FLOAT3(Mix, mix, x, y, a, alternatives((x * (constant(1.0f) - a)) + y * a,
- x + (y - x) * a));
+ x + (y - x) * a))
DEFINE_DERIVED_FLOAT3_16BIT(Mix16Bit, mix, x, y, a, alternatives((x * (constant((deFloat16)FLOAT16_1_0) - a)) + y * a,
- x + (y - x) * a));
+ x + (y - x) * a))
DEFINE_DERIVED_DOUBLE3(Mix64Bit, mix, x, y, a, alternatives((x * (constant(1.0) - a)) + y * a,
- x + (y - x) * a));
+ x + (y - x) * a))
static double step (double edge, double x)
{
public:
virtual void genFixeds (const FloatFormat&, const Precision, vector<T>&, const Interval&) const {}
virtual T genRandom (const FloatFormat&,const Precision, Random&, const Interval&) const { return T(); }
- virtual void removeNotInRange (vector<T>&, const Interval&, const Precision) const {};
+ virtual void removeNotInRange (vector<T>&, const Interval&, const Precision) const {}
};
template <>
if (inputLess(in1.d, in2.d))
return true;
return false;
- };
+ }
};
template<typename In>
switch (glu::getDataTypeScalarSize(type))
{
case 1: return baseSize;
- case 2: return baseSize * 2u;;
+ case 2: return baseSize * 2u;
case 3: // fallthrough.
case 4: return baseSize * 4u;
default:
default:
DE_ASSERT(false);
break;
- };
+ }
std::ostringstream src;
src << "; SPIR-V\n"
return res;
}
-inline int addOne (int v) { return v + 1; };
-inline int subOne (int v) { return v - 1; };
-inline deUint32 addOne (deUint32 v) { return v + 1; };
-inline deUint32 subOne (deUint32 v) { return v - 1; };
+inline int addOne (int v) { return v + 1; }
+inline int subOne (int v) { return v - 1; }
+inline deUint32 addOne (deUint32 v) { return v + 1; }
+inline deUint32 subOne (deUint32 v) { return v - 1; }
-template<int Size> inline Vector<float, Size> addOne (const Vector<float, Size>& v) { return v + 1.0f; };
-template<int Size> inline Vector<float, Size> subOne (const Vector<float, Size>& v) { return v - 1.0f; };
-template<int Size> inline Vector<int, Size> addOne (const Vector<int, Size>& v) { return v + 1; };
-template<int Size> inline Vector<int, Size> subOne (const Vector<int, Size>& v) { return v - 1; };
-template<int Size> inline Vector<deUint32, Size> addOne (const Vector<deUint32, Size>& v) { return v + 1U; };
-template<int Size> inline Vector<deUint32, Size> subOne (const Vector<deUint32, Size>& v) { return (v.asInt() - 1).asUint(); };
+template<int Size> inline Vector<float, Size> addOne (const Vector<float, Size>& v) { return v + 1.0f; }
+template<int Size> inline Vector<float, Size> subOne (const Vector<float, Size>& v) { return v - 1.0f; }
+template<int Size> inline Vector<int, Size> addOne (const Vector<int, Size>& v) { return v + 1; }
+template<int Size> inline Vector<int, Size> subOne (const Vector<int, Size>& v) { return v - 1; }
+template<int Size> inline Vector<deUint32, Size> addOne (const Vector<deUint32, Size>& v) { return v + 1U; }
+template<int Size> inline Vector<deUint32, Size> subOne (const Vector<deUint32, Size>& v) { return (v.asInt() - 1).asUint(); }
-template<typename T> inline T selection (bool cond, T a, T b) { return cond ? a : b; };
+template<typename T> inline T selection (bool cond, T a, T b) { return cond ? a : b; }
// Vec-scalar and scalar-vec binary operators.
// \note This one is done separately due to how the overloaded minus operator is implemented for vector-scalar operands.
-template<int Size> inline Vector<deUint32, Size> subVecScalar (const Vector<deUint32, Size>& v, deUint32 s) { return (v.asInt() - (int)s).asUint(); };
-
-template<typename T, int Size> inline Vector<T, Size> addVecScalar (const Vector<T, Size>& v, T s) { return v + s; };
-template<typename T, int Size> inline Vector<T, Size> subVecScalar (const Vector<T, Size>& v, T s) { return v - s; };
-template<typename T, int Size> inline Vector<T, Size> mulVecScalar (const Vector<T, Size>& v, T s) { return v * s; };
-template<typename T, int Size> inline Vector<T, Size> divVecScalar (const Vector<T, Size>& v, T s) { return v / s; };
-template<typename T, int Size> inline Vector<T, Size> modVecScalar (const Vector<T, Size>& v, T s) { return mod(v, Vector<T, Size>(s)); };
-template<typename T, int Size> inline Vector<T, Size> bitwiseAndVecScalar (const Vector<T, Size>& v, T s) { return bitwiseAnd(v, Vector<T, Size>(s)); };
-template<typename T, int Size> inline Vector<T, Size> bitwiseOrVecScalar (const Vector<T, Size>& v, T s) { return bitwiseOr(v, Vector<T, Size>(s)); };
-template<typename T, int Size> inline Vector<T, Size> bitwiseXorVecScalar (const Vector<T, Size>& v, T s) { return bitwiseXor(v, Vector<T, Size>(s)); };
-
-template<typename T, int Size> inline Vector<T, Size> addScalarVec (T s, const Vector<T, Size>& v) { return s + v; };
-template<typename T, int Size> inline Vector<T, Size> subScalarVec (T s, const Vector<T, Size>& v) { return s - v; };
-template<typename T, int Size> inline Vector<T, Size> mulScalarVec (T s, const Vector<T, Size>& v) { return s * v; };
-template<typename T, int Size> inline Vector<T, Size> divScalarVec (T s, const Vector<T, Size>& v) { return s / v; };
-template<typename T, int Size> inline Vector<T, Size> modScalarVec (T s, const Vector<T, Size>& v) { return mod(Vector<T, Size>(s), v); };
-template<typename T, int Size> inline Vector<T, Size> bitwiseAndScalarVec (T s, const Vector<T, Size>& v) { return bitwiseAnd(Vector<T, Size>(s), v); };
-template<typename T, int Size> inline Vector<T, Size> bitwiseOrScalarVec (T s, const Vector<T, Size>& v) { return bitwiseOr(Vector<T, Size>(s), v); };
-template<typename T, int Size> inline Vector<T, Size> bitwiseXorScalarVec (T s, const Vector<T, Size>& v) { return bitwiseXor(Vector<T, Size>(s), v); };
+template<int Size> inline Vector<deUint32, Size> subVecScalar (const Vector<deUint32, Size>& v, deUint32 s) { return (v.asInt() - (int)s).asUint(); }
+
+template<typename T, int Size> inline Vector<T, Size> addVecScalar (const Vector<T, Size>& v, T s) { return v + s; }
+template<typename T, int Size> inline Vector<T, Size> subVecScalar (const Vector<T, Size>& v, T s) { return v - s; }
+template<typename T, int Size> inline Vector<T, Size> mulVecScalar (const Vector<T, Size>& v, T s) { return v * s; }
+template<typename T, int Size> inline Vector<T, Size> divVecScalar (const Vector<T, Size>& v, T s) { return v / s; }
+template<typename T, int Size> inline Vector<T, Size> modVecScalar (const Vector<T, Size>& v, T s) { return mod(v, Vector<T, Size>(s)); }
+template<typename T, int Size> inline Vector<T, Size> bitwiseAndVecScalar (const Vector<T, Size>& v, T s) { return bitwiseAnd(v, Vector<T, Size>(s)); }
+template<typename T, int Size> inline Vector<T, Size> bitwiseOrVecScalar (const Vector<T, Size>& v, T s) { return bitwiseOr(v, Vector<T, Size>(s)); }
+template<typename T, int Size> inline Vector<T, Size> bitwiseXorVecScalar (const Vector<T, Size>& v, T s) { return bitwiseXor(v, Vector<T, Size>(s)); }
+
+template<typename T, int Size> inline Vector<T, Size> addScalarVec (T s, const Vector<T, Size>& v) { return s + v; }
+template<typename T, int Size> inline Vector<T, Size> subScalarVec (T s, const Vector<T, Size>& v) { return s - v; }
+template<typename T, int Size> inline Vector<T, Size> mulScalarVec (T s, const Vector<T, Size>& v) { return s * v; }
+template<typename T, int Size> inline Vector<T, Size> divScalarVec (T s, const Vector<T, Size>& v) { return s / v; }
+template<typename T, int Size> inline Vector<T, Size> modScalarVec (T s, const Vector<T, Size>& v) { return mod(Vector<T, Size>(s), v); }
+template<typename T, int Size> inline Vector<T, Size> bitwiseAndScalarVec (T s, const Vector<T, Size>& v) { return bitwiseAnd(Vector<T, Size>(s), v); }
+template<typename T, int Size> inline Vector<T, Size> bitwiseOrScalarVec (T s, const Vector<T, Size>& v) { return bitwiseOr(Vector<T, Size>(s), v); }
+template<typename T, int Size> inline Vector<T, Size> bitwiseXorScalarVec (T s, const Vector<T, Size>& v) { return bitwiseXor(Vector<T, Size>(s), v); }
// Reference functions for specific sequence operations for the sequence operator tests.
void eval_##GLSL_NAME##_bvec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(greaterThan(c.in[0].swizzle(2, 0, 1), Vec3(0.0f))).asFloat(); } \
void eval_##GLSL_NAME##_bvec4 (ShaderEvalContext& c) { c.color.xyzw() = FUNC_NAME(greaterThan(c.in[0].swizzle(1, 2, 3, 0), Vec4(0.0f))).asFloat(); }
-DECLARE_UNARY_SCALAR_BVEC_FUNCS(any, boolAny);
-DECLARE_UNARY_SCALAR_BVEC_FUNCS(all, boolAll);
+DECLARE_UNARY_SCALAR_BVEC_FUNCS(any, boolAny)
+DECLARE_UNARY_SCALAR_BVEC_FUNCS(all, boolAll)
// ShaderOperatorTests.
struct QueueFamilyQueuesCount
{
- QueueFamilyQueuesCount() : queueCount(0u) {};
+ QueueFamilyQueuesCount() : queueCount(0u) {}
deUint32 queueCount;
};
const tcu::UVec3& imageSize,
const VkFormat format);
- void initPrograms (SourceCollections& sourceCollections) const {DE_UNREF(sourceCollections);};
+ void initPrograms (SourceCollections& sourceCollections) const {DE_UNREF(sourceCollections);}
TestInstance* createInstance (Context& context) const;
virtual void checkSupport (Context& context) const;
const VkFormat format,
deUint32 numSamples);
- void initPrograms (SourceCollections& sourceCollections) const {DE_UNREF(sourceCollections);};
+ void initPrograms (SourceCollections& sourceCollections) const {DE_UNREF(sourceCollections);}
TestInstance* createInstance (Context& context) const;
virtual void checkSupport (Context& context) const;
expectedGranularity.height = 16;
expectedGranularity.depth = 16;
break;
- };
+ }
}
else if (m_numSamples == 2)
{
expectedGranularity.width = 32;
expectedGranularity.height = 64;
break;
- };
+ }
}
else if (m_numSamples == 4)
{
expectedGranularity.width = 32;
expectedGranularity.height = 32;
break;
- };
+ }
}
else if (m_numSamples == 8)
{
expectedGranularity.width = 16;
expectedGranularity.height = 32;
break;
- };
+ }
}
else if (m_numSamples == 16)
{
expectedGranularity.width = 16;
expectedGranularity.height = 16;
break;
- };
+ }
}
else
{
expectedGranularity.width = 64;
expectedGranularity.height = 64;
break;
- };
+ }
}
if ( imageGranularity.width != expectedGranularity.width
tcu::ConstPixelBufferAccess pixelBuffer = vk::getChannelAccess(compatibleFormatDescription, compatibleShaderGridSize, planeRowPitches, (const void* const*)planePointers, channelNdx);
std::ostringstream str;
str << "image" << channelNdx;
- m_context.getTestContext().getLog() << tcu::LogImage(str.str(), str.str(), pixelBuffer);;
+ m_context.getTestContext().getLog() << tcu::LogImage(str.str(), str.str(), pixelBuffer);
}
// Validate results
default :
DE_FATAL("Unexpected image type");
break;
- };
+ }
if (requiresSampler)
src << "1 ";
default:
DE_FATAL("Unexpected channel type");
break;
- };
+ }
return src.str();
}
default :
DE_FATAL("Unexpected image type");
break;
- };
+ }
if (requiresSampler)
src << "1 ";
default :
DE_FATAL("Unexpected image type");
break;
- };
+ }
return src.str();
}
default:
DE_FATAL("Unexpected image type");
return false;
- };
+ }
}
bool checkSparseSupportForImageFormat (const InstanceInterface& instance,
default:
DE_FATAL("Unexpected data type");
break;
- };
+ }
// Read input data from binding 1, location 2. Should have value(s) of 0.5 in 16bit float or 32767 in 16bit int.
// Store the value to two outputs (dataOut0 and 1).
default:
DE_FATAL("Impossible");
break;
- };
+ }
}
else
{
default:
DE_FATAL("Impossible");
break;
- };
+ }
}
else
{
{
for (size_t outputNdx = 0; outputNdx < m_shaderSpec.outputs.size(); ++outputNdx)
{
- const BufferSp& expectedOutput = m_shaderSpec.outputs[outputNdx].getBuffer();;
+ const BufferSp& expectedOutput = m_shaderSpec.outputs[outputNdx].getBuffer();
vector<deUint8> expectedBytes;
expectedOutput->getBytes(expectedBytes);
struct Decorations
{
Decorations()
- {};
+ {}
Decorations(const string& f, const string& v, const string& o)
: fragment (f)
, vertex (v)
, others (o)
- {};
+ {}
string fragment;
string vertex;
string others;
{
// Check various code fragments
const FloatStatementUsageFlags commandsFloatConstMask = B_STATEMENT_USAGE_COMMANDS_CONST_FLOAT | B_STATEMENT_USAGE_COMMANDS_CONST_FP16;
- const bool commandsUsesFloatConstant = (testCaseInfo.operation.statementUsageFlags & commandsFloatConstMask) != 0;;
+ const bool commandsUsesFloatConstant = (testCaseInfo.operation.statementUsageFlags & commandsFloatConstMask) != 0;
const FloatStatementUsageFlags argumentsFloatConstMask = B_STATEMENT_USAGE_ARGS_CONST_FLOAT | B_STATEMENT_USAGE_ARGS_CONST_FP16;
const bool argumentsUsesFloatConstant = (specOpData.argumentsUsesFloatConstant & argumentsFloatConstMask) != 0;
bool hasFP16ConstsInCommandsOrArguments = commandsUsesFloatConstant || argumentsUsesFloatConstant;
aspectFlags |= VK_IMAGE_ASPECT_COLOR_BIT;
return aspectFlags;
-};
+}
TestStatus runAndVerifyUnusedVariablePipeline (Context &context, UnusedVariableContext unusedVariableContext)
{
sizeof(Vec4), // deUint32 offsetInBytes;
};
vertexAttribs.push_back(attr1);
- };
+ }
// If the test instantiation has additional input/output interface variables, we need to create additional bindings.
// Right now we only support one additional input varible for the vertex stage, and that will be bound to binding #1
{
vertFragPipelineStages.push_back(ShaderElement("vert", "main", VK_SHADER_STAGE_VERTEX_BIT));
vertFragPipelineStages.push_back(ShaderElement("frag", "main", VK_SHADER_STAGE_FRAGMENT_BIT));
- };
+ }
return vertFragPipelineStages;
}
tessPipelineStages.push_back(ShaderElement("tessc", "main", VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT));
tessPipelineStages.push_back(ShaderElement("tesse", "main", VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT));
tessPipelineStages.push_back(ShaderElement("frag", "main", VK_SHADER_STAGE_FRAGMENT_BIT));
- };
+ }
return tessPipelineStages;
}
geomPipelineStages.push_back(ShaderElement("vert", "main", VK_SHADER_STAGE_VERTEX_BIT));
geomPipelineStages.push_back(ShaderElement("geom", "main", VK_SHADER_STAGE_GEOMETRY_BIT));
geomPipelineStages.push_back(ShaderElement("frag", "main", VK_SHADER_STAGE_FRAGMENT_BIT));
- };
+ }
return geomPipelineStages;
}
vulkanFeatures.extVariablePointers = EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS_STORAGEBUFFER;
spec.extensions.push_back("VK_KHR_variable_pointers");
break;
- };
+ }
spec.inputs.push_back(BufferSp(new Float32Buffer(inputData)));
spec.inputs.push_back(BufferSp(new Buffer<UVec4>(indexSelectorData)));
vulkanFeatures.extVariablePointers = EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS_STORAGEBUFFER;
element = 1;
break;
- };
+ }
outputData.reserve(numItems);
for (deUint32 numIdx = 0; numIdx < numItems; ++numIdx)
uint64Tests[ndx] = de::MovePtr<SpvAsmTypeUint64Tests>(new SpvAsmTypeUint64Tests(testCtx, ndx + 1));
}
- MAKE_TEST_SV_I_8136("negate", SpvOpSNegate, negate, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_I_8136("add", SpvOpIAdd, add, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_I_8136("sub", SpvOpISub, sub, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_I_8136("mul", SpvOpIMul, mul, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_I_8136("div", SpvOpSDiv, div, FILTER_ZERO, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_U_8136("div", SpvOpUDiv, div, FILTER_ZERO, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_I_8136("rem", SpvOpSRem, rem, FILTER_NEGATIVES_AND_ZERO, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_I_8136("mod", SpvOpSMod, mod, FILTER_NEGATIVES_AND_ZERO, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_U_8136("mod", SpvOpUMod, mod, FILTER_ZERO, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_I_8136("abs", GLSLstd450SAbs, abs, FILTER_NONE, RANGE_FULL, "GLSL.std.450");
- MAKE_TEST_SV_I_8136("sign", GLSLstd450SSign, sign, FILTER_NONE, RANGE_FULL, "GLSL.std.450");
- MAKE_TEST_SV_I_8136("min", GLSLstd450SMin, min, FILTER_NONE, RANGE_FULL, "GLSL.std.450");
- MAKE_TEST_SV_U_8136("min", GLSLstd450UMin, min, FILTER_NONE, RANGE_FULL, "GLSL.std.450");
- MAKE_TEST_SV_I_8136("max", GLSLstd450SMax, max, FILTER_NONE, RANGE_FULL, "GLSL.std.450");
- MAKE_TEST_SV_U_8136("max", GLSLstd450UMax, max, FILTER_NONE, RANGE_FULL, "GLSL.std.450");
- MAKE_TEST_SV_I_8136("clamp", GLSLstd450SClamp, clamp, FILTER_MIN_GT_MAX, RANGE_FULL, "GLSL.std.450");
- MAKE_TEST_SV_U_8136("clamp", GLSLstd450UClamp, clamp, FILTER_MIN_GT_MAX, RANGE_FULL, "GLSL.std.450");
- MAKE_TEST_SV_I_3("find_lsb", GLSLstd450FindILsb, lsb, FILTER_NONE, RANGE_FULL, "GLSL.std.450");
- MAKE_TEST_SV_I_3("find_msb", GLSLstd450FindSMsb, msb, FILTER_NONE, RANGE_FULL, "GLSL.std.450");
- MAKE_TEST_SV_U_3("find_msb", GLSLstd450FindUMsb, msb, FILTER_NONE, RANGE_FULL, "GLSL.std.450");
- MAKE_TEST_SV_I_1("mul_sdiv", DE_NULL, mul_div, FILTER_ZERO, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_U_1("mul_udiv", DE_NULL, mul_div, FILTER_ZERO, RANGE_FULL, DE_NULL);
-
- MAKE_TEST_SV_U_8136_W("shift_right_logical", SpvOpShiftRightLogical, lsr, FILTER_NONE, RANGE_BIT_WIDTH, DE_NULL);
- MAKE_TEST_SV_I_8136_W("shift_right_logical", SpvOpShiftRightLogical, lsr, FILTER_NONE, RANGE_BIT_WIDTH, DE_NULL);
- MAKE_TEST_SV_U_8136_W("shift_right_arithmetic", SpvOpShiftRightArithmetic, asr, FILTER_NONE, RANGE_BIT_WIDTH, DE_NULL);
- MAKE_TEST_SV_I_8136_W("shift_right_arithmetic", SpvOpShiftRightArithmetic, asr, FILTER_NONE, RANGE_BIT_WIDTH, DE_NULL);
- MAKE_TEST_SV_U_8136_W("shift_left_logical", SpvOpShiftLeftLogical, lsl, FILTER_NONE, RANGE_BIT_WIDTH, DE_NULL);
- MAKE_TEST_SV_I_8136_W("shift_left_logical", SpvOpShiftLeftLogical, lsl, FILTER_NONE, RANGE_BIT_WIDTH, DE_NULL);
-
- MAKE_TEST_SV_U_8136("bitwise_or", SpvOpBitwiseOr, bitwise_or, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_I_8136("bitwise_or", SpvOpBitwiseOr, bitwise_or , FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_U_8136("bitwise_xor", SpvOpBitwiseXor, bitwise_xor, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_I_8136("bitwise_xor", SpvOpBitwiseXor, bitwise_xor, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_U_8136("bitwise_and", SpvOpBitwiseAnd, bitwise_and, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_I_8136("bitwise_and", SpvOpBitwiseAnd, bitwise_and, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_U_8136("not", SpvOpNot, not, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_I_8136("not", SpvOpNot, not, FILTER_NONE, RANGE_FULL, DE_NULL);
-
- MAKE_TEST_SV_U_8136_N("iequal", SpvOpIEqual, iequal, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_I_8136_N("iequal", SpvOpIEqual, iequal, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_U_8136_N("inotequal", SpvOpINotEqual, inotequal, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_I_8136_N("inotequal", SpvOpINotEqual, inotequal, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_U_8136_N("ugreaterthan", SpvOpUGreaterThan, ugreaterthan, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_I_8136_N("ugreaterthan", SpvOpUGreaterThan, ugreaterthan, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_U_8136_N("sgreaterthan", SpvOpSGreaterThan, sgreaterthan, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_I_8136_N("sgreaterthan", SpvOpSGreaterThan, sgreaterthan, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_U_8136_N("ugreaterthanequal", SpvOpUGreaterThanEqual, ugreaterthanequal, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_I_8136_N("ugreaterthanequal", SpvOpUGreaterThanEqual, ugreaterthanequal, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_U_8136_N("sgreaterthanequal", SpvOpSGreaterThanEqual, sgreaterthanequal, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_I_8136_N("sgreaterthanequal", SpvOpSGreaterThanEqual, sgreaterthanequal, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_U_8136_N("ulessthan", SpvOpULessThan, ulessthan, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_I_8136_N("ulessthan", SpvOpULessThan, ulessthan, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_U_8136_N("slessthan", SpvOpSLessThan, slessthan, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_I_8136_N("slessthan", SpvOpSLessThan, slessthan, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_U_8136_N("ulessthanequal", SpvOpULessThanEqual, ulessthanequal, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_I_8136_N("ulessthanequal", SpvOpULessThanEqual, ulessthanequal, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_U_8136_N("slessthanequal", SpvOpSLessThanEqual, slessthanequal, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_I_8136_N("slessthanequal", SpvOpSLessThanEqual, slessthanequal, FILTER_NONE, RANGE_FULL, DE_NULL);
-
- MAKE_TEST_SV_U_3_W("bit_field_insert", SpvOpBitFieldInsert, bitFieldInsert, FILTER_NONE, RANGE_BIT_WIDTH_SUM, DE_NULL);
- MAKE_TEST_SV_I_3_W("bit_field_insert", SpvOpBitFieldInsert, bitFieldInsert, FILTER_NONE, RANGE_BIT_WIDTH_SUM, DE_NULL);
- MAKE_TEST_SV_U_3_W("bit_field_s_extract", SpvOpBitFieldSExtract, bitFieldSExtract, FILTER_NONE, RANGE_BIT_WIDTH_SUM, DE_NULL);
- MAKE_TEST_SV_I_3_W("bit_field_s_extract", SpvOpBitFieldSExtract, bitFieldSExtract, FILTER_NONE, RANGE_BIT_WIDTH_SUM, DE_NULL);
- MAKE_TEST_SV_U_3_W("bit_field_u_extract", SpvOpBitFieldUExtract, bitFieldUExtract, FILTER_NONE, RANGE_BIT_WIDTH_SUM, DE_NULL);
- MAKE_TEST_SV_I_3_W("bit_field_u_extract", SpvOpBitFieldUExtract, bitFieldUExtract, FILTER_NONE, RANGE_BIT_WIDTH_SUM, DE_NULL);
- MAKE_TEST_SV_U_3("bit_reverse", SpvOpBitReverse, bitReverse, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_I_3("bit_reverse", SpvOpBitReverse, bitReverse, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_U_3("bit_count", SpvOpBitCount, bitCount, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_I_3("bit_count", SpvOpBitCount, bitCount, FILTER_NONE, RANGE_FULL, DE_NULL);
-
- MAKE_TEST_S_U_8136("constant", SpvOpConstant, constant, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_S_I_8136("constant", SpvOpConstant, constant, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_V_U_8136("constant_composite", SpvOpConstantComposite, constant, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_V_I_8136("constant_composite", SpvOpConstantComposite, constant, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_V_U_8136("constant_null", SpvOpConstantNull, constant, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_V_I_8136("constant_null", SpvOpConstantNull, constant, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_U_8136("variable_initializer", SpvOpVariable, constant, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_SV_I_8136("variable_initializer", SpvOpVariable, constant, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_S_U_8136("spec_constant_initializer", SpvOpSpecConstant, constant, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_S_I_8136("spec_constant_initializer", SpvOpSpecConstant, constant, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_V_U_8136("spec_constant_composite_initializer", SpvOpSpecConstantComposite, constant, FILTER_NONE, RANGE_FULL, DE_NULL);
- MAKE_TEST_V_I_8136("spec_constant_composite_initializer", SpvOpSpecConstantComposite, constant, FILTER_NONE, RANGE_FULL, DE_NULL);
+ MAKE_TEST_SV_I_8136("negate", SpvOpSNegate, negate, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_I_8136("add", SpvOpIAdd, add, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_I_8136("sub", SpvOpISub, sub, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_I_8136("mul", SpvOpIMul, mul, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_I_8136("div", SpvOpSDiv, div, FILTER_ZERO, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_U_8136("div", SpvOpUDiv, div, FILTER_ZERO, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_I_8136("rem", SpvOpSRem, rem, FILTER_NEGATIVES_AND_ZERO, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_I_8136("mod", SpvOpSMod, mod, FILTER_NEGATIVES_AND_ZERO, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_U_8136("mod", SpvOpUMod, mod, FILTER_ZERO, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_I_8136("abs", GLSLstd450SAbs, abs, FILTER_NONE, RANGE_FULL, "GLSL.std.450")
+ MAKE_TEST_SV_I_8136("sign", GLSLstd450SSign, sign, FILTER_NONE, RANGE_FULL, "GLSL.std.450")
+ MAKE_TEST_SV_I_8136("min", GLSLstd450SMin, min, FILTER_NONE, RANGE_FULL, "GLSL.std.450")
+ MAKE_TEST_SV_U_8136("min", GLSLstd450UMin, min, FILTER_NONE, RANGE_FULL, "GLSL.std.450")
+ MAKE_TEST_SV_I_8136("max", GLSLstd450SMax, max, FILTER_NONE, RANGE_FULL, "GLSL.std.450")
+ MAKE_TEST_SV_U_8136("max", GLSLstd450UMax, max, FILTER_NONE, RANGE_FULL, "GLSL.std.450")
+ MAKE_TEST_SV_I_8136("clamp", GLSLstd450SClamp, clamp, FILTER_MIN_GT_MAX, RANGE_FULL, "GLSL.std.450")
+ MAKE_TEST_SV_U_8136("clamp", GLSLstd450UClamp, clamp, FILTER_MIN_GT_MAX, RANGE_FULL, "GLSL.std.450")
+ MAKE_TEST_SV_I_3("find_lsb", GLSLstd450FindILsb, lsb, FILTER_NONE, RANGE_FULL, "GLSL.std.450")
+ MAKE_TEST_SV_I_3("find_msb", GLSLstd450FindSMsb, msb, FILTER_NONE, RANGE_FULL, "GLSL.std.450")
+ MAKE_TEST_SV_U_3("find_msb", GLSLstd450FindUMsb, msb, FILTER_NONE, RANGE_FULL, "GLSL.std.450")
+ MAKE_TEST_SV_I_1("mul_sdiv", DE_NULL, mul_div, FILTER_ZERO, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_U_1("mul_udiv", DE_NULL, mul_div, FILTER_ZERO, RANGE_FULL, DE_NULL)
+
+ MAKE_TEST_SV_U_8136_W("shift_right_logical", SpvOpShiftRightLogical, lsr, FILTER_NONE, RANGE_BIT_WIDTH, DE_NULL)
+ MAKE_TEST_SV_I_8136_W("shift_right_logical", SpvOpShiftRightLogical, lsr, FILTER_NONE, RANGE_BIT_WIDTH, DE_NULL)
+ MAKE_TEST_SV_U_8136_W("shift_right_arithmetic", SpvOpShiftRightArithmetic, asr, FILTER_NONE, RANGE_BIT_WIDTH, DE_NULL)
+ MAKE_TEST_SV_I_8136_W("shift_right_arithmetic", SpvOpShiftRightArithmetic, asr, FILTER_NONE, RANGE_BIT_WIDTH, DE_NULL)
+ MAKE_TEST_SV_U_8136_W("shift_left_logical", SpvOpShiftLeftLogical, lsl, FILTER_NONE, RANGE_BIT_WIDTH, DE_NULL)
+ MAKE_TEST_SV_I_8136_W("shift_left_logical", SpvOpShiftLeftLogical, lsl, FILTER_NONE, RANGE_BIT_WIDTH, DE_NULL)
+
+ MAKE_TEST_SV_U_8136("bitwise_or", SpvOpBitwiseOr, bitwise_or, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_I_8136("bitwise_or", SpvOpBitwiseOr, bitwise_or , FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_U_8136("bitwise_xor", SpvOpBitwiseXor, bitwise_xor, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_I_8136("bitwise_xor", SpvOpBitwiseXor, bitwise_xor, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_U_8136("bitwise_and", SpvOpBitwiseAnd, bitwise_and, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_I_8136("bitwise_and", SpvOpBitwiseAnd, bitwise_and, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_U_8136("not", SpvOpNot, not, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_I_8136("not", SpvOpNot, not, FILTER_NONE, RANGE_FULL, DE_NULL)
+
+ MAKE_TEST_SV_U_8136_N("iequal", SpvOpIEqual, iequal, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_I_8136_N("iequal", SpvOpIEqual, iequal, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_U_8136_N("inotequal", SpvOpINotEqual, inotequal, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_I_8136_N("inotequal", SpvOpINotEqual, inotequal, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_U_8136_N("ugreaterthan", SpvOpUGreaterThan, ugreaterthan, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_I_8136_N("ugreaterthan", SpvOpUGreaterThan, ugreaterthan, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_U_8136_N("sgreaterthan", SpvOpSGreaterThan, sgreaterthan, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_I_8136_N("sgreaterthan", SpvOpSGreaterThan, sgreaterthan, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_U_8136_N("ugreaterthanequal", SpvOpUGreaterThanEqual, ugreaterthanequal, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_I_8136_N("ugreaterthanequal", SpvOpUGreaterThanEqual, ugreaterthanequal, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_U_8136_N("sgreaterthanequal", SpvOpSGreaterThanEqual, sgreaterthanequal, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_I_8136_N("sgreaterthanequal", SpvOpSGreaterThanEqual, sgreaterthanequal, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_U_8136_N("ulessthan", SpvOpULessThan, ulessthan, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_I_8136_N("ulessthan", SpvOpULessThan, ulessthan, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_U_8136_N("slessthan", SpvOpSLessThan, slessthan, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_I_8136_N("slessthan", SpvOpSLessThan, slessthan, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_U_8136_N("ulessthanequal", SpvOpULessThanEqual, ulessthanequal, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_I_8136_N("ulessthanequal", SpvOpULessThanEqual, ulessthanequal, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_U_8136_N("slessthanequal", SpvOpSLessThanEqual, slessthanequal, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_I_8136_N("slessthanequal", SpvOpSLessThanEqual, slessthanequal, FILTER_NONE, RANGE_FULL, DE_NULL)
+
+ MAKE_TEST_SV_U_3_W("bit_field_insert", SpvOpBitFieldInsert, bitFieldInsert, FILTER_NONE, RANGE_BIT_WIDTH_SUM, DE_NULL)
+ MAKE_TEST_SV_I_3_W("bit_field_insert", SpvOpBitFieldInsert, bitFieldInsert, FILTER_NONE, RANGE_BIT_WIDTH_SUM, DE_NULL)
+ MAKE_TEST_SV_U_3_W("bit_field_s_extract", SpvOpBitFieldSExtract, bitFieldSExtract, FILTER_NONE, RANGE_BIT_WIDTH_SUM, DE_NULL)
+ MAKE_TEST_SV_I_3_W("bit_field_s_extract", SpvOpBitFieldSExtract, bitFieldSExtract, FILTER_NONE, RANGE_BIT_WIDTH_SUM, DE_NULL)
+ MAKE_TEST_SV_U_3_W("bit_field_u_extract", SpvOpBitFieldUExtract, bitFieldUExtract, FILTER_NONE, RANGE_BIT_WIDTH_SUM, DE_NULL)
+ MAKE_TEST_SV_I_3_W("bit_field_u_extract", SpvOpBitFieldUExtract, bitFieldUExtract, FILTER_NONE, RANGE_BIT_WIDTH_SUM, DE_NULL)
+ MAKE_TEST_SV_U_3("bit_reverse", SpvOpBitReverse, bitReverse, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_I_3("bit_reverse", SpvOpBitReverse, bitReverse, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_U_3("bit_count", SpvOpBitCount, bitCount, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_I_3("bit_count", SpvOpBitCount, bitCount, FILTER_NONE, RANGE_FULL, DE_NULL)
+
+ MAKE_TEST_S_U_8136("constant", SpvOpConstant, constant, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_S_I_8136("constant", SpvOpConstant, constant, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_V_U_8136("constant_composite", SpvOpConstantComposite, constant, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_V_I_8136("constant_composite", SpvOpConstantComposite, constant, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_V_U_8136("constant_null", SpvOpConstantNull, constant, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_V_I_8136("constant_null", SpvOpConstantNull, constant, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_U_8136("variable_initializer", SpvOpVariable, constant, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_SV_I_8136("variable_initializer", SpvOpVariable, constant, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_S_U_8136("spec_constant_initializer", SpvOpSpecConstant, constant, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_S_I_8136("spec_constant_initializer", SpvOpSpecConstant, constant, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_V_U_8136("spec_constant_composite_initializer", SpvOpSpecConstantComposite, constant, FILTER_NONE, RANGE_FULL, DE_NULL)
+ MAKE_TEST_V_I_8136("spec_constant_composite_initializer", SpvOpSpecConstantComposite, constant, FILTER_NONE, RANGE_FULL, DE_NULL)
int8Tests[0]->createSwitchTests();
int16Tests[0]->createSwitchTests();
{
const VkPhysicalDeviceFeatures& availableFeatures = context.getDeviceFeatures();
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, robustBufferAccess);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, fullDrawIndexUint32);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, imageCubeArray);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, independentBlend);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, geometryShader);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, tessellationShader);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, sampleRateShading);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, dualSrcBlend);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, logicOp);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, multiDrawIndirect);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, drawIndirectFirstInstance);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, depthClamp);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, depthBiasClamp);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, fillModeNonSolid);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, depthBounds);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, wideLines);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, largePoints);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, alphaToOne);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, multiViewport);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, samplerAnisotropy);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, textureCompressionETC2);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, textureCompressionASTC_LDR);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, textureCompressionBC);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, occlusionQueryPrecise);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, pipelineStatisticsQuery);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, vertexPipelineStoresAndAtomics);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, fragmentStoresAndAtomics);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderTessellationAndGeometryPointSize);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderImageGatherExtended);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderStorageImageExtendedFormats);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderStorageImageMultisample);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderStorageImageReadWithoutFormat);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderStorageImageWriteWithoutFormat);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderUniformBufferArrayDynamicIndexing);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderSampledImageArrayDynamicIndexing);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderStorageBufferArrayDynamicIndexing);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderStorageImageArrayDynamicIndexing);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderClipDistance);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderCullDistance);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderFloat64);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderInt64);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderInt16);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderResourceResidency);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderResourceMinLod);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, sparseBinding);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, sparseResidencyBuffer);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, sparseResidencyImage2D);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, sparseResidencyImage3D);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, sparseResidency2Samples);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, sparseResidency4Samples);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, sparseResidency8Samples);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, sparseResidency16Samples);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, sparseResidencyAliased);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, variableMultisampleRate);
- IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, inheritedQueries);
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, robustBufferAccess)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, fullDrawIndexUint32)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, imageCubeArray)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, independentBlend)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, geometryShader)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, tessellationShader)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, sampleRateShading)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, dualSrcBlend)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, logicOp)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, multiDrawIndirect)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, drawIndirectFirstInstance)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, depthClamp)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, depthBiasClamp)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, fillModeNonSolid)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, depthBounds)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, wideLines)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, largePoints)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, alphaToOne)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, multiViewport)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, samplerAnisotropy)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, textureCompressionETC2)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, textureCompressionASTC_LDR)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, textureCompressionBC)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, occlusionQueryPrecise)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, pipelineStatisticsQuery)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, vertexPipelineStoresAndAtomics)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, fragmentStoresAndAtomics)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderTessellationAndGeometryPointSize)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderImageGatherExtended)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderStorageImageExtendedFormats)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderStorageImageMultisample)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderStorageImageReadWithoutFormat)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderStorageImageWriteWithoutFormat)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderUniformBufferArrayDynamicIndexing)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderSampledImageArrayDynamicIndexing)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderStorageBufferArrayDynamicIndexing)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderStorageImageArrayDynamicIndexing)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderClipDistance)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderCullDistance)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderFloat64)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderInt64)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderInt16)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderResourceResidency)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, shaderResourceMinLod)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, sparseBinding)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, sparseResidencyBuffer)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, sparseResidencyImage2D)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, sparseResidencyImage3D)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, sparseResidency2Samples)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, sparseResidency4Samples)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, sparseResidency8Samples)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, sparseResidency16Samples)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, sparseResidencyAliased)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, variableMultisampleRate)
+ IS_CORE_FEATURE_AVAILABLE(toCheck, availableFeatures, inheritedQueries)
return true;
}
spec.requestedVulkanFeatures.extVariablePointers = EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS;
spec.extensions.push_back("VK_KHR_variable_pointers");
break;
- };
+ }
if (testParams[paramIdx].type == "matrix")
{
DE_NULL // const deUint32* pCorrelatedViewMasks
};
- return vk::createRenderPass2(m_context.getDeviceInterface(), m_context.getDevice(), &renderPassInfo);;
+ return vk::createRenderPass2(m_context.getDeviceInterface(), m_context.getDevice(), &renderPassInfo);
}
Move<VkRenderPass> NoneStageTestInstance::buildComplexRenderPass(VkFormat intermediateFormat, VkImageLayout intermediateLayout, VkImageAspectFlags intermediateAspect,
*outQueueFamilyIndex = queueInfo.queueFamilyIndex;
return createCustomDevice(validationEnabled, vkp, instance, vki, physicalDevice, &deviceInfo);
-};
+}
struct BufferParameters
{
!!pImageMemoryBarrier, // deUint32 imageMemoryBarrierCount
pImageMemoryBarrier // const VkImageMemoryBarrier2KHR* pImageMemoryBarriers
};
-};
+}
PipelineCacheData::PipelineCacheData (void)
{
"Using additive blending to detect overlap.\n";
return new PassthroughTestInstance(context, params);
-};
+}
TestInstance* IdentityTessellationShaderTestCase::createInstance (Context& context) const
{
"Using additive blending to detect overlap.\n";
return new PassthroughTestInstance(context, params);
-};
+}
inline TestCase* makeIdentityGeometryShaderCase (tcu::TestContext& testCtx, const TessPrimitiveType primitiveType)
{
std::ostringstream str;
str << "winding mode " << getWindingShaderName(winding) << ", " << (usePointMode ? "" : "don't ") << "use point mode";
return str.str();
-};
+}
template <typename T, int N>
std::vector<T> arrayToVector (const T (&arr)[N])
TestInstance* createInstance (Context& context) const
{
return new OuterEdgeDivisionTestInstance(context, m_caseDef);
- };
+ }
void checkSupport (Context& context) const
{
TestInstance* createInstance (Context& context) const
{
return new OuterEdgeIndexIndependenceTestInstance(context, m_caseDef);
- };
+ }
void checkSupport (Context& context) const
{
TestInstance* createInstance (Context& context) const
{
return new SymmetricOuterEdgeTestInstance(context, m_caseDef);
- };
+ }
void checkSupport (Context& context) const
{
default:
DE_FATAL("Unexpected channel class.");
break;
- };
+ }
}
return floatFormats;
{
array.elementType = DE_NULL;
array.size = 0;
- };
+ }
} m_data;
};
{
array.elementType = DE_NULL;
array.size = 0;
- };
+ }
} m_data;
};
using const_pointer = const value_type*;
using const_iterator = const value_type*;
- inline constexpr ConstexprVector() noexcept : values{}, count{0} {};
+ inline constexpr ConstexprVector() noexcept : values{}, count{0} {}
/*--------------------------------------------------------------------*//*!
* MSVC v140 chokes on this if it is a raw variadic template list.
deviceInfo.pEnabledFeatures = enabledFeatures.pNext ? DE_NULL : &enabledFeatures.features;
return createDevice(vkp, instance, vki, physicalDevice, &deviceInfo);
-};
+}
} // anonymous
struct NoSupport0
{
- void checkSupport (Context&) const {};
+ void checkSupport (Context&) const {}
};
class FunctionSupport0
template<typename Arg0>
struct NoSupport1
{
- void checkSupport (Context&, Arg0) const {};
+ void checkSupport (Context&, Arg0) const {}
};
template<typename Arg0>
tcu::ConstPixelBufferAccess pixelBuffer = vk::getChannelAccess(compatibleFormatDescription, compatibleShaderGridSize, planeRowPitches, (const void* const*)planePointers, channelNdx);
std::ostringstream str;
str << "image" << channelNdx;
- context.getTestContext().getLog() << tcu::LogImage(str.str(), str.str(), pixelBuffer);;
+ context.getTestContext().getLog() << tcu::LogImage(str.str(), str.str(), pixelBuffer);
}
// verify data
for line in genBitfield64Src(bitfield64):
yield line
- for line in indentLines(["VK_DEFINE_PLATFORM_TYPE(%s,\t%s);" % (s[0], c) for n, s, c in PLATFORM_TYPES]):
+ for line in indentLines(["VK_DEFINE_PLATFORM_TYPE(%s,\t%s)" % (s[0], c) for n, s, c in PLATFORM_TYPES]):
yield line
for ext in api.extensions:
volatile Dummy g_dummy;
-};
+}
template <typename T, int Size>
static inline float floatMedian (const T (&v)[Size])
extern volatile Dummy g_dummy;
-};
+}
} // tcu
case 0x1b:
case 0x1f:
return -1;
- };
+ }
switch (src & 0x3)
{
case 1: return 1;
case 2: return (deInt8)(2 + ((src >> 2) & 0x7));
case 3: return (deInt8)(10 + ((src >> 2) & 0x7));
- };
+ }
return -1;
}
b[0] |= getBits128(low, high, 64, 59) << 10;
deltaBitsR = deltaBitsG = deltaBitsB = 4;
break;
- };
+ }
if (hasSign)
{
default:
DE_ASSERT(false);
- };
+ }
}
if (((mode == VERIFICATIONMODE_STRICT) && (missingPixels + unexpectedPixels > 0)) ||
#include <limits>
DE_INLINE double deToDouble (deFloat16 x) { return deFloat16To64(x); }
-DE_INLINE double deToDouble (float x) { return x; };
-DE_INLINE double deToDouble (double x) { return x; };
+DE_INLINE double deToDouble (float x) { return x; }
+DE_INLINE double deToDouble (double x) { return x; }
template <typename T>
inline T deToFloatType(double x)
// These helpers make the C helpers usable from templates. Because some of
// these deal with signaling NaN, it's important that no implicit float
// conversion operations happen.
-DE_INLINE deBool deIsPositiveZero (deFloat16 x) { return deHalfIsPositiveZero(x); };
-DE_INLINE deBool deIsPositiveZero (float x) { return deFloatIsPositiveZero(x); };
-DE_INLINE deBool deIsPositiveZero (double x) { return deDoubleIsPositiveZero(x); };
-DE_INLINE deBool deIsNegativeZero (deFloat16 x) { return deHalfIsNegativeZero(x); };
-DE_INLINE deBool deIsNegativeZero (float x) { return deFloatIsNegativeZero(x); };
-DE_INLINE deBool deIsNegativeZero (double x) { return deDoubleIsNegativeZero(x); };
-DE_INLINE deBool deIsIEEENaN (deFloat16 x) { return deHalfIsIEEENaN(x); };
-DE_INLINE deBool deIsIEEENaN (float x) { return deFloatIsIEEENaN(x); };
-DE_INLINE deBool deIsIEEENaN (double x) { return deDoubleIsIEEENaN(x); };
-DE_INLINE deBool deIsSignalingNaN (deFloat16 x) { return deHalfIsSignalingNaN(x); };
-DE_INLINE deBool deIsSignalingNaN (float x) { return deFloatIsSignalingNaN(x); };
-DE_INLINE deBool deIsSignalingNaN (double x) { return deDoubleIsSignalingNaN(x); };
-DE_INLINE deBool deIsQuietNaN (deFloat16 x) { return deHalfIsQuietNaN(x); };
-DE_INLINE deBool deIsQuietNaN (float x) { return deFloatIsQuietNaN(x); };
-DE_INLINE deBool deIsQuietNaN (double x) { return deDoubleIsQuietNaN(x); };
+DE_INLINE deBool deIsPositiveZero (deFloat16 x) { return deHalfIsPositiveZero(x); }
+DE_INLINE deBool deIsPositiveZero (float x) { return deFloatIsPositiveZero(x); }
+DE_INLINE deBool deIsPositiveZero (double x) { return deDoubleIsPositiveZero(x); }
+DE_INLINE deBool deIsNegativeZero (deFloat16 x) { return deHalfIsNegativeZero(x); }
+DE_INLINE deBool deIsNegativeZero (float x) { return deFloatIsNegativeZero(x); }
+DE_INLINE deBool deIsNegativeZero (double x) { return deDoubleIsNegativeZero(x); }
+DE_INLINE deBool deIsIEEENaN (deFloat16 x) { return deHalfIsIEEENaN(x); }
+DE_INLINE deBool deIsIEEENaN (float x) { return deFloatIsIEEENaN(x); }
+DE_INLINE deBool deIsIEEENaN (double x) { return deDoubleIsIEEENaN(x); }
+DE_INLINE deBool deIsSignalingNaN (deFloat16 x) { return deHalfIsSignalingNaN(x); }
+DE_INLINE deBool deIsSignalingNaN (float x) { return deFloatIsSignalingNaN(x); }
+DE_INLINE deBool deIsSignalingNaN (double x) { return deDoubleIsSignalingNaN(x); }
+DE_INLINE deBool deIsQuietNaN (deFloat16 x) { return deHalfIsQuietNaN(x); }
+DE_INLINE deBool deIsQuietNaN (float x) { return deFloatIsQuietNaN(x); }
+DE_INLINE deBool deIsQuietNaN (double x) { return deDoubleIsQuietNaN(x); }
template<typename T>
inline T deQuietNaN()
fileStream->status = DE_STREAMSTATUS_ERROR;
return DE_STREAMRESULT_ERROR;
break;
- };
+ }
}
static deStreamResult fileIOStream_write (deStreamData* stream, const void* buf, deInt32 bufSize, deInt32* numWritten)
fileStream->status = DE_STREAMSTATUS_ERROR;
return DE_STREAMRESULT_ERROR;
break;
- };
+ }
}
static const char* fileIOStream_getError (deStreamData* stream)
fileStream->error = DE_NULL;
if (!fileStream->file)
- fileStream->status = DE_STREAMSTATUS_ERROR;;
+ fileStream->status = DE_STREAMSTATUS_ERROR;
}
{
array.elementType = DE_NULL;
array.size = 0;
- };
+ }
} m_data;
} DE_WARN_UNUSED_TYPE;
default:
TCU_THROW(NotSupportedError, "WSI type not supported");
- };
+ }
}
bool VulkanPlatform::hasDisplay (vk::wsi::Type wsiType) const
{
default:
return false;
- };
+ }
}
vk::Library* VulkanPlatform::createLibrary (void) const
{
{
public:
LessOrEqualOp (GeneratorState& state, ConstValueRangeAccess valueRange);
- virtual ~LessOrEqualOp (void) {};
+ virtual ~LessOrEqualOp (void) {}
static float getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange);
};
{
public:
GreaterOrEqualOp (GeneratorState& state, ConstValueRangeAccess valueRange);
- virtual ~GreaterOrEqualOp (void) {};
+ virtual ~GreaterOrEqualOp (void) {}
static float getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange);
};
{
using namespace advblend;
-#define SAMPLE_REGISTER_ADV_BLEND(FUNCTION_NAME) \
- for (int regSampleNdx = 0; regSampleNdx < SAMPLE_REGISTER_SIZE; regSampleNdx++) \
- { \
- if (m_sampleRegister[regSampleNdx].isAlive) \
- { \
- SampleData& sample = m_sampleRegister[regSampleNdx]; \
- const Vec4& srcColor = sample.clampedBlendSrcColor; \
- const Vec4& dstColor = sample.clampedBlendDstColor; \
- const Vec3& bias = sample.blendSrcFactorRGB; \
- const float p0 = sample.blendSrcFactorA; \
- const float r = FUNCTION_NAME(srcColor[0], dstColor[0])*p0 + bias[0]; \
- const float g = FUNCTION_NAME(srcColor[1], dstColor[1])*p0 + bias[1]; \
- const float b = FUNCTION_NAME(srcColor[2], dstColor[2])*p0 + bias[2]; \
- \
- sample.blendedRGB = Vec3(r, g, b); \
- } \
- }
-
-#define SAMPLE_REGISTER_ADV_BLEND_HSL(COLOR_EXPRESSION) \
- for (int regSampleNdx = 0; regSampleNdx < SAMPLE_REGISTER_SIZE; regSampleNdx++) \
- { \
- if (m_sampleRegister[regSampleNdx].isAlive) \
- { \
- SampleData& sample = m_sampleRegister[regSampleNdx]; \
- const Vec3 srcColor = sample.clampedBlendSrcColor.swizzle(0,1,2); \
- const Vec3 dstColor = sample.clampedBlendDstColor.swizzle(0,1,2); \
- const Vec3& bias = sample.blendSrcFactorRGB; \
- const float p0 = sample.blendSrcFactorA; \
- \
- sample.blendedRGB = (COLOR_EXPRESSION)*p0 + bias; \
- } \
- }
+#define SAMPLE_REGISTER_ADV_BLEND(FUNCTION_NAME) \
+ do { \
+ for (int regSampleNdx = 0; regSampleNdx < SAMPLE_REGISTER_SIZE; regSampleNdx++) \
+ { \
+ if (m_sampleRegister[regSampleNdx].isAlive) \
+ { \
+ SampleData& sample = m_sampleRegister[regSampleNdx]; \
+ const Vec4& srcColor = sample.clampedBlendSrcColor; \
+ const Vec4& dstColor = sample.clampedBlendDstColor; \
+ const Vec3& bias = sample.blendSrcFactorRGB; \
+ const float p0 = sample.blendSrcFactorA; \
+ const float r = FUNCTION_NAME(srcColor[0], dstColor[0])*p0 + bias[0]; \
+ const float g = FUNCTION_NAME(srcColor[1], dstColor[1])*p0 + bias[1]; \
+ const float b = FUNCTION_NAME(srcColor[2], dstColor[2])*p0 + bias[2]; \
+ \
+ sample.blendedRGB = Vec3(r, g, b); \
+ } \
+ } \
+ } while (0)
+
+#define SAMPLE_REGISTER_ADV_BLEND_HSL(COLOR_EXPRESSION) \
+ do { \
+ for (int regSampleNdx = 0; regSampleNdx < SAMPLE_REGISTER_SIZE; regSampleNdx++) \
+ { \
+ if (m_sampleRegister[regSampleNdx].isAlive) \
+ { \
+ SampleData& sample = m_sampleRegister[regSampleNdx]; \
+ const Vec3 srcColor = sample.clampedBlendSrcColor.swizzle(0,1,2); \
+ const Vec3 dstColor = sample.clampedBlendDstColor.swizzle(0,1,2); \
+ const Vec3& bias = sample.blendSrcFactorRGB; \
+ const float p0 = sample.blendSrcFactorA; \
+ \
+ sample.blendedRGB = (COLOR_EXPRESSION)*p0 + bias; \
+ } \
+ } \
+ } while (0)
// Pre-compute factors & compute alpha \todo [2014-03-18 pyry] Re-using variable names.
// \note clampedBlend*Color contains clamped & unpremultiplied colors
const std::vector<VertexOutputInfo>& getOutputs (void) const { return m_outputs; }
protected:
- ~VertexShader (void) {}; // \note Renderer will not delete any objects passed in.
+ ~VertexShader (void) {} // \note Renderer will not delete any objects passed in.
std::vector<VertexInputInfo> m_inputs;
std::vector<VertexOutputInfo> m_outputs;
virtual void shadeFragments (FragmentPacket* packets, const int numPackets, const FragmentShadingContext& context) const = 0; // \note numPackets must be greater than zero.
protected:
- ~FragmentShader (void) {}; // \note Renderer will not delete any objects passed in.
+ ~FragmentShader (void) {} // \note Renderer will not delete any objects passed in.
std::vector<FragmentInputInfo> m_inputs;
std::vector<FragmentOutputInfo> m_outputs;
TCU_THROW(NotSupportedError, "Native pixmap doesn't support eglCreatePlatformPixmapSurface()");
}
break;
- };
+ }
log << TestLog::Message << "Creating pixmap surface with config ID " << id << TestLog::EndMessage;
EGLU_CHECK_MSG(egl, "init");
default:
DE_ASSERT(false);
isOk = false;
- };
+ }
}
if (notSupported)
default:
DE_ASSERT(false);
isOk = false;
- };
+ }
}
if (notSupported)
default:
DE_FATAL("Unknown modify type");
return false;
- };
+ }
default:
DE_FATAL("Unknown modify format");
default:
DE_ASSERT(false);
- };
+ }
}
}
default:
DE_ASSERT(false);
- };
+ }
}
else
{
class Params
{
public:
- Params (void) {};
+ Params (void) {}
Params (const string& name,
const string& description,
ContextReset (glw::Functions& gl, tcu::TestLog& log, ShaderType shaderType);
ContextReset (glw::Functions& gl, tcu::TestLog& log, ShaderType shaderType, ResourceType resourceType, ReadWriteType readWriteType);
- virtual ~ContextReset (void) {};
+ virtual ~ContextReset (void) {}
virtual void setup (void) = 0;
virtual void draw (void) = 0;
public:
ContextResetCase (EglTestContext& eglTestCtx, const char* name, const char* description, Params params);
- virtual ~ContextResetCase (void) {};
+ virtual ~ContextResetCase (void) {}
virtual void provokeReset (de::SharedPtr<ContextReset>& contextReset) = 0;
virtual void waitForReset (de::SharedPtr<ContextReset>& contextReset) = 0;
}
TCU_CHECK(m_sync == eglNoSync);
- };
+ }
IterateResult iterate (void)
{
}
TCU_CHECK(m_sync == eglNoSync);
- };
+ }
IterateResult iterate (void)
{
TCU_CHECK(status == condSatisfied);
EGLU_CHECK_MSG(egl, clientWaitSyncMsgChk.c_str());
- };
+ }
IterateResult iterate (void)
{
TestLog::EndMessage;
TCU_CHECK(result == condSatisfied);
- };
+ }
IterateResult iterate (void)
{
TCU_CHECK(result == EGL_FALSE);
TCU_CHECK(condition == 0xF0F0F);
- };
+ }
IterateResult iterate (void)
{
wrapModes[wrapMode].mode,
formats[format].format, formats[format].dataType,
sizes2D[size].width, sizes2D[size].height));
- })))));
+ })))))
// Cubemap cases.
FOR_EACH(minFilter, minFilterModes,
wrapModes[wrapMode].mode,
formats[format].format, formats[format].dataType,
sizesCube[size].width, sizesCube[size].height));
- })))));
+ })))))
}
} // Accuracy
StateVerifier* m_verifier;
};
-#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
- for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
- { \
- StateVerifier* verifier = (VERIFIERS)[_verifierNdx]; \
- CODE_BLOCK; \
- }
+#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
+ do { \
+ for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
+ { \
+ StateVerifier* verifier = (VERIFIERS)[_verifierNdx]; \
+ CODE_BLOCK; \
+ } \
+ } while (0)
} // anonymous
m_verifierInt = new GetBufferParameterIVerifier (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
BufferParamVerifier* verifiers[] = {m_verifierInt};
- FOR_EACH_VERIFIER(verifiers, addChild(new BufferSizeCase (m_context, verifier, (std::string("buffer_size") + verifier->getTestNamePostfix()).c_str(), "BUFFER_SIZE")));
- FOR_EACH_VERIFIER(verifiers, addChild(new BufferUsageCase (m_context, verifier, (std::string("buffer_usage") + verifier->getTestNamePostfix()).c_str(), "BUFFER_USAGE")));
+ FOR_EACH_VERIFIER(verifiers, addChild(new BufferSizeCase (m_context, verifier, (std::string("buffer_size") + verifier->getTestNamePostfix()).c_str(), "BUFFER_SIZE")))
+ FOR_EACH_VERIFIER(verifiers, addChild(new BufferUsageCase (m_context, verifier, (std::string("buffer_usage") + verifier->getTestNamePostfix()).c_str(), "BUFFER_USAGE")))
}
void BufferObjectQueryTests::deinit (void)
class FloatLoader
{
public:
- virtual ~FloatLoader (void) {};
+ virtual ~FloatLoader (void) {}
// returns the value loaded
virtual tcu::Vec4 load (glu::CallLogWrapper& gl, int index, const tcu::Vec4& v) const = 0;
RenderCommand renderCmd;
renderCmd.params.visibleFace = rr::FACETYPE_FRONT;
- renderCmd.params.depth = depthValues[y1*numL1CellsX + x1];;
+ renderCmd.params.depth = depthValues[y1*numL1CellsX + x1];
renderCmd.params.depthTestEnabled = true;
renderCmd.params.depthFunc = GL_ALWAYS;
renderCmd.params.depthWriteMask = true;
{
public:
StencilClearsTest (Context& context, const FboConfig& config);
- virtual ~StencilClearsTest (void) {};
+ virtual ~StencilClearsTest (void) {}
void render (sglr::Context& context, Surface& dst);
{
public:
StencilTest (Context& context, const FboConfig& config, bool npot = false);
- virtual ~StencilTest (void) {};
+ virtual ~StencilTest (void) {}
void render (sglr::Context& context, Surface& dst);
{
public:
SharedColorbufferTest (Context& context, const FboConfig& config);
- virtual ~SharedColorbufferTest (void) {};
+ virtual ~SharedColorbufferTest (void) {}
void render (sglr::Context& context, Surface& dst);
};
{
public:
SharedDepthbufferTest (Context& context, const FboConfig& config);
- virtual ~SharedDepthbufferTest (void) {};
+ virtual ~SharedDepthbufferTest (void) {}
static bool isConfigSupported (const FboConfig& config);
void render (sglr::Context& context, Surface& dst);
StateVerifier* m_verifier;
};
-#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
- for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
- { \
- StateVerifier* verifier = (VERIFIERS)[_verifierNdx]; \
- CODE_BLOCK; \
- }
+#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
+ do { \
+ for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
+ { \
+ StateVerifier* verifier = (VERIFIERS)[_verifierNdx]; \
+ CODE_BLOCK; \
+ } \
+ } while (0)
} // anonymous
}
}
-#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
- for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
- { \
- StateVerifier* verifier = (VERIFIERS)[_verifierNdx]; \
- CODE_BLOCK; \
- }
-
-#define FOR_EACH_QUERYTYPE(QUERYTYPES, CODE_BLOCK) \
- for (int _queryTypeNdx = 0; _queryTypeNdx < DE_LENGTH_OF_ARRAY(QUERYTYPES); _queryTypeNdx++) \
- { \
- const QueryType queryType = (QUERYTYPES)[_queryTypeNdx]; \
- CODE_BLOCK; \
- }
+#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
+ do { \
+ for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
+ { \
+ StateVerifier* verifier = (VERIFIERS)[_verifierNdx]; \
+ CODE_BLOCK; \
+ } \
+ } while (0)
+
+#define FOR_EACH_QUERYTYPE(QUERYTYPES, CODE_BLOCK) \
+ do { \
+ for (int _queryTypeNdx = 0; _queryTypeNdx < DE_LENGTH_OF_ARRAY(QUERYTYPES); _queryTypeNdx++) \
+ { \
+ const QueryType queryType = (QUERYTYPES)[_queryTypeNdx]; \
+ CODE_BLOCK; \
+ } \
+ } while (0) \
} // anonymous
a = (int)(deRandom_getUint32(&rnd) & 0xFF);
break;
- };
+ }
glClearColor(float(r)/255.0f, float(g)/255.0f, float(b)/255.0f, float(a)/255.0f);
glClear(GL_COLOR_BUFFER_BIT);
requirement = LOOPREQUIREMENT_DYNAMIC;
return new ShaderLoopCase(context, caseName, description, isVertexCase, evalFunc, requirement, vertexShaderSource.c_str(), fragmentShaderSource.c_str());
-};
+}
// ShaderLoopTests.
MAKE_EVAL_CASE(OP_SUB, IN0TYPE, IN0DATATYPE, IN1TYPE, IN1DATATYPE); \
MAKE_EVAL_CASE(OP_MUL, IN0TYPE, IN0DATATYPE, IN1TYPE, IN1DATATYPE); \
MAKE_EVAL_CASE(OP_DIV, IN0TYPE, IN0DATATYPE, IN1TYPE, IN1DATATYPE); \
- MAKE_EVAL_CASE(OP_COMP_MUL, IN0TYPE, IN0DATATYPE, IN1TYPE, IN1DATATYPE);
+ MAKE_EVAL_CASE(OP_COMP_MUL, IN0TYPE, IN0DATATYPE, IN1TYPE, IN1DATATYPE)
#define MUL_OP(IN0TYPE, IN0DATATYPE, IN1TYPE, IN1DATATYPE) \
MAKE_EVAL_CASE(OP_MUL, IN0TYPE, IN0DATATYPE, IN1TYPE, IN1DATATYPE)
#undef DEFINE_VEC_FLOAT_FLOAT_FUNCTION
#undef DEFINE_FLOAT_FLOAT_VEC_FUNCTION
-inline float addOne (float v) { return v + 1.0f; };
-inline float subOne (float v) { return v - 1.0f; };
-inline int addOne (int v) { return v + 1; };
-inline int subOne (int v) { return v - 1; };
+inline float addOne (float v) { return v + 1.0f; }
+inline float subOne (float v) { return v - 1.0f; }
+inline int addOne (int v) { return v + 1; }
+inline int subOne (int v) { return v - 1; }
-template<int Size> inline Vector<float, Size> addOne (const Vector<float, Size>& v) { return v + 1.0f; };
-template<int Size> inline Vector<float, Size> subOne (const Vector<float, Size>& v) { return v - 1.0f; };
-template<int Size> inline Vector<int, Size> addOne (const Vector<int, Size>& v) { return v + 1; };
-template<int Size> inline Vector<int, Size> subOne (const Vector<int, Size>& v) { return v - 1; };
+template<int Size> inline Vector<float, Size> addOne (const Vector<float, Size>& v) { return v + 1.0f; }
+template<int Size> inline Vector<float, Size> subOne (const Vector<float, Size>& v) { return v - 1.0f; }
+template<int Size> inline Vector<int, Size> addOne (const Vector<int, Size>& v) { return v + 1; }
+template<int Size> inline Vector<int, Size> subOne (const Vector<int, Size>& v) { return v - 1; }
-template<typename T> inline T selection (bool cond, T a, T b) { return cond ? a : b; };
+template<typename T> inline T selection (bool cond, T a, T b) { return cond ? a : b; }
-template<typename T, int Size> inline Vector<T, Size> addVecScalar (const Vector<T, Size>& v, T s) { return v + s; };
-template<typename T, int Size> inline Vector<T, Size> subVecScalar (const Vector<T, Size>& v, T s) { return v - s; };
-template<typename T, int Size> inline Vector<T, Size> mulVecScalar (const Vector<T, Size>& v, T s) { return v * s; };
-template<typename T, int Size> inline Vector<T, Size> divVecScalar (const Vector<T, Size>& v, T s) { return v / s; };
+template<typename T, int Size> inline Vector<T, Size> addVecScalar (const Vector<T, Size>& v, T s) { return v + s; }
+template<typename T, int Size> inline Vector<T, Size> subVecScalar (const Vector<T, Size>& v, T s) { return v - s; }
+template<typename T, int Size> inline Vector<T, Size> mulVecScalar (const Vector<T, Size>& v, T s) { return v * s; }
+template<typename T, int Size> inline Vector<T, Size> divVecScalar (const Vector<T, Size>& v, T s) { return v / s; }
-template<typename T, int Size> inline Vector<T, Size> addScalarVec (T s, const Vector<T, Size>& v) { return s + v; };
-template<typename T, int Size> inline Vector<T, Size> subScalarVec (T s, const Vector<T, Size>& v) { return s - v; };
-template<typename T, int Size> inline Vector<T, Size> mulScalarVec (T s, const Vector<T, Size>& v) { return s * v; };
-template<typename T, int Size> inline Vector<T, Size> divScalarVec (T s, const Vector<T, Size>& v) { return s / v; };
+template<typename T, int Size> inline Vector<T, Size> addScalarVec (T s, const Vector<T, Size>& v) { return s + v; }
+template<typename T, int Size> inline Vector<T, Size> subScalarVec (T s, const Vector<T, Size>& v) { return s - v; }
+template<typename T, int Size> inline Vector<T, Size> mulScalarVec (T s, const Vector<T, Size>& v) { return s * v; }
+template<typename T, int Size> inline Vector<T, Size> divScalarVec (T s, const Vector<T, Size>& v) { return s / v; }
// Reference functions for specific sequence operations for the sequence operator tests.
void eval_##GLSL_NAME##_bvec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(greaterThan(c.in[0].swizzle(2, 0, 1), Vec3(0.0f))).asFloat(); } \
void eval_##GLSL_NAME##_bvec4 (ShaderEvalContext& c) { c.color.xyzw() = FUNC_NAME(greaterThan(c.in[0].swizzle(1, 2, 3, 0), Vec4(0.0f))).asFloat(); }
-DECLARE_UNARY_SCALAR_BVEC_FUNCS(any, boolAny);
-DECLARE_UNARY_SCALAR_BVEC_FUNCS(all, boolAll);
+DECLARE_UNARY_SCALAR_BVEC_FUNCS(any, boolAny)
+DECLARE_UNARY_SCALAR_BVEC_FUNCS(all, boolAll)
void ShaderOperatorTests::init (void)
{
// \note Unused bits are set to 1, clear should mask them out
int mask = (1<<stencilBits)-1;
dst.push_back(StencilOp::clearStencil(targetStencil | ~mask));
- });
+ })
// Replace in different points
STENCIL_CASE(stencil_fail_replace, "Set stencil on stencil fail",
{
dst.push_back(StencilOp::quad(GL_NEVER, targetStencil, GL_ALWAYS, 0.0f, GL_REPLACE, GL_KEEP, GL_KEEP));
- });
+ })
STENCIL_CASE(depth_fail_replace, "Set stencil on depth fail",
{
dst.push_back(StencilOp::clearDepth(0.0f));
dst.push_back(StencilOp::quad(GL_ALWAYS, targetStencil, GL_LESS, 0.5f, GL_KEEP, GL_REPLACE, GL_KEEP));
- });
+ })
STENCIL_CASE(depth_pass_replace, "Set stencil on depth pass",
{
dst.push_back(StencilOp::quad(GL_ALWAYS, targetStencil, GL_LESS, 0.0f, GL_KEEP, GL_KEEP, GL_REPLACE));
- });
+ })
// Increment, decrement
STENCIL_CASE(incr_stencil_fail, "Increment on stencil fail",
}
else
dst.push_back(StencilOp::clearStencil(targetStencil));
- });
+ })
STENCIL_CASE(decr_stencil_fail, "Decrement on stencil fail",
{
int maxStencil = (1<<stencilBits)-1;
}
else
dst.push_back(StencilOp::clearStencil(targetStencil));
- });
+ })
STENCIL_CASE(incr_wrap_stencil_fail, "Increment (wrap) on stencil fail",
{
int maxStencil = (1<<stencilBits)-1;
dst.push_back(StencilOp::clearStencil((targetStencil-1)&maxStencil));
dst.push_back(StencilOp::quad(GL_EQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_INCR_WRAP, GL_KEEP, GL_KEEP));
- });
+ })
STENCIL_CASE(decr_wrap_stencil_fail, "Decrement (wrap) on stencil fail",
{
int maxStencil = (1<<stencilBits)-1;
dst.push_back(StencilOp::clearStencil((targetStencil+1)&maxStencil));
dst.push_back(StencilOp::quad(GL_EQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_DECR_WRAP, GL_KEEP, GL_KEEP));
- });
+ })
// Zero, Invert
STENCIL_CASE(zero_stencil_fail, "Zero on stencil fail",
dst.push_back(StencilOp::clearStencil(targetStencil));
dst.push_back(StencilOp::quad(GL_NOTEQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_ZERO, GL_KEEP, GL_KEEP));
dst.push_back(StencilOp::quad(GL_EQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_REPLACE, GL_KEEP, GL_KEEP));
- });
+ })
STENCIL_CASE(invert_stencil_fail, "Invert on stencil fail",
{
int mask = (1<<stencilBits)-1;
dst.push_back(StencilOp::clearStencil((~targetStencil)&mask));
dst.push_back(StencilOp::quad(GL_EQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_INVERT, GL_KEEP, GL_KEEP));
- });
+ })
// Comparison modes
STENCIL_CASE(cmp_equal, "Equality comparison",
dst.push_back(StencilOp::clearStencil(inv));
dst.push_back(StencilOp::quad(GL_EQUAL, inv, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INVERT));
dst.push_back(StencilOp::quad(GL_EQUAL, inv, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INVERT));
- });
+ })
STENCIL_CASE(cmp_not_equal, "Equality comparison",
{
int mask = (1<<stencilBits)-1;
dst.push_back(StencilOp::clearStencil(inv));
dst.push_back(StencilOp::quad(GL_NOTEQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INVERT));
dst.push_back(StencilOp::quad(GL_NOTEQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INVERT));
- });
+ })
STENCIL_CASE(cmp_less_than, "Less than comparison",
{
int maxStencil = (1<<stencilBits)-1;
}
else
dst.push_back(StencilOp::clearStencil(targetStencil));
- });
+ })
STENCIL_CASE(cmp_less_or_equal, "Less or equal comparison",
{
int maxStencil = (1<<stencilBits)-1;
}
else
dst.push_back(StencilOp::clearStencil(targetStencil));
- });
+ })
STENCIL_CASE(cmp_greater_than, "Greater than comparison",
{
if (targetStencil > 0)
}
else
dst.push_back(StencilOp::clearStencil(targetStencil));
- });
+ })
STENCIL_CASE(cmp_greater_or_equal, "Greater or equal comparison",
{
if (targetStencil > 0)
}
else
dst.push_back(StencilOp::clearStencil(targetStencil));
- });
+ })
STENCIL_CASE(cmp_mask_equal, "Equality comparison with mask",
{
int valMask = (1<<stencilBits)-1;
StencilOp op = StencilOp::quad(GL_EQUAL, (~targetStencil | ~mask) & valMask, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INVERT);
op.stencilMask = mask;
dst.push_back(op);
- });
+ })
}
} // Functional
{
public:
Tex2DCompletenessCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description);
- ~Tex2DCompletenessCase (void) {};
+ ~Tex2DCompletenessCase (void) {}
IterateResult iterate (void);
{
public:
TexCubeCompletenessCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description);
- ~TexCubeCompletenessCase (void) {};
+ ~TexCubeCompletenessCase (void) {}
IterateResult iterate (void);
wrapModes[wrapMode].mode,
formats[format].format, formats[format].dataType,
sizes2D[size].width, sizes2D[size].height));
- })))));
+ })))))
// 2D ETC1 texture cases.
{
wrapModes[wrapMode].mode,
wrapModes[wrapMode].mode,
filenames));
- })));
+ })))
}
// Cubemap cases.
wrapModes[wrapMode].mode,
formats[format].format, formats[format].dataType,
sizesCube[size].width, sizesCube[size].height));
- })))));
+ })))))
// Cubemap ETC1 cases
{
GL_CLAMP_TO_EDGE,
GL_CLAMP_TO_EDGE,
filenames));
- }));
+ }))
}
}
} // anonymous
-#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
- for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
- { \
- TexParamVerifier* verifier = (VERIFIERS)[_verifierNdx]; \
- CODE_BLOCK; \
- }
+#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
+ do { \
+ for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
+ { \
+ TexParamVerifier* verifier = (VERIFIERS)[_verifierNdx]; \
+ CODE_BLOCK; \
+ } \
+ } while (0)
TextureStateQueryTests::TextureStateQueryTests (Context& context)
: TestCaseGroup (context, "texture", "Texture State Query tests")
filteringModes[filter].mode, filteringModes[filter].mode,
sizes[size].width, sizes[size].height));
- })))));
+ })))))
// Power-of-two ETC1 texture
std::vector<std::string> potFilenames;
filteringModes[filter].mode, filteringModes[filter].mode,
potFilenames));
- })));
+ })))
std::vector<std::string> npotFilenames;
npotFilenames.push_back("data/etc1/photo_helsinki_113x89.pkm");
vector<const StructType*> m_structTypes;
};
-}; // anonymous
+} // anonymous
static VarValue getSamplerFillValue (const VarValue& sampler)
{
magFilterModes[magFilter].mode,
wrapModes[wrapMode].mode,
wrapModes[wrapMode].mode));
- })));
+ })))
FOR_EACH(wrapSMode, wrapModes,
FOR_EACH(wrapTMode, wrapModes,
GL_LINEAR,
wrapModes[wrapSMode].mode,
wrapModes[wrapTMode].mode));
- }));
+ }))
// Cube map cases.
magFilterModes[magFilter].mode,
wrapModes[wrapMode].mode,
wrapModes[wrapMode].mode));
- })));
+ })))
FOR_EACH(wrapSMode, wrapModes,
FOR_EACH(wrapTMode, wrapModes,
GL_LINEAR,
wrapModes[wrapSMode].mode,
wrapModes[wrapTMode].mode));
- }));
+ }))
}
} // Functional
string statNamePrefix = isEntireRange ? "" : "LowestHalf";
float rangeSizeRatio = isEntireRange ? 1.0f : 0.5f;
-#define LOG_TIME(NAME, DESC, DATA) log << TestLog::Float(statNamePrefix + (NAME) + singular, singular + " of " + (DESC), "ms", QP_KEY_TAG_TIME, func(vectorLowestPercentage((DATA), rangeSizeRatio))/1000.0f);
+#define LOG_TIME(NAME, DESC, DATA) log << TestLog::Float(statNamePrefix + (NAME) + singular, singular + " of " + (DESC), "ms", QP_KEY_TAG_TIME, func(vectorLowestPercentage((DATA), rangeSizeRatio))/1000.0f)
log << TestLog::Message << (isEntireRange ? "For all measurements:" : "\nFor only the lowest 50% of the measurements:") << TestLog::EndMessage;
LOG_TIME("ShaderSourceSetTime", "shader source set time", sourceSetTimes);
string statNamePrefix = isEntireRange ? "" : "LowestHalf";
float rangeSizeRatio = isEntireRange ? 1.0f : 0.5f;
-#define LOG_TIME(NAME, DESC, DATA) log << TestLog::Float(statNamePrefix + (NAME) + singular, singular + " of " + (DESC), "ms", QP_KEY_TAG_TIME, func(vectorLowestPercentage((DATA), rangeSizeRatio))/1000.0f);
+#define LOG_TIME(NAME, DESC, DATA) log << TestLog::Float(statNamePrefix + (NAME) + singular, singular + " of " + (DESC), "ms", QP_KEY_TAG_TIME, func(vectorLowestPercentage((DATA), rangeSizeRatio))/1000.0f)
log << TestLog::Message << (isEntireRange ? "For all measurements:" : "\nFor only the lowest 50% of the measurements:") << TestLog::EndMessage;
LOG_TIME("ShaderSourceSetTime", "shader source set time", sourceSetTimes);
GL_BLEND,
GL_DITHER
})
- );
+ )
ADD_ARG_CASE1(disable, "Test cost of glDisable() calls",
disable,
GL_BLEND,
GL_DITHER
})
- );
+ )
ADD_ARG_CASE1(depth_func, "Test cost of glDepthFunc() calls",
depthFunc,
GL_GEQUAL,
GL_NOTEQUAL
})
- );
+ )
ADD_ARG_CASE1(depth_mask, "Test cost of glDepthMask() calls",
depthMask,
GL_TRUE,
GL_FALSE
})
- );
+ )
ADD_ARG_CASE1(stencil_mask, "Test cost of glStencilMask() calls",
stencilMask,
GL_TRUE,
GL_FALSE
})
- );
+ )
ADD_ARG_CASE1(clear_depth, "Test cost of glClearDepth() calls",
clearDepthf,
0.5f,
1.0f
})
- );
+ )
ADD_ARG_CASE1(clear_stencil, "Test cost of glClearStencil() calls",
clearStencil,
128,
28
})
- );
+ )
ADD_ARG_CASE1(line_width, "Test cost of glLineWidth() calls",
lineWidth,
0.5f,
10.0f
})
- );
+ )
ADD_ARG_CASE1(cull_face, "Test cost of glCullFace() calls",
cullFace,
GL_BACK,
GL_FRONT_AND_BACK
})
- );
+ )
ADD_ARG_CASE1(front_face, "Test cost of glFrontFace() calls",
frontFace,
GL_CCW,
GL_CW
})
- );
+ )
ADD_ARG_CASE1(blend_equation, "Test cost of glBlendEquation() calls",
blendEquation,
GL_FUNC_SUBTRACT,
GL_FUNC_REVERSE_SUBTRACT
})
- );
+ )
ADD_ARG_CASE1(enable_vertex_attrib_array, "Test cost of glEnableVertexAttribArray() calls",
enableVertexAttribArray,
6,
7,
})
- );
+ )
ADD_ARG_CASE1(disable_vertex_attrib_array, "Test cost of glDisableVertexAttribArray() calls",
disableVertexAttribArray,
6,
7,
})
- );
+ )
ADD_ARG_CASE1(use_program, "Test cost of glUseProgram() calls. Note: Uses only program 0.",
useProgram,
ARG_LIST({
0,
})
- );
+ )
ADD_ARG_CASE1(active_texture, "Test cost of glActiveTexture() calls",
activeTexture,
GL_TEXTURE6,
GL_TEXTURE7
})
- );
+ )
ADD_ARG_CASE2(depth_range, "Test cost of glDepthRangef() calls",
depthRangef,
1.0f,
0.5f
})
- );
+ )
ADD_ARG_CASE2(polygon_offset, "Test cost of glPolygonOffset() calls",
polygonOffset,
0.5f,
1000.0f
})
- );
+ )
ADD_ARG_CASE2(sample_coverage, "Test cost of glSampleCoverage() calls",
sampleCoverage,
GL_TRUE,
GL_FALSE
})
- );
+ )
ADD_ARG_CASE2(blend_func, "Test cost of glBlendFunc() calls",
blendFunc,
GL_CONSTANT_ALPHA,
GL_ONE_MINUS_CONSTANT_ALPHA
})
- );
+ )
ADD_ARG_CASE2(blend_equation_separate, "Test cost of glBlendEquationSeparate() calls",
blendEquationSeparate,
GL_FUNC_SUBTRACT,
GL_FUNC_REVERSE_SUBTRACT
})
- );
+ )
ADD_ARG_CASE2(stencil_mask_separate, "Test cost of glStencilMaskSeparate() calls",
stencilMaskSeparate,
GL_TRUE,
GL_FALSE
})
- );
+ )
ADD_ARG_CASE2(bind_buffer, "Test cost of glBindBuffer() calls. Note: Uses only buffer 0",
bindBuffer,
ARG_LIST({
0
})
- );
+ )
ADD_ARG_CASE2(bind_texture, "Test cost of glBindTexture() calls. Note: Uses only texture 0",
bindTexture,
ARG_LIST({
0
})
- );
+ )
ADD_ARG_CASE2(hint, "Test cost of glHint() calls",
hint,
GL_NICEST,
GL_DONT_CARE
})
- );
+ )
ADD_ARG_CASE3(stencil_func, "Test cost of glStencilFunc() calls",
stencilFunc,
7,
0xFFFFFFFF
})
- );
+ )
ADD_ARG_CASE3(stencil_op, "Test cost of glStencilOp() calls",
stencilOp,
GL_INCR_WRAP,
GL_DECR_WRAP
})
- );
+ )
ADD_ARG_CASE4(viewport, "Test cost of glViewport() calls",
viewport,
100,
1145235
})
- );
+ )
ADD_ARG_CASE4(scissor, "Test cost of glScissor() calls",
scissor,
100,
1145235
})
- );
+ )
ADD_ARG_CASE4(stencil_func_separate, "Test cost of glStencilFuncSeparate() calls",
stencilFuncSeparate,
7,
0xFFFFFFFF
})
- );
+ )
ADD_ARG_CASE4(stencil_op_separatae, "Test cost of glStencilOpSeparate() calls",
stencilOpSeparate,
GL_INCR_WRAP,
GL_DECR_WRAP
})
- );
+ )
ADD_ARG_CASE4(blend_func_separate, "Test cost of glBlendFuncSeparate() calls",
blendFuncSeparate,
GL_CONSTANT_ALPHA,
GL_ONE_MINUS_CONSTANT_ALPHA
})
- );
+ )
ADD_ARG_CASE4(color_mask, "Test cost of glColorMask() calls",
colorMask,
GL_TRUE,
GL_FALSE
})
- );
+ )
ADD_ARG_CASE4(clear_color, "Test cost of glClearColor() calls",
clearColor,
0.5f,
0.33f
})
- );
+ )
ADD_ARG_CASE6(vertex_attrib_pointer, "Test cost of glVertexAttribPointer() calls",
vertexAttribPointer,
(void*)(deUintptr)(0x0FF),
(void*)(deUintptr)(0x0EF)
})
- );
+ )
}
} // Performance
textureSizes[texSize].uploadCallGroup->addChild (new TextureUploadCallCase (m_context, caseName.c_str(), "", function, format, type, size));
textureSizes[texSize].uploadAndDrawGroup->addChild (new TextureUploadAndDrawCase (m_context, caseName.c_str(), "", function, format, type, size));
- })));
+ })))
for (int i = 0; i < DE_LENGTH_OF_ARRAY(textureSizes); i++)
{
namespace tcu
{
class WaiverUtil;
-};
+}
namespace deqp
{
wrapModes[wrapMode].mode,
formats[format].format,
sizes2D[size].width, sizes2D[size].height));
- })))));
+ })))))
// Cubemap cases.
FOR_EACH(minFilter, minFilterModes,
false,
formats[format].format,
sizesCube[size].width, sizesCube[size].height));
- })))));
+ })))))
}
} // Accuracy
}
};
-#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
- for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
- { \
- StateVerifier* verifier = (VERIFIERS)[_verifierNdx]; \
- CODE_BLOCK; \
- }
+#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
+ do { \
+ for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
+ { \
+ StateVerifier* verifier = (VERIFIERS)[_verifierNdx]; \
+ CODE_BLOCK; \
+ } \
+ } while (0)
} // anonymous
} // anonymous
-#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
- for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
- { \
- BufferParamVerifier* verifier = (VERIFIERS)[_verifierNdx]; \
- CODE_BLOCK; \
- }
+#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
+ do { \
+ for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
+ { \
+ BufferParamVerifier* verifier = (VERIFIERS)[_verifierNdx]; \
+ CODE_BLOCK; \
+ } \
+ } while (0)
BufferObjectQueryTests::BufferObjectQueryTests (Context& context)
: TestCaseGroup (context, "buffer_object", "Buffer Object Query tests")
class FloatLoader
{
public:
- virtual ~FloatLoader (void) {};
+ virtual ~FloatLoader (void) {}
// returns the value loaded
virtual tcu::Vec4 load (glu::CallLogWrapper& gl, int index, const tcu::Vec4& v) const = 0;
RenderCommand renderCmd;
renderCmd.params.visibleFace = rr::FACETYPE_FRONT;
- renderCmd.params.depth = depthValues[y1*numL1CellsX + x1];;
+ renderCmd.params.depth = depthValues[y1*numL1CellsX + x1];
renderCmd.params.depthTestEnabled = true;
renderCmd.params.depthFunc = GL_ALWAYS;
renderCmd.params.depthWriteMask = true;
{
public:
StencilClearsTest (Context& context, const FboConfig& config);
- virtual ~StencilClearsTest (void) {};
+ virtual ~StencilClearsTest (void) {}
void render (sglr::Context& context, Surface& dst);
};
{
public:
SharedColorbufferTest (Context& context, const FboConfig& config);
- virtual ~SharedColorbufferTest (void) {};
+ virtual ~SharedColorbufferTest (void) {}
void render (sglr::Context& context, Surface& dst);
};
{
public:
SharedDepthStencilTest (Context& context, const FboConfig& config);
- virtual ~SharedDepthStencilTest (void) {};
+ virtual ~SharedDepthStencilTest (void) {}
static bool isConfigSupported (const FboConfig& config);
void render (sglr::Context& context, Surface& dst);
case GL_R11F_G11F_B10F:
case GL_RG32F:
case GL_R32F:
- return glu::contextSupports(renderContext.getType(), glu::ApiType::es(3, 2));;
+ return glu::contextSupports(renderContext.getType(), glu::ApiType::es(3, 2));
default:
return false;
StateVerifier* m_verifier;
};
-#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
- for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
- { \
- StateVerifier* verifier = (VERIFIERS)[_verifierNdx]; \
- CODE_BLOCK; \
- }
+#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
+ do { \
+ for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
+ { \
+ StateVerifier* verifier = (VERIFIERS)[_verifierNdx]; \
+ CODE_BLOCK; \
+ } \
+ } while (0)
} // anonymous
StateVerifier* m_verifier;
};
-#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
- for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
- { \
- StateVerifier* verifier = (VERIFIERS)[_verifierNdx]; \
- CODE_BLOCK; \
- }
+#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
+ do { \
+ for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
+ { \
+ StateVerifier* verifier = (VERIFIERS)[_verifierNdx]; \
+ CODE_BLOCK; \
+ } \
+ } while (0)
} // anonymous
}
}
-#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
- for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
- { \
- StateVerifier* verifier = (VERIFIERS)[_verifierNdx]; \
- CODE_BLOCK; \
- }
-
-#define FOR_EACH_QUERYTYPE(QUERYTYPES, CODE_BLOCK) \
- for (int _queryTypeNdx = 0; _queryTypeNdx < DE_LENGTH_OF_ARRAY(QUERYTYPES); _queryTypeNdx++) \
- { \
- const QueryType queryType = (QUERYTYPES)[_queryTypeNdx]; \
- CODE_BLOCK; \
- }
+#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
+ do { \
+ for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
+ { \
+ StateVerifier* verifier = (VERIFIERS)[_verifierNdx]; \
+ CODE_BLOCK; \
+ } \
+ } while (0)
+
+#define FOR_EACH_QUERYTYPE(QUERYTYPES, CODE_BLOCK) \
+ do { \
+ for (int _queryTypeNdx = 0; _queryTypeNdx < DE_LENGTH_OF_ARRAY(QUERYTYPES); _queryTypeNdx++) \
+ { \
+ const QueryType queryType = (QUERYTYPES)[_queryTypeNdx]; \
+ CODE_BLOCK; \
+ } \
+ } while (0)
} // anonymous
m_program.draw(vao, 1.0, false, &dst);
log() << TestLog::Message << "// Drew an output image with VAO " << vao
<< TestLog::EndMessage;
-};
+}
class BufferTfAttacher : public Attacher
{
a = (int)(deRandom_getUint32(&rnd) & 0xFF);
break;
- };
+ }
glClearColor(float(r)/255.0f, float(g)/255.0f, float(b)/255.0f, float(a)/255.0f);
glClear(GL_COLOR_BUFFER_BIT);
std::string() + states[stateNdx].name + getVerifierSuffix(verifier),
states[stateNdx].desc,
verifier,
- states[stateNdx].tester)));
+ states[stateNdx].tester)))
}
}
// Create the case.
ShaderEvalFunc evalFunc = getLoopEvalFunc(numIters);
return new ShaderLoopCase(context, caseName, description, isVertexCase, evalFunc, vertexShaderSource.c_str(), fragmentShaderSource.c_str());
-};
+}
// ShaderLoopTests.
return res;
}
-inline float addOne (float v) { return v + 1.0f; };
-inline float subOne (float v) { return v - 1.0f; };
-inline int addOne (int v) { return v + 1; };
-inline int subOne (int v) { return v - 1; };
-inline deUint32 addOne (deUint32 v) { return v + 1; };
-inline deUint32 subOne (deUint32 v) { return v - 1; };
-
-template<int Size> inline Vector<float, Size> addOne (const Vector<float, Size>& v) { return v + 1.0f; };
-template<int Size> inline Vector<float, Size> subOne (const Vector<float, Size>& v) { return v - 1.0f; };
-template<int Size> inline Vector<int, Size> addOne (const Vector<int, Size>& v) { return v + 1; };
-template<int Size> inline Vector<int, Size> subOne (const Vector<int, Size>& v) { return v - 1; };
-template<int Size> inline Vector<deUint32, Size> addOne (const Vector<deUint32, Size>& v) { return v + 1U; };
-template<int Size> inline Vector<deUint32, Size> subOne (const Vector<deUint32, Size>& v) { return (v.asInt() - 1).asUint(); };
-
-template<typename T> inline T selection (bool cond, T a, T b) { return cond ? a : b; };
+inline float addOne (float v) { return v + 1.0f; }
+inline float subOne (float v) { return v - 1.0f; }
+inline int addOne (int v) { return v + 1; }
+inline int subOne (int v) { return v - 1; }
+inline deUint32 addOne (deUint32 v) { return v + 1; }
+inline deUint32 subOne (deUint32 v) { return v - 1; }
+
+template<int Size> inline Vector<float, Size> addOne (const Vector<float, Size>& v) { return v + 1.0f; }
+template<int Size> inline Vector<float, Size> subOne (const Vector<float, Size>& v) { return v - 1.0f; }
+template<int Size> inline Vector<int, Size> addOne (const Vector<int, Size>& v) { return v + 1; }
+template<int Size> inline Vector<int, Size> subOne (const Vector<int, Size>& v) { return v - 1; }
+template<int Size> inline Vector<deUint32, Size> addOne (const Vector<deUint32, Size>& v) { return v + 1U; }
+template<int Size> inline Vector<deUint32, Size> subOne (const Vector<deUint32, Size>& v) { return (v.asInt() - 1).asUint(); }
+
+template<typename T> inline T selection (bool cond, T a, T b) { return cond ? a : b; }
// Vec-scalar and scalar-vec binary operators.
// \note This one is done separately due to how the overloaded minus operator is implemented for vector-scalar operands.
-template<int Size> inline Vector<deUint32, Size> subVecScalar (const Vector<deUint32, Size>& v, deUint32 s) { return (v.asInt() - (int)s).asUint(); };
-
-template<typename T, int Size> inline Vector<T, Size> addVecScalar (const Vector<T, Size>& v, T s) { return v + s; };
-template<typename T, int Size> inline Vector<T, Size> subVecScalar (const Vector<T, Size>& v, T s) { return v - s; };
-template<typename T, int Size> inline Vector<T, Size> mulVecScalar (const Vector<T, Size>& v, T s) { return v * s; };
-template<typename T, int Size> inline Vector<T, Size> divVecScalar (const Vector<T, Size>& v, T s) { return v / s; };
-template<typename T, int Size> inline Vector<T, Size> modVecScalar (const Vector<T, Size>& v, T s) { return mod(v, Vector<T, Size>(s)); };
-template<typename T, int Size> inline Vector<T, Size> bitwiseAndVecScalar (const Vector<T, Size>& v, T s) { return bitwiseAnd(v, Vector<T, Size>(s)); };
-template<typename T, int Size> inline Vector<T, Size> bitwiseOrVecScalar (const Vector<T, Size>& v, T s) { return bitwiseOr(v, Vector<T, Size>(s)); };
-template<typename T, int Size> inline Vector<T, Size> bitwiseXorVecScalar (const Vector<T, Size>& v, T s) { return bitwiseXor(v, Vector<T, Size>(s)); };
-
-template<typename T, int Size> inline Vector<T, Size> addScalarVec (T s, const Vector<T, Size>& v) { return s + v; };
-template<typename T, int Size> inline Vector<T, Size> subScalarVec (T s, const Vector<T, Size>& v) { return s - v; };
-template<typename T, int Size> inline Vector<T, Size> mulScalarVec (T s, const Vector<T, Size>& v) { return s * v; };
-template<typename T, int Size> inline Vector<T, Size> divScalarVec (T s, const Vector<T, Size>& v) { return s / v; };
-template<typename T, int Size> inline Vector<T, Size> modScalarVec (T s, const Vector<T, Size>& v) { return mod(Vector<T, Size>(s), v); };
-template<typename T, int Size> inline Vector<T, Size> bitwiseAndScalarVec (T s, const Vector<T, Size>& v) { return bitwiseAnd(Vector<T, Size>(s), v); };
-template<typename T, int Size> inline Vector<T, Size> bitwiseOrScalarVec (T s, const Vector<T, Size>& v) { return bitwiseOr(Vector<T, Size>(s), v); };
-template<typename T, int Size> inline Vector<T, Size> bitwiseXorScalarVec (T s, const Vector<T, Size>& v) { return bitwiseXor(Vector<T, Size>(s), v); };
+template<int Size> inline Vector<deUint32, Size> subVecScalar (const Vector<deUint32, Size>& v, deUint32 s) { return (v.asInt() - (int)s).asUint(); }
+
+template<typename T, int Size> inline Vector<T, Size> addVecScalar (const Vector<T, Size>& v, T s) { return v + s; }
+template<typename T, int Size> inline Vector<T, Size> subVecScalar (const Vector<T, Size>& v, T s) { return v - s; }
+template<typename T, int Size> inline Vector<T, Size> mulVecScalar (const Vector<T, Size>& v, T s) { return v * s; }
+template<typename T, int Size> inline Vector<T, Size> divVecScalar (const Vector<T, Size>& v, T s) { return v / s; }
+template<typename T, int Size> inline Vector<T, Size> modVecScalar (const Vector<T, Size>& v, T s) { return mod(v, Vector<T, Size>(s)); }
+template<typename T, int Size> inline Vector<T, Size> bitwiseAndVecScalar (const Vector<T, Size>& v, T s) { return bitwiseAnd(v, Vector<T, Size>(s)); }
+template<typename T, int Size> inline Vector<T, Size> bitwiseOrVecScalar (const Vector<T, Size>& v, T s) { return bitwiseOr(v, Vector<T, Size>(s)); }
+template<typename T, int Size> inline Vector<T, Size> bitwiseXorVecScalar (const Vector<T, Size>& v, T s) { return bitwiseXor(v, Vector<T, Size>(s)); }
+
+template<typename T, int Size> inline Vector<T, Size> addScalarVec (T s, const Vector<T, Size>& v) { return s + v; }
+template<typename T, int Size> inline Vector<T, Size> subScalarVec (T s, const Vector<T, Size>& v) { return s - v; }
+template<typename T, int Size> inline Vector<T, Size> mulScalarVec (T s, const Vector<T, Size>& v) { return s * v; }
+template<typename T, int Size> inline Vector<T, Size> divScalarVec (T s, const Vector<T, Size>& v) { return s / v; }
+template<typename T, int Size> inline Vector<T, Size> modScalarVec (T s, const Vector<T, Size>& v) { return mod(Vector<T, Size>(s), v); }
+template<typename T, int Size> inline Vector<T, Size> bitwiseAndScalarVec (T s, const Vector<T, Size>& v) { return bitwiseAnd(Vector<T, Size>(s), v); }
+template<typename T, int Size> inline Vector<T, Size> bitwiseOrScalarVec (T s, const Vector<T, Size>& v) { return bitwiseOr(Vector<T, Size>(s), v); }
+template<typename T, int Size> inline Vector<T, Size> bitwiseXorScalarVec (T s, const Vector<T, Size>& v) { return bitwiseXor(Vector<T, Size>(s), v); }
// Reference functions for specific sequence operations for the sequence operator tests.
void eval_##GLSL_NAME##_bvec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(greaterThan(c.in[0].swizzle(2, 0, 1), Vec3(0.0f))).asFloat(); } \
void eval_##GLSL_NAME##_bvec4 (ShaderEvalContext& c) { c.color.xyzw() = FUNC_NAME(greaterThan(c.in[0].swizzle(1, 2, 3, 0), Vec4(0.0f))).asFloat(); }
-DECLARE_UNARY_SCALAR_BVEC_FUNCS(any, boolAny);
-DECLARE_UNARY_SCALAR_BVEC_FUNCS(all, boolAll);
+DECLARE_UNARY_SCALAR_BVEC_FUNCS(any, boolAny)
+DECLARE_UNARY_SCALAR_BVEC_FUNCS(all, boolAll)
void ShaderOperatorTests::init (void)
{
// \note Unused bits are set to 1, clear should mask them out
int mask = (1<<stencilBits)-1;
dst.push_back(StencilOp::clearStencil(targetStencil | ~mask));
- });
+ })
// Replace in different points
STENCIL_CASE(stencil_fail_replace, "Set stencil on stencil fail",
{
dst.push_back(StencilOp::quad(GL_NEVER, targetStencil, GL_ALWAYS, 0.0f, GL_REPLACE, GL_KEEP, GL_KEEP));
- });
+ })
STENCIL_CASE(depth_fail_replace, "Set stencil on depth fail",
{
dst.push_back(StencilOp::clearDepth(0.0f));
dst.push_back(StencilOp::quad(GL_ALWAYS, targetStencil, GL_LESS, 0.5f, GL_KEEP, GL_REPLACE, GL_KEEP));
- });
+ })
STENCIL_CASE(depth_pass_replace, "Set stencil on depth pass",
{
dst.push_back(StencilOp::quad(GL_ALWAYS, targetStencil, GL_LESS, 0.0f, GL_KEEP, GL_KEEP, GL_REPLACE));
- });
+ })
// Increment, decrement
STENCIL_CASE(incr_stencil_fail, "Increment on stencil fail",
}
else
dst.push_back(StencilOp::clearStencil(targetStencil));
- });
+ })
STENCIL_CASE(decr_stencil_fail, "Decrement on stencil fail",
{
int maxStencil = (1<<stencilBits)-1;
}
else
dst.push_back(StencilOp::clearStencil(targetStencil));
- });
+ })
STENCIL_CASE(incr_wrap_stencil_fail, "Increment (wrap) on stencil fail",
{
int maxStencil = (1<<stencilBits)-1;
dst.push_back(StencilOp::clearStencil((targetStencil-1)&maxStencil));
dst.push_back(StencilOp::quad(GL_EQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_INCR_WRAP, GL_KEEP, GL_KEEP));
- });
+ })
STENCIL_CASE(decr_wrap_stencil_fail, "Decrement (wrap) on stencil fail",
{
int maxStencil = (1<<stencilBits)-1;
dst.push_back(StencilOp::clearStencil((targetStencil+1)&maxStencil));
dst.push_back(StencilOp::quad(GL_EQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_DECR_WRAP, GL_KEEP, GL_KEEP));
- });
+ })
// Zero, Invert
STENCIL_CASE(zero_stencil_fail, "Zero on stencil fail",
dst.push_back(StencilOp::clearStencil(targetStencil));
dst.push_back(StencilOp::quad(GL_NOTEQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_ZERO, GL_KEEP, GL_KEEP));
dst.push_back(StencilOp::quad(GL_EQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_REPLACE, GL_KEEP, GL_KEEP));
- });
+ })
STENCIL_CASE(invert_stencil_fail, "Invert on stencil fail",
{
int mask = (1<<stencilBits)-1;
dst.push_back(StencilOp::clearStencil((~targetStencil)&mask));
dst.push_back(StencilOp::quad(GL_EQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_INVERT, GL_KEEP, GL_KEEP));
- });
+ })
// Comparison modes
STENCIL_CASE(cmp_equal, "Equality comparison",
dst.push_back(StencilOp::clearStencil(inv));
dst.push_back(StencilOp::quad(GL_EQUAL, inv, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INVERT));
dst.push_back(StencilOp::quad(GL_EQUAL, inv, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INVERT));
- });
+ })
STENCIL_CASE(cmp_not_equal, "Equality comparison",
{
int mask = (1<<stencilBits)-1;
dst.push_back(StencilOp::clearStencil(inv));
dst.push_back(StencilOp::quad(GL_NOTEQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INVERT));
dst.push_back(StencilOp::quad(GL_NOTEQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INVERT));
- });
+ })
STENCIL_CASE(cmp_less_than, "Less than comparison",
{
int maxStencil = (1<<stencilBits)-1;
}
else
dst.push_back(StencilOp::clearStencil(targetStencil));
- });
+ })
STENCIL_CASE(cmp_less_or_equal, "Less or equal comparison",
{
int maxStencil = (1<<stencilBits)-1;
}
else
dst.push_back(StencilOp::clearStencil(targetStencil));
- });
+ })
STENCIL_CASE(cmp_greater_than, "Greater than comparison",
{
if (targetStencil > 0)
}
else
dst.push_back(StencilOp::clearStencil(targetStencil));
- });
+ })
STENCIL_CASE(cmp_greater_or_equal, "Greater or equal comparison",
{
if (targetStencil > 0)
}
else
dst.push_back(StencilOp::clearStencil(targetStencil));
- });
+ })
STENCIL_CASE(cmp_mask_equal, "Equality comparison with mask",
{
int valMask = (1<<stencilBits)-1;
StencilOp op = StencilOp::quad(GL_EQUAL, (~targetStencil | ~mask) & valMask, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INVERT);
op.stencilMask = mask;
dst.push_back(op);
- });
+ })
}
} // Functional
states[stateNdx].desc,
verifier,
textureTargets[targetNdx].target,
- states[stateNdx].tester)));
+ states[stateNdx].tester)))
}
}
}
filteringModes[filter].mode, filteringModes[filter].mode,
rgba8Sizes[size].width, rgba8Sizes[size].height));
- }))));
+ }))))
}
}
filteringModes[filter].mode, filteringModes[filter].mode,
potFilenames));
- })));
+ })))
std::vector<std::string> npotFilenames;
npotFilenames.push_back("data/etc1/photo_helsinki_113x89.pkm");
wrapModes[wrapT].mode,
filteringModes[filter].mode, filteringModes[filter].mode,
npotFilenames));
- })));
+ })))
}
// ETC-2 (and EAC) cases.
wrapModes[wrapT].mode,
filteringModes[filter].mode, filteringModes[filter].mode,
etc2Sizes[size].width, etc2Sizes[size].height));
- }))));
+ }))))
}
}
wrapModes[wrapT].mode,
filteringModes[filter].mode, filteringModes[filter].mode,
formatSizes[size].width, formatSizes[size].height));
- }))));
+ }))))
}
}
}
vector<const StructType*> m_structTypes;
};
-}; // anonymous
+} // anonymous
static VarValue getSamplerFillValue (const VarValue& sampler)
{
default:
DE_ASSERT(false);
- };
+ }
}
itr += stride;
default:
DE_ASSERT(false);
- };
+ }
}
itr += stride;
spec.indexCount = 0;
spec.vao.attributes[0].normalized = GL_TRUE;
- spec.state.attributes[0].normalized = GL_FALSE;;
+ spec.state.attributes[0].normalized = GL_FALSE;
addChild(new VertexArrayObjectTest(m_context, spec, "diff_normalize", "diff_normalize"));
}
// DrawElements with buffer / Pointer
magFilterModes[magFilter].mode,
wrapModes[wrapMode].mode,
wrapModes[wrapMode].mode));
- })));
+ })))
FOR_EACH(wrapSMode, wrapModes,
FOR_EACH(wrapTMode, wrapModes,
GL_LINEAR,
wrapModes[wrapSMode].mode,
wrapModes[wrapTMode].mode));
- }));
+ }))
// Cube map cases.
magFilterModes[magFilter].mode,
wrapModes[wrapMode].mode,
wrapModes[wrapMode].mode));
- })));
+ })))
FOR_EACH(wrapSMode, wrapModes,
FOR_EACH(wrapTMode, wrapModes,
GL_LINEAR,
wrapModes[wrapSMode].mode,
wrapModes[wrapTMode].mode));
- }));
+ }))
// 2D array cases.
magFilterModes[magFilter].mode,
wrapModes[wrapMode].mode,
wrapModes[wrapMode].mode));
- })));
+ })))
FOR_EACH(wrapSMode, wrapModes,
FOR_EACH(wrapTMode, wrapModes,
GL_LINEAR,
wrapModes[wrapSMode].mode,
wrapModes[wrapTMode].mode));
- }));
+ }))
// 3D cases.
wrapModes[wrapMode].mode,
wrapModes[wrapMode].mode,
wrapModes[wrapMode].mode));
- })));
+ })))
FOR_EACH(wrapSMode, wrapModes,
FOR_EACH(wrapTMode, wrapModes,
wrapModes[wrapSMode].mode,
wrapModes[wrapTMode].mode,
wrapModes[wrapRMode].mode));
- })));
+ })))
}
} // Functional
void logAndSetTestResult (void);
void logSamples (void);
void drawMisc (void);
- int findStabilizationSample (deUint64 (Result::*target), const char* description);
- bool checkSampleTemporalStability (deUint64 (Result::*target), const char* description);
+ int findStabilizationSample (deUint64 Result::*target, const char* description);
+ bool checkSampleTemporalStability (deUint64 Result::*target, const char* description);
const DrawMethod m_drawMethod;
const TargetBuffer m_targetBuffer;
}
};
-int UploadWaitDrawCase::findStabilizationSample (deUint64 (UploadWaitDrawCase::Result::*target), const char* description)
+int UploadWaitDrawCase::findStabilizationSample (deUint64 UploadWaitDrawCase::Result::*target, const char* description)
{
std::vector<std::vector<deUint64> > sampleObservations(m_numMaxSwaps+1);
ThresholdComparer<deUint64> comparer;
return 0;
}
-bool UploadWaitDrawCase::checkSampleTemporalStability (deUint64 (UploadWaitDrawCase::Result::*target), const char* description)
+bool UploadWaitDrawCase::checkSampleTemporalStability (deUint64 UploadWaitDrawCase::Result::*target, const char* description)
{
// Try to find correlation with sample order and sample times
{
public:
RenderData (const ObjectData& object, const glu::RenderContext& renderCtx, TestLog& log);
- ~RenderData (void) {};
+ ~RenderData (void) {}
const glu::ShaderProgram m_program;
const glu::VertexArray m_vao;
string statNamePrefix = isEntireRange ? "" : "LowestHalf";
float rangeSizeRatio = isEntireRange ? 1.0f : 0.5f;
-#define LOG_TIME(NAME, DESC, DATA) log << TestLog::Float(statNamePrefix + (NAME) + singular, singular + " of " + (DESC), "ms", QP_KEY_TAG_TIME, func(vectorLowestPercentage((DATA), rangeSizeRatio))/1000.0f);
+#define LOG_TIME(NAME, DESC, DATA) log << TestLog::Float(statNamePrefix + (NAME) + singular, singular + " of " + (DESC), "ms", QP_KEY_TAG_TIME, func(vectorLowestPercentage((DATA), rangeSizeRatio))/1000.0f)
log << TestLog::Message << (isEntireRange ? "For all measurements:" : "\nFor only the lowest 50% of the measurements:") << TestLog::EndMessage;
LOG_TIME("ShaderSourceSetTime", "shader source set time", sourceSetTimes);
string statNamePrefix = isEntireRange ? "" : "LowestHalf";
float rangeSizeRatio = isEntireRange ? 1.0f : 0.5f;
-#define LOG_TIME(NAME, DESC, DATA) log << TestLog::Float(statNamePrefix + (NAME) + singular, singular + " of " + (DESC), "ms", QP_KEY_TAG_TIME, func(vectorLowestPercentage((DATA), rangeSizeRatio))/1000.0f);
+#define LOG_TIME(NAME, DESC, DATA) log << TestLog::Float(statNamePrefix + (NAME) + singular, singular + " of " + (DESC), "ms", QP_KEY_TAG_TIME, func(vectorLowestPercentage((DATA), rangeSizeRatio))/1000.0f)
log << TestLog::Message << (isEntireRange ? "For all measurements:" : "\nFor only the lowest 50% of the measurements:") << TestLog::EndMessage;
LOG_TIME("ShaderSourceSetTime", "shader source set time", sourceSetTimes);
GL_RASTERIZER_DISCARD,
GL_PRIMITIVE_RESTART_FIXED_INDEX
})
- );
+ )
ADD_ARG_CASE1(disable, "Test cost of glDisable() calls",
disable,
GL_RASTERIZER_DISCARD,
GL_PRIMITIVE_RESTART_FIXED_INDEX
})
- );
+ )
ADD_ARG_CASE1(depth_func, "Test cost of glDepthFunc() calls",
depthFunc,
GL_GEQUAL,
GL_NOTEQUAL
})
- );
+ )
ADD_ARG_CASE1(depth_mask, "Test cost of glDepthMask() calls",
depthMask,
GL_TRUE,
GL_FALSE
})
- );
+ )
ADD_ARG_CASE1(stencil_mask, "Test cost of glStencilMask() calls",
stencilMask,
GL_TRUE,
GL_FALSE
})
- );
+ )
ADD_ARG_CASE1(clear_depth, "Test cost of glClearDepth() calls",
clearDepthf,
0.5f,
1.0f
})
- );
+ )
ADD_ARG_CASE1(clear_stencil, "Test cost of glClearStencil() calls",
clearStencil,
128,
28
})
- );
+ )
ADD_ARG_CASE1(line_width, "Test cost of glLineWidth() calls",
lineWidth,
0.5f,
10.0f
})
- );
+ )
ADD_ARG_CASE1(cull_face, "Test cost of glCullFace() calls",
cullFace,
GL_BACK,
GL_FRONT_AND_BACK
})
- );
+ )
ADD_ARG_CASE1(front_face, "Test cost of glFrontFace() calls",
frontFace,
GL_CCW,
GL_CW
})
- );
+ )
ADD_ARG_CASE1(blend_equation, "Test cost of glBlendEquation() calls",
blendEquation,
GL_FUNC_SUBTRACT,
GL_FUNC_REVERSE_SUBTRACT
})
- );
+ )
ADD_ARG_CASE1(enable_vertex_attrib_array, "Test cost of glEnableVertexAttribArray() calls",
enableVertexAttribArray,
6,
7,
})
- );
+ )
ADD_ARG_CASE1(disable_vertex_attrib_array, "Test cost of glDisableVertexAttribArray() calls",
disableVertexAttribArray,
6,
7,
})
- );
+ )
ADD_ARG_CASE1(use_program, "Test cost of glUseProgram() calls. Note: Uses only program 0.",
useProgram,
ARG_LIST({
0,
})
- );
+ )
ADD_ARG_CASE1(active_texture, "Test cost of glActiveTexture() calls",
activeTexture,
GL_TEXTURE6,
GL_TEXTURE7
})
- );
+ )
ADD_ARG_CASE2(depth_range, "Test cost of glDepthRangef() calls",
depthRangef,
1.0f,
0.5f
})
- );
+ )
ADD_ARG_CASE2(polygon_offset, "Test cost of glPolygonOffset() calls",
polygonOffset,
0.5f,
1000.0f
})
- );
+ )
ADD_ARG_CASE2(sample_coverage, "Test cost of glSampleCoverage() calls",
sampleCoverage,
GL_TRUE,
GL_FALSE
})
- );
+ )
ADD_ARG_CASE2(blend_func, "Test cost of glBlendFunc() calls",
blendFunc,
GL_CONSTANT_ALPHA,
GL_ONE_MINUS_CONSTANT_ALPHA
})
- );
+ )
ADD_ARG_CASE2(blend_equation_separate, "Test cost of glBlendEquationSeparate() calls",
blendEquationSeparate,
GL_FUNC_SUBTRACT,
GL_FUNC_REVERSE_SUBTRACT
})
- );
+ )
ADD_ARG_CASE2(stencil_mask_separate, "Test cost of glStencilMaskSeparate() calls",
stencilMaskSeparate,
GL_TRUE,
GL_FALSE
})
- );
+ )
ADD_ARG_CASE2(bind_buffer, "Test cost of glBindBuffer() calls. Note: Uses only buffer 0",
bindBuffer,
ARG_LIST({
0
})
- );
+ )
ADD_ARG_CASE2(bind_texture, "Test cost of glBindTexture() calls. Note: Uses only texture 0",
bindTexture,
ARG_LIST({
0
})
- );
+ )
ADD_ARG_CASE2(bind_sampler, "Test cost of glBindSampler() calls. Note: Uses only sampler 0",
bindSampler,
ARG_LIST({
0
})
- );
+ )
ADD_ARG_CASE1(bind_vertex_array, "Test cost of glBindVertexArray() calls. Note: Uses only VAO 0",
bindVertexArray,
ARG_LIST({
0
})
- );
+ )
ADD_ARG_CASE2(hint, "Test cost of glHint() calls",
hint,
GL_NICEST,
GL_DONT_CARE
})
- );
+ )
ADD_ARG_CASE3(stencil_func, "Test cost of glStencilFunc() calls",
stencilFunc,
7,
0xFFFFFFFF
})
- );
+ )
ADD_ARG_CASE3(stencil_op, "Test cost of glStencilOp() calls",
stencilOp,
GL_INCR_WRAP,
GL_DECR_WRAP
})
- );
+ )
ADD_ARG_CASE4(viewport, "Test cost of glViewport() calls",
viewport,
100,
1145235
})
- );
+ )
ADD_ARG_CASE4(scissor, "Test cost of glScissor() calls",
scissor,
100,
1145235
})
- );
+ )
ADD_ARG_CASE4(stencil_func_separate, "Test cost of glStencilFuncSeparate() calls",
stencilFuncSeparate,
7,
0xFFFFFFFF
})
- );
+ )
ADD_ARG_CASE4(stencil_op_separatae, "Test cost of glStencilOpSeparate() calls",
stencilOpSeparate,
GL_INCR_WRAP,
GL_DECR_WRAP
})
- );
+ )
ADD_ARG_CASE4(blend_func_separate, "Test cost of glBlendFuncSeparate() calls",
blendFuncSeparate,
GL_CONSTANT_ALPHA,
GL_ONE_MINUS_CONSTANT_ALPHA
})
- );
+ )
ADD_ARG_CASE4(color_mask, "Test cost of glColorMask() calls",
colorMask,
GL_TRUE,
GL_FALSE
})
- );
+ )
ADD_ARG_CASE4(clear_color, "Test cost of glClearColor() calls",
clearColor,
0.5f,
0.33f
})
- );
+ )
ADD_ARG_CASE6(vertex_attrib_pointer, "Test cost of glVertexAttribPointer() calls",
vertexAttribPointer,
(void*)(deUintptr)(0x0FF),
(void*)(deUintptr)(0x0EF)
})
- );
+ )
ADD_ARG_CASE2(vertex_attrib_divisor, "Test cost of glVertexAttribDivisor() calls",
vertexAttribDivisor,
127,
256
})
- );
+ )
ADD_ARG_CASE3(bind_buffer_base, "Test cost of glBindBufferBase() calls. Note: uses only buffer 0.",
bindBufferBase,
ARG_LIST({
0
})
- );
+ )
ADD_ARG_CASE5(bind_buffer_range, "Test cost of glBindBufferRange() calls. Note: uses only buffer 0.",
bindBufferRange,
ARG_LIST({
0
})
- );
+ )
}
} // Performance
namespace tcu
{
class WaiverUtil;
-};
+}
namespace deqp
{
QUERY_FLOAT
};
-#define FOR_EACH_VERIFIER(VERIFIERS, X) \
- for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); ++verifierNdx) \
- { \
- const char* verifierSuffix = getVerifierSuffix((VERIFIERS)[verifierNdx]); \
- const QueryType verifier = (VERIFIERS)[verifierNdx]; \
- this->addChild(X); \
- }
+#define FOR_EACH_VERIFIER(VERIFIERS, X) \
+ do { \
+ for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); ++verifierNdx) \
+ { \
+ const char* verifierSuffix = getVerifierSuffix((VERIFIERS)[verifierNdx]); \
+ const QueryType verifier = (VERIFIERS)[verifierNdx]; \
+ this->addChild(X); \
+ } \
+ } while (0)
struct StateBoolean
{
bool nextCell (void);
IVec2 getOrigin (void) const;
- const IVec2& getCellSize (void) const { return m_cellSize; };
+ const IVec2& getCellSize (void) const { return m_cellSize; }
IVec4 getUsedAreaBoundingBox (void) const;
- int getCellCount (void) const { return m_cellCount; };
+ int getCellCount (void) const { return m_cellCount; }
private:
static IVec2 getRandomOffset (deUint32 seed, IVec2 targetSize, IVec2 cellSize, IVec2 grid, int cellCount);
if (!intThresholdCompare(log, cell.name.c_str(), cell.description.c_str(), cell.reference.getAccess(), resultAccess, threshold.toIVec().cast<deUint32>(), tcu::COMPARE_LOG_ON_ERROR))
results.fail("Image comparison of " + cell.description + " failed.");
else
- log << TestLog::Message << "Image comparison of " << cell.description << " passed." << TestLog::EndMessage;;
+ log << TestLog::Message << "Image comparison of " << cell.description << " passed." << TestLog::EndMessage;
}
}
}
default:
DE_ASSERT(false);
- };
+ }
}
void FragmentShader::shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const
default:
DE_ASSERT(DE_FALSE);
- };
+ }
}
}
}
default:
DE_ASSERT(DE_FALSE);
- };
+ }
stream << " o_drawBuffer" << drawBufferNdx << ";\n";
}
default:
DE_ASSERT(DE_FALSE);
- };
+ }
}
stream << "}";
QUERY_FRAMEBUFFER_INTEGER,
};
-#define FOR_EACH_VERIFIER(X) \
- for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(verifiers); ++verifierNdx) \
- { \
- const char* verifierSuffix = getVerifierSuffix(verifiers[verifierNdx]); \
- const QueryType verifier = verifiers[verifierNdx]; \
- this->addChild(X); \
- }
+#define FOR_EACH_VERIFIER(X) \
+ do { \
+ for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(verifiers); ++verifierNdx) \
+ { \
+ const char* verifierSuffix = getVerifierSuffix(verifiers[verifierNdx]); \
+ const QueryType verifier = verifiers[verifierNdx]; \
+ this->addChild(X); \
+ } \
+ } while (0)
FOR_EACH_VERIFIER(new FramebufferDimensionTest (m_context, verifier, FramebufferDimensionTest::DIMENSION_WIDTH, (std::string("framebuffer_default_width_") + verifierSuffix).c_str(), "Test FRAMEBUFFER_DEFAULT_WIDTH"));
FOR_EACH_VERIFIER(new FramebufferDimensionTest (m_context, verifier, FramebufferDimensionTest::DIMENSION_HEIGHT, (std::string("framebuffer_default_height_") + verifierSuffix).c_str(), "Test FRAMEBUFFER_DEFAULT_HEIGHT"));
default:
DE_ASSERT(DE_FALSE);
return false;
- };
+ }
}
bool LayeredRenderCase::verifyImageSingleColoredRow (const tcu::Surface& layer, float rowWidthRatio, const tcu::Vec4& barColor, bool logging)
}
void delete_renderbuffers (NegativeTestContext& ctx)
-{;
+{
ctx.beginSection("GL_INVALID_VALUE is generated if n is negative.");
ctx.glDeleteRenderbuffers(-1, 0);
ctx.expectError(GL_INVALID_VALUE);
bool matchesFilter (const glu::VariableDeclaration& variable) const;
bool matchesFilter (const glu::InterfaceBlock& block) const;
- deUint32 getShaderTypeBits (void) const { return m_shaderTypeBits; };
- deUint32 getStorageBits (void) const { return m_storageBits; };
+ deUint32 getShaderTypeBits (void) const { return m_shaderTypeBits; }
+ deUint32 getStorageBits (void) const { return m_storageBits; }
private:
deUint32 m_shaderTypeBits;
deUint32 m_storageBits;
default:
DE_ASSERT(false);
return 0;
- };
+ }
}
static bool isInterfaceBlockInterfaceName (const ProgramInterfaceDefinition::Program* program, ProgramInterface interface, const std::string& blockInterfaceName)
QUERY_PIPELINE_INTEGER,
};
-#define FOR_EACH_VERIFIER(X) \
- for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(verifiers); ++verifierNdx) \
- { \
- const char* verifierSuffix = getVerifierSuffix(verifiers[verifierNdx]); \
- const QueryType verifier = verifiers[verifierNdx]; \
- this->addChild(X); \
- }
+#define FOR_EACH_VERIFIER(X) \
+ do { \
+ for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(verifiers); ++verifierNdx) \
+ { \
+ const char* verifierSuffix = getVerifierSuffix(verifiers[verifierNdx]); \
+ const QueryType verifier = verifiers[verifierNdx]; \
+ this->addChild(X); \
+ } \
+ } while (0)
FOR_EACH_VERIFIER(new ActiveProgramCase(m_context, verifier, (std::string("active_program_") + verifierSuffix).c_str(), "Test ACTIVE_PROGRAM"));
FOR_EACH_VERIFIER(new PipelineProgramCase(m_context, verifier, (std::string("vertex_shader_") + verifierSuffix).c_str(), "Test VERTEX_SHADER", GL_VERTEX_SHADER));
QUERY_PROGRAM_INTEGER_VEC3,
};
-#define FOR_EACH_INT_VERIFIER(X) \
- for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(intVerifiers); ++verifierNdx) \
- { \
- const char* verifierSuffix = getVerifierSuffix(intVerifiers[verifierNdx]); \
- const QueryType verifier = intVerifiers[verifierNdx]; \
- this->addChild(X); \
- }
-
-#define FOR_EACH_VEC_VERIFIER(X) \
- for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(intVec3Verifiers); ++verifierNdx) \
- { \
- const char* verifierSuffix = getVerifierSuffix(intVec3Verifiers[verifierNdx]); \
- const QueryType verifier = intVec3Verifiers[verifierNdx]; \
- this->addChild(X); \
- }
+#define FOR_EACH_INT_VERIFIER(X) \
+ do { \
+ for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(intVerifiers); ++verifierNdx) \
+ { \
+ const char* verifierSuffix = getVerifierSuffix(intVerifiers[verifierNdx]); \
+ const QueryType verifier = intVerifiers[verifierNdx]; \
+ this->addChild(X); \
+ } \
+ } while (0)
+
+#define FOR_EACH_VEC_VERIFIER(X) \
+ do { \
+ for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(intVec3Verifiers); ++verifierNdx) \
+ { \
+ const char* verifierSuffix = getVerifierSuffix(intVec3Verifiers[verifierNdx]); \
+ const QueryType verifier = intVec3Verifiers[verifierNdx]; \
+ this->addChild(X); \
+ } \
+ } while (0)
FOR_EACH_INT_VERIFIER(new ProgramSeparableCase (m_context, verifier, (std::string("program_separable_") + verifierSuffix).c_str(), "Test PROGRAM_SEPARABLE"));
FOR_EACH_VEC_VERIFIER(new ComputeWorkGroupSizeCase (m_context, verifier, (std::string("compute_work_group_size_") + verifierSuffix).c_str(), "Test COMPUTE_WORK_GROUP_SIZE"));
vector<const StructType*> m_structTypes;
};
-}; // anonymous
+} // anonymous
static VarValue getSamplerFillValue (const VarValue& sampler)
{
, description (groupDescription)
, internalFormat (groupInternalFormat) {}
- ~TestGroupConfig (void) {};
+ ~TestGroupConfig (void) {}
const char* name;
const char* description;
std::string() + states[stateNdx].name + verifierSuffix,
states[stateNdx].desc,
verifier,
- states[stateNdx].tester));
+ states[stateNdx].tester))
}
else if (isIsVectorQuery(states[stateNdx].tester))
{
std::string() + states[stateNdx].name + verifierSuffix,
states[stateNdx].desc,
verifier,
- states[stateNdx].tester));
+ states[stateNdx].tester))
}
else
{
std::string() + states[stateNdx].name + verifierSuffix,
states[stateNdx].desc,
verifier,
- states[stateNdx].tester));
+ states[stateNdx].tester))
}
}
}
{
public:
TextureFormatTestCase (Context& context, const char* name, const char* desc, deUint32 format);
- ~TextureFormatTestCase (void) {};
+ ~TextureFormatTestCase (void) {}
IterateResult iterate (void);
{
public:
LastFragDataTestCase (Context& context, const char* name, const char* desc, deUint32 format);
- ~LastFragDataTestCase (void) {};
+ ~LastFragDataTestCase (void) {}
IterateResult iterate (void);
Program (Winding w, const SharedPtr<const ShaderProgram>& prog) : winding(w), program(prog) {}
- string description (void) const { return string() + "winding mode " + getWindingShaderName(winding); };
+ string description (void) const { return string() + "winding mode " + getWindingShaderName(winding); }
};
static const int RENDER_SIZE = 16;
Program (Winding w, bool point, const SharedPtr<const ShaderProgram>& prog) : winding(w), usePointMode(point), program(prog) {}
- string description (void) const { return string() + "winding mode " + getWindingShaderName(winding) + ", " + (usePointMode ? "" : "don't ") + "use point mode"; };
+ string description (void) const { return string() + "winding mode " + getWindingShaderName(winding) + ", " + (usePointMode ? "" : "don't ") + "use point mode"; }
};
static vector<float> generatePatchTessLevels (int numPatches, int constantOuterLevelIndex, float constantOuterLevel);
}
else if (isFixed)
{
- const bool isSigned = m_channelClass == tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT;;
+ const bool isSigned = m_channelClass == tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT;
const tcu::Vec4 lookupBias = (isSigned) ? (tcu::Vec4(0.5f)) : (tcu::Vec4(0.25f)); // scale & bias to [0.25, 0.5] range to make out-of-range values visible
const tcu::Vec4 lookupScale = (isSigned) ? (tcu::Vec4(0.25f)) : (tcu::Vec4(0.5f));
QUERY_TEXTURE_LEVEL_FLOAT,
};
-#define FOR_EACH_VERIFIER(X) \
- for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(verifiers); ++verifierNdx) \
- { \
- const std::string verifierSuffix = getVerifierSuffix(verifiers[verifierNdx]); \
- const QueryType verifier = verifiers[verifierNdx]; \
- targetGroup->addChild(X); \
- }
+#define FOR_EACH_VERIFIER(X) \
+ do { \
+ for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(verifiers); ++verifierNdx) \
+ { \
+ const std::string verifierSuffix = getVerifierSuffix(verifiers[verifierNdx]); \
+ const QueryType verifier = verifiers[verifierNdx]; \
+ targetGroup->addChild(X); \
+ } \
+ } while (0)
+
static const struct
{
const char* name;
states[stateNdx].desc,
verifier,
textureTargets[targetNdx].target,
- states[stateNdx].tester));
+ states[stateNdx].tester))
}
else if (isIsVectorQuery(states[stateNdx].tester))
{
states[stateNdx].desc,
verifier,
textureTargets[targetNdx].target,
- states[stateNdx].tester));
+ states[stateNdx].tester))
}
else
{
states[stateNdx].desc,
verifier,
textureTargets[targetNdx].target,
- states[stateNdx].tester));
+ states[stateNdx].tester))
}
}
}
namespace tcu
{
class WaiverUtil;
-};
+}
namespace deqp
{
namespace tcu
{
class WaiverUtil;
-};
+}
namespace deqp
{
return app<CLASS>(arg0, arg1, arg2, arg3); \
}
-DEFINE_DERIVED_FLOAT1(Sqrt, sqrt, x, constant(1.0f) / app<InverseSqrt>(x));
-DEFINE_DERIVED_FLOAT2(Pow, pow, x, y, exp2(y * log2(x)));
-DEFINE_DERIVED_FLOAT1(Radians, radians, d, (constant(DE_PI) / constant(180.0f)) * d);
-DEFINE_DERIVED_FLOAT1(Degrees, degrees, r, (constant(180.0f) / constant(DE_PI)) * r);
+DEFINE_DERIVED_FLOAT1(Sqrt, sqrt, x, constant(1.0f) / app<InverseSqrt>(x))
+DEFINE_DERIVED_FLOAT2(Pow, pow, x, y, exp2(y * log2(x)))
+DEFINE_DERIVED_FLOAT1(Radians, radians, d, (constant(DE_PI) / constant(180.0f)) * d)
+DEFINE_DERIVED_FLOAT1(Degrees, degrees, r, (constant(180.0f) / constant(DE_PI)) * r)
class TrigFunc : public CFloatFunc1
{
ExprP<float> cos (const ExprP<float>& x) { return app<Cos>(x); }
-DEFINE_DERIVED_FLOAT1(Tan, tan, x, sin(x) * (constant(1.0f) / cos(x)));
+DEFINE_DERIVED_FLOAT1(Tan, tan, x, sin(x) * (constant(1.0f) / cos(x)))
class ASin : public CFloatFunc1
{
// Codomain could be [-pi, pi], but that would probably be too strict.
};
-DEFINE_DERIVED_FLOAT1(Sinh, sinh, x, (exp(x) - exp(-x)) / constant(2.0f));
-DEFINE_DERIVED_FLOAT1(Cosh, cosh, x, (exp(x) + exp(-x)) / constant(2.0f));
-DEFINE_DERIVED_FLOAT1(Tanh, tanh, x, sinh(x) / cosh(x));
+DEFINE_DERIVED_FLOAT1(Sinh, sinh, x, (exp(x) - exp(-x)) / constant(2.0f))
+DEFINE_DERIVED_FLOAT1(Cosh, cosh, x, (exp(x) + exp(-x)) / constant(2.0f))
+DEFINE_DERIVED_FLOAT1(Tanh, tanh, x, sinh(x) / cosh(x))
// These are not defined as derived forms in the GLSL ES spec, but
// that gives us a reasonable precision.
-DEFINE_DERIVED_FLOAT1(ASinh, asinh, x, log(x + sqrt(x * x + constant(1.0f))));
+DEFINE_DERIVED_FLOAT1(ASinh, asinh, x, log(x + sqrt(x * x + constant(1.0f))))
DEFINE_DERIVED_FLOAT1(ACosh, acosh, x, log(x + sqrt(alternatives((x + constant(1.0f)) * (x - constant(1.0f)),
- (x*x - constant(1.0f))))));
+ (x*x - constant(1.0f))))))
DEFINE_DERIVED_FLOAT1(ATanh, atanh, x, constant(0.5f) * log((constant(1.0f) + x) /
- (constant(1.0f) - x)));
+ (constant(1.0f) - x)))
template <typename T>
class GetComponent : public PrimitiveFunc<Signature<typename T::Element, T, int> >
return i - alternatives((n * dotNI) * constant(2.0f),
n * (dotNI * constant(2.0f)));
- };
+ }
};
template<typename Ret, typename Arg0, typename Arg1>
return i - alternatives(alternatives((n * (n*i)) * constant(2.0f),
n * ((n*i) * constant(2.0f))),
(n * n) * (i * constant(2.0f)));
- };
+ }
};
template <int Size>
Ceil (void) : PreciseFunc1("ceil", deCeil) {}
};
-DEFINE_DERIVED_FLOAT1(Fract, fract, x, x - app<Floor>(x));
+DEFINE_DERIVED_FLOAT1(Fract, fract, x, x - app<Floor>(x))
class PreciseFunc2 : public CFloatFunc2
{
double precision (const EvalContext&, double, double, double) const { return 0.0; }
};
-DEFINE_DERIVED_FLOAT2(Mod, mod, x, y, x - y * app<Floor>(x / y));
+DEFINE_DERIVED_FLOAT2(Mod, mod, x, y, x - y * app<Floor>(x / y))
class Modf : public PrimitiveFunc<Signature<float, float, float> >
{
}
DEFINE_DERIVED_FLOAT3(Mix, mix, x, y, a, alternatives((x * (constant(1.0f) - a)) + y * a,
- x + (y - x) * a));
+ x + (y - x) * a))
static double step (double edge, double x)
{
if (inputLess(in1.d, in2.d))
return true;
return false;
- };
+ }
};
template<typename In>
DE_ASSERT(false);
return 0.0f;
break;
- };
+ }
}
GLValue GLValue::getMaxValue (DrawTestSpec::InputType type)
template<typename T>
inline T extractGLValue (const GLValue& v);
-template<> GLValue::Float inline extractGLValue<GLValue::Float> (const GLValue& v) { return v.fl; };
-template<> GLValue::Double inline extractGLValue<GLValue::Double> (const GLValue& v) { return v.d; };
-template<> GLValue::Byte inline extractGLValue<GLValue::Byte> (const GLValue& v) { return v.b; };
-template<> GLValue::Ubyte inline extractGLValue<GLValue::Ubyte> (const GLValue& v) { return v.ub; };
-template<> GLValue::Ushort inline extractGLValue<GLValue::Ushort> (const GLValue& v) { return v.us; };
-template<> GLValue::Short inline extractGLValue<GLValue::Short> (const GLValue& v) { return v.s; };
-template<> GLValue::Fixed inline extractGLValue<GLValue::Fixed> (const GLValue& v) { return v.fi; };
-template<> GLValue::Int inline extractGLValue<GLValue::Int> (const GLValue& v) { return v.i; };
-template<> GLValue::Uint inline extractGLValue<GLValue::Uint> (const GLValue& v) { return v.ui; };
-template<> GLValue::Half inline extractGLValue<GLValue::Half> (const GLValue& v) { return v.h; };
+template<> GLValue::Float inline extractGLValue<GLValue::Float> (const GLValue& v) { return v.fl; }
+template<> GLValue::Double inline extractGLValue<GLValue::Double> (const GLValue& v) { return v.d; }
+template<> GLValue::Byte inline extractGLValue<GLValue::Byte> (const GLValue& v) { return v.b; }
+template<> GLValue::Ubyte inline extractGLValue<GLValue::Ubyte> (const GLValue& v) { return v.ub; }
+template<> GLValue::Ushort inline extractGLValue<GLValue::Ushort> (const GLValue& v) { return v.us; }
+template<> GLValue::Short inline extractGLValue<GLValue::Short> (const GLValue& v) { return v.s; }
+template<> GLValue::Fixed inline extractGLValue<GLValue::Fixed> (const GLValue& v) { return v.fi; }
+template<> GLValue::Int inline extractGLValue<GLValue::Int> (const GLValue& v) { return v.i; }
+template<> GLValue::Uint inline extractGLValue<GLValue::Uint> (const GLValue& v) { return v.ui; }
+template<> GLValue::Half inline extractGLValue<GLValue::Half> (const GLValue& v) { return v.h; }
template<class T>
inline T getRandom (deRandom& rnd, T min, T max);
throw tcu::NotSupportedError("Unsupported attachment kind for attachment point",
"", __FILE__, __LINE__);
return *it;
-};
+}
Image* makeImage (GLenum bufType, ImageFormat format,
GLsizei width, GLsizei height, FboBuilder& builder)
struct Config
{
- virtual ~Config (void) {};
+ virtual ~Config (void) {}
};
struct Image : public Config
"Attachment name returned by query even after detachment.");
errors.check(!elemType.exists(elementId),
"Deleted attached object name still usable after detachment.");
-};
+}
class InputAttachmentTest : public TestBase
{
"Result of container modification on original attachment before deletion.",
refSurface);
return STOP;
-};
+}
struct LifeTestSpec
{
{
array.elementType = DE_NULL;
array.size = 0;
- };
+ }
} m_data;
};
DE_ASSERT(false);
return 0.0f;
break;
- };
+ }
}
class RandomArrayGenerator
projects / platform / upstream / VK-GL-CTS.git / commitdiff