Home | History | Annotate | Download | only in functional 
      1 /*-------------------------------------------------------------------------
      2  * drawElements Quality Program OpenGL ES 3.1 Module
      3  * -------------------------------------------------
      4  *
      5  * Copyright 2014 The Android Open Source Project
      6  *
      7  * Licensed under the Apache License, Version 2.0 (the "License");
      8  * you may not use this file except in compliance with the License.
      9  * You may obtain a copy of the License at
     10  *
     11  *      http://www.apache.org/licenses/LICENSE-2.0
     12  *
     13  * Unless required by applicable law or agreed to in writing, software
     14  * distributed under the License is distributed on an "AS IS" BASIS,
     15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     16  * See the License for the specific language governing permissions and
     17  * limitations under the License.
     18  *
     19  *//*!
     20  * \file
     21  * \brief Multisample interpolation state query tests
     22  *//*--------------------------------------------------------------------*/
     23 
     24 #include "es31fShaderMultisampleInterpolationStateQueryTests.hpp"
     25 #include "tcuTestLog.hpp"
     26 #include "gluCallLogWrapper.hpp"
     27 #include "gluContextInfo.hpp"
     28 #include "gluRenderContext.hpp"
     29 #include "glsStateQueryUtil.hpp"
     30 #include "glwEnums.hpp"
     31 #include "glwFunctions.hpp"
     32 
     33 
     34 namespace deqp
     35 {
     36 namespace gles31
     37 {
     38 namespace Functional
     39 {
     40 namespace
     41 {
     42 
     43 using namespace gls::StateQueryUtil;
     44 
     45 class InterpolationOffsetCase : public TestCase
     46 {
     47 public:
     48 	enum TestType
     49 	{
     50 		TEST_MIN_OFFSET = 0,
     51 		TEST_MAX_OFFSET,
     52 
     53 		TEST_LAST
     54 	};
     55 
     56 						InterpolationOffsetCase		(Context& context, const char* name, const char* desc, QueryType verifier, TestType testType);
     57 						~InterpolationOffsetCase	(void);
     58 
     59 	void				init						(void);
     60 	IterateResult		iterate						(void);
     61 
     62 private:
     63 	const QueryType		m_verifier;
     64 	const TestType		m_testType;
     65 };
     66 
     67 InterpolationOffsetCase::InterpolationOffsetCase (Context& context, const char* name, const char* desc, QueryType verifier, TestType testType)
     68 	: TestCase		(context, name, desc)
     69 	, m_verifier	(verifier)
     70 	, m_testType	(testType)
     71 {
     72 	DE_ASSERT(m_testType < TEST_LAST);
     73 }
     74 
     75 InterpolationOffsetCase::~InterpolationOffsetCase (void)
     76 {
     77 }
     78 
     79 void InterpolationOffsetCase::init (void)
     80 {
     81 	const bool supportsES32 = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2));
     82 
     83 	if (!supportsES32 && !m_context.getContextInfo().isExtensionSupported("GL_OES_shader_multisample_interpolation"))
     84 		throw tcu::NotSupportedError("Test requires GL_OES_shader_multisample_interpolation extension");
     85 }
     86 
     87 InterpolationOffsetCase::IterateResult InterpolationOffsetCase::iterate (void)
     88 {
     89 	glu::CallLogWrapper		gl		(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
     90 	tcu::ResultCollector	result	(m_testCtx.getLog(), " // ERROR: ");
     91 	gl.enableLogging(true);
     92 
     93 	if (m_testType == TEST_MAX_OFFSET)
     94 		verifyStateFloatMin(result, gl, GL_MAX_FRAGMENT_INTERPOLATION_OFFSET, 0.5, m_verifier);
     95 	else if (m_testType == TEST_MIN_OFFSET)
     96 		verifyStateFloatMax(result, gl, GL_MIN_FRAGMENT_INTERPOLATION_OFFSET, -0.5, m_verifier);
     97 	else
     98 		DE_ASSERT(false);
     99 
    100 	result.setTestContextResult(m_testCtx);
    101 	return STOP;
    102 }
    103 
    104 class FragmentInterpolationOffsetBitsCase : public TestCase
    105 {
    106 public:
    107 						FragmentInterpolationOffsetBitsCase		(Context& context, const char* name, const char* desc, QueryType verifier);
    108 						~FragmentInterpolationOffsetBitsCase	(void);
    109 
    110 	void				init									(void);
    111 	IterateResult		iterate									(void);
    112 
    113 private:
    114 	const QueryType		m_verifier;
    115 };
    116 
    117 FragmentInterpolationOffsetBitsCase::FragmentInterpolationOffsetBitsCase (Context& context, const char* name, const char* desc, QueryType verifier)
    118 	: TestCase		(context, name, desc)
    119 	, m_verifier	(verifier)
    120 {
    121 }
    122 
    123 FragmentInterpolationOffsetBitsCase::~FragmentInterpolationOffsetBitsCase (void)
    124 {
    125 }
    126 
    127 void FragmentInterpolationOffsetBitsCase::init (void)
    128 {
    129 	const bool supportsES32 = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2));
    130 
    131 	if (!supportsES32 && !m_context.getContextInfo().isExtensionSupported("GL_OES_shader_multisample_interpolation"))
    132 		throw tcu::NotSupportedError("Test requires GL_OES_shader_multisample_interpolation extension");
    133 }
    134 
    135 FragmentInterpolationOffsetBitsCase::IterateResult FragmentInterpolationOffsetBitsCase::iterate (void)
    136 {
    137 	glu::CallLogWrapper		gl		(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
    138 	tcu::ResultCollector	result	(m_testCtx.getLog(), " // ERROR: ");
    139 	gl.enableLogging(true);
    140 
    141 	verifyStateIntegerMin(result, gl, GL_FRAGMENT_INTERPOLATION_OFFSET_BITS, 4, m_verifier);
    142 
    143 	result.setTestContextResult(m_testCtx);
    144 	return STOP;
    145 }
    146 
    147 } // anonymous
    148 
    149 ShaderMultisampleInterpolationStateQueryTests::ShaderMultisampleInterpolationStateQueryTests (Context& context)
    150 	: TestCaseGroup(context, "multisample_interpolation", "Test multisample interpolation states")
    151 {
    152 }
    153 
    154 ShaderMultisampleInterpolationStateQueryTests::~ShaderMultisampleInterpolationStateQueryTests (void)
    155 {
    156 }
    157 
    158 void ShaderMultisampleInterpolationStateQueryTests::init (void)
    159 {
    160 	static const struct Verifier
    161 	{
    162 		QueryType		verifier;
    163 		const char*		name;
    164 		const char*		desc;
    165 	} verifiers[] =
    166 	{
    167 		{ QUERY_BOOLEAN,	"get_boolean",		"Test using getBoolean"		},
    168 		{ QUERY_INTEGER,	"get_integer",		"Test using getInteger"		},
    169 		{ QUERY_FLOAT,		"get_float",		"Test using getFloat"		},
    170 		{ QUERY_INTEGER64,	"get_integer64",	"Test using getInteger64"	},
    171 	};
    172 
    173 	// .min_fragment_interpolation_offset
    174 	{
    175 		tcu::TestCaseGroup* const group = new tcu::TestCaseGroup(m_testCtx, "min_fragment_interpolation_offset", "Test MIN_FRAGMENT_INTERPOLATION_OFFSET");
    176 		addChild(group);
    177 
    178 		for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(verifiers); ++verifierNdx)
    179 			group->addChild(new InterpolationOffsetCase(m_context, verifiers[verifierNdx].name, verifiers[verifierNdx].desc, verifiers[verifierNdx].verifier, InterpolationOffsetCase::TEST_MIN_OFFSET));
    180 	}
    181 
    182 	// .max_fragment_interpolation_offset
    183 	{
    184 		tcu::TestCaseGroup* const group = new tcu::TestCaseGroup(m_testCtx, "max_fragment_interpolation_offset", "Test MAX_FRAGMENT_INTERPOLATION_OFFSET");
    185 		addChild(group);
    186 
    187 		for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(verifiers); ++verifierNdx)
    188 			group->addChild(new InterpolationOffsetCase(m_context, verifiers[verifierNdx].name, verifiers[verifierNdx].desc, verifiers[verifierNdx].verifier, InterpolationOffsetCase::TEST_MAX_OFFSET));
    189 	}
    190 
    191 	// .fragment_interpolation_offset_bits
    192 	{
    193 		tcu::TestCaseGroup* const group = new tcu::TestCaseGroup(m_testCtx, "fragment_interpolation_offset_bits", "Test FRAGMENT_INTERPOLATION_OFFSET_BITS");
    194 		addChild(group);
    195 
    196 		for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(verifiers); ++verifierNdx)
    197 			group->addChild(new FragmentInterpolationOffsetBitsCase(m_context, verifiers[verifierNdx].name, verifiers[verifierNdx].desc, verifiers[verifierNdx].verifier));
    198 	}
    199 }
    200 
    201 } // Functional
    202 } // gles31
    203 } // deqp
    204