| /*------------------------------------------------------------------------- |
| * drawElements Quality Program OpenGL (ES) Module |
| * ----------------------------------------------- |
| * |
| * Copyright 2015 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| *//*! |
| * \file |
| * \brief State Query test utils. |
| *//*--------------------------------------------------------------------*/ |
| #include "glsStateQueryUtil.hpp" |
| #include "tcuTestContext.hpp" |
| #include "tcuFormatUtil.hpp" |
| #include "gluCallLogWrapper.hpp" |
| #include "gluStrUtil.hpp" |
| #include "glwEnums.hpp" |
| #include "deStringUtil.hpp" |
| |
| namespace deqp |
| { |
| namespace gls |
| { |
| namespace StateQueryUtil |
| { |
| |
| static glw::GLboolean mapBoolToGLBoolean(bool b) |
| { |
| return (b ? GL_TRUE : GL_FALSE); |
| } |
| |
| static bool checkError(tcu::ResultCollector &result, glu::CallLogWrapper &gl, const char *msg) |
| { |
| const glw::GLenum errorCode = gl.glGetError(); |
| |
| if (errorCode == GL_NO_ERROR) |
| return true; |
| |
| result.fail(std::string(msg) + ": glGetError() returned " + glu::getErrorStr(errorCode).toString()); |
| return false; |
| } |
| |
| QueriedState::QueriedState(void) : m_type(DATATYPE_LAST) |
| { |
| } |
| |
| QueriedState::QueriedState(glw::GLint v) : m_type(DATATYPE_INTEGER) |
| { |
| m_v.vInt = v; |
| } |
| |
| QueriedState::QueriedState(glw::GLint64 v) : m_type(DATATYPE_INTEGER64) |
| { |
| m_v.vInt64 = v; |
| } |
| |
| QueriedState::QueriedState(bool v) : m_type(DATATYPE_BOOLEAN) |
| { |
| m_v.vBool = v; |
| } |
| |
| QueriedState::QueriedState(glw::GLfloat v) : m_type(DATATYPE_FLOAT) |
| { |
| m_v.vFloat = v; |
| } |
| |
| QueriedState::QueriedState(glw::GLuint v) : m_type(DATATYPE_UNSIGNED_INTEGER) |
| { |
| m_v.vUint = v; |
| } |
| |
| QueriedState::QueriedState(const GLIntVec3 &v) : m_type(DATATYPE_INTEGER_VEC3) |
| { |
| m_v.vIntVec3[0] = v[0]; |
| m_v.vIntVec3[1] = v[1]; |
| m_v.vIntVec3[2] = v[2]; |
| } |
| |
| QueriedState::QueriedState(void *v) : m_type(DATATYPE_POINTER) |
| { |
| m_v.vPtr = v; |
| } |
| |
| QueriedState::QueriedState(const GLIntVec4 &v) : m_type(DATATYPE_INTEGER_VEC4) |
| { |
| m_v.vIntVec4[0] = v[0]; |
| m_v.vIntVec4[1] = v[1]; |
| m_v.vIntVec4[2] = v[2]; |
| m_v.vIntVec4[3] = v[3]; |
| } |
| |
| QueriedState::QueriedState(const GLUintVec4 &v) : m_type(DATATYPE_UNSIGNED_INTEGER_VEC4) |
| { |
| m_v.vUintVec4[0] = v[0]; |
| m_v.vUintVec4[1] = v[1]; |
| m_v.vUintVec4[2] = v[2]; |
| m_v.vUintVec4[3] = v[3]; |
| } |
| |
| QueriedState::QueriedState(const GLFloatVec4 &v) : m_type(DATATYPE_FLOAT_VEC4) |
| { |
| m_v.vFloatVec4[0] = v[0]; |
| m_v.vFloatVec4[1] = v[1]; |
| m_v.vFloatVec4[2] = v[2]; |
| m_v.vFloatVec4[3] = v[3]; |
| } |
| |
| QueriedState::QueriedState(const BooleanVec4 &v) : m_type(DATATYPE_BOOLEAN_VEC4) |
| { |
| m_v.vBooleanVec4[0] = v[0]; |
| m_v.vBooleanVec4[1] = v[1]; |
| m_v.vBooleanVec4[2] = v[2]; |
| m_v.vBooleanVec4[3] = v[3]; |
| } |
| |
| QueriedState::QueriedState(const GLInt64Vec4 &v) : m_type(DATATYPE_INTEGER64_VEC4) |
| { |
| m_v.vInt64Vec4[0] = v[0]; |
| m_v.vInt64Vec4[1] = v[1]; |
| m_v.vInt64Vec4[2] = v[2]; |
| m_v.vInt64Vec4[3] = v[3]; |
| } |
| |
| bool QueriedState::isUndefined(void) const |
| { |
| return m_type == DATATYPE_LAST; |
| } |
| |
| DataType QueriedState::getType(void) const |
| { |
| return m_type; |
| } |
| |
| glw::GLint &QueriedState::getIntAccess(void) |
| { |
| DE_ASSERT(m_type == DATATYPE_INTEGER); |
| return m_v.vInt; |
| } |
| |
| glw::GLint64 &QueriedState::getInt64Access(void) |
| { |
| DE_ASSERT(m_type == DATATYPE_INTEGER64); |
| return m_v.vInt64; |
| } |
| |
| bool &QueriedState::getBoolAccess(void) |
| { |
| DE_ASSERT(m_type == DATATYPE_BOOLEAN); |
| return m_v.vBool; |
| } |
| |
| glw::GLfloat &QueriedState::getFloatAccess(void) |
| { |
| DE_ASSERT(m_type == DATATYPE_FLOAT); |
| return m_v.vFloat; |
| } |
| |
| glw::GLuint &QueriedState::getUintAccess(void) |
| { |
| DE_ASSERT(m_type == DATATYPE_UNSIGNED_INTEGER); |
| return m_v.vUint; |
| } |
| |
| QueriedState::GLIntVec3 &QueriedState::getIntVec3Access(void) |
| { |
| DE_ASSERT(m_type == DATATYPE_INTEGER_VEC3); |
| return m_v.vIntVec3; |
| } |
| |
| void *&QueriedState::getPtrAccess(void) |
| { |
| DE_ASSERT(m_type == DATATYPE_POINTER); |
| return m_v.vPtr; |
| } |
| |
| QueriedState::GLIntVec4 &QueriedState::getIntVec4Access(void) |
| { |
| DE_ASSERT(m_type == DATATYPE_INTEGER_VEC4); |
| return m_v.vIntVec4; |
| } |
| |
| QueriedState::GLUintVec4 &QueriedState::getUintVec4Access(void) |
| { |
| DE_ASSERT(m_type == DATATYPE_UNSIGNED_INTEGER_VEC4); |
| return m_v.vUintVec4; |
| } |
| |
| QueriedState::GLFloatVec4 &QueriedState::getFloatVec4Access(void) |
| { |
| DE_ASSERT(m_type == DATATYPE_FLOAT_VEC4); |
| return m_v.vFloatVec4; |
| } |
| |
| QueriedState::BooleanVec4 &QueriedState::getBooleanVec4Access(void) |
| { |
| DE_ASSERT(m_type == DATATYPE_BOOLEAN_VEC4); |
| return m_v.vBooleanVec4; |
| } |
| |
| QueriedState::GLInt64Vec4 &QueriedState::getInt64Vec4Access(void) |
| { |
| DE_ASSERT(m_type == DATATYPE_INTEGER64_VEC4); |
| return m_v.vInt64Vec4; |
| } |
| |
| // query |
| |
| static bool verifyBooleanValidity(tcu::ResultCollector &result, glw::GLboolean v) |
| { |
| if (v == GL_TRUE || v == GL_FALSE) |
| return true; |
| else |
| { |
| std::ostringstream buf; |
| buf << "Boolean value was not neither GL_TRUE nor GL_FALSE, got " << de::toString(tcu::Format::Hex<2>(v)); |
| result.fail(buf.str()); |
| return false; |
| } |
| } |
| |
| static bool verifyBooleanVec4Validity(tcu::ResultCollector &result, const glw::GLboolean v[4]) |
| { |
| bool valid = true; |
| |
| for (int i = 0; i < 4; i++) |
| { |
| if (v[i] != GL_TRUE && v[i] != GL_FALSE) |
| valid = false; |
| } |
| |
| if (!valid) |
| { |
| std::ostringstream buf; |
| buf << "Boolean vec4 value was not neither GL_TRUE nor GL_FALSE, got ("; |
| |
| for (int i = 0; i < 4; i++) |
| buf << (i > 0 ? ", " : "") << de::toString(tcu::Format::Hex<2>(v[i])); |
| |
| buf << ")"; |
| |
| result.fail(buf.str()); |
| } |
| |
| return valid; |
| } |
| |
| void queryState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLenum target, |
| QueriedState &state) |
| { |
| switch (type) |
| { |
| case QUERY_ISENABLED: |
| { |
| const glw::GLboolean value = gl.glIsEnabled(target); |
| |
| if (!checkError(result, gl, "glIsEnabled")) |
| return; |
| |
| if (!verifyBooleanValidity(result, value)) |
| return; |
| |
| state = QueriedState(value == GL_TRUE); |
| break; |
| } |
| |
| case QUERY_BOOLEAN: |
| { |
| StateQueryMemoryWriteGuard<glw::GLboolean> value; |
| gl.glGetBooleanv(target, &value); |
| |
| if (!checkError(result, gl, "glGetBooleanv")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| if (!verifyBooleanValidity(result, value)) |
| return; |
| |
| state = QueriedState(value == GL_TRUE); |
| break; |
| } |
| |
| case QUERY_INTEGER: |
| { |
| StateQueryMemoryWriteGuard<glw::GLint> value; |
| gl.glGetIntegerv(target, &value); |
| |
| if (!checkError(result, gl, "glGetIntegerv")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| |
| case QUERY_INTEGER64: |
| { |
| StateQueryMemoryWriteGuard<glw::GLint64> value; |
| gl.glGetInteger64v(target, &value); |
| |
| if (!checkError(result, gl, "glGetInteger64v")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| |
| case QUERY_FLOAT: |
| { |
| StateQueryMemoryWriteGuard<glw::GLfloat> value; |
| gl.glGetFloatv(target, &value); |
| |
| if (!checkError(result, gl, "glGetFloatv")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| |
| default: |
| DE_ASSERT(false); |
| break; |
| } |
| } |
| |
| void queryIndexedState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLenum target, |
| int index, QueriedState &state) |
| { |
| switch (type) |
| { |
| case QUERY_INDEXED_BOOLEAN_VEC4: |
| { |
| StateQueryMemoryWriteGuard<glw::GLboolean[4]> value; |
| gl.glGetBooleani_v(target, index, value); |
| |
| if (!checkError(result, gl, "glGetBooleani_v")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| if (!verifyBooleanVec4Validity(result, value)) |
| return; |
| |
| { |
| bool res[4]; |
| |
| for (int i = 0; i < 4; i++) |
| res[i] = value[i] == GL_TRUE; |
| |
| state = QueriedState(res); |
| } |
| |
| break; |
| } |
| |
| case QUERY_INDEXED_INTEGER_VEC4: |
| { |
| StateQueryMemoryWriteGuard<glw::GLint[4]> value; |
| gl.glGetIntegeri_v(target, index, value); |
| |
| if (!checkError(result, gl, "glGetIntegeri_v")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| |
| case QUERY_INDEXED_INTEGER64_VEC4: |
| { |
| StateQueryMemoryWriteGuard<glw::GLint64[4]> value; |
| gl.glGetInteger64i_v(target, index, value); |
| |
| if (!checkError(result, gl, "glGetInteger64i_v")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| |
| case QUERY_INDEXED_ISENABLED: |
| { |
| const glw::GLboolean value = gl.glIsEnabledi(target, index); |
| |
| if (!checkError(result, gl, "glIsEnabledi")) |
| return; |
| |
| if (!verifyBooleanValidity(result, value)) |
| return; |
| |
| state = QueriedState(value == GL_TRUE); |
| break; |
| } |
| |
| case QUERY_INDEXED_BOOLEAN: |
| { |
| StateQueryMemoryWriteGuard<glw::GLboolean> value; |
| gl.glGetBooleani_v(target, index, &value); |
| |
| if (!checkError(result, gl, "glGetBooleani_v")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| if (!verifyBooleanValidity(result, value)) |
| return; |
| |
| state = QueriedState(value == GL_TRUE); |
| break; |
| } |
| |
| case QUERY_INDEXED_INTEGER: |
| { |
| StateQueryMemoryWriteGuard<glw::GLint> value; |
| gl.glGetIntegeri_v(target, index, &value); |
| |
| if (!checkError(result, gl, "glGetIntegeri_v")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| |
| case QUERY_INDEXED_INTEGER64: |
| { |
| StateQueryMemoryWriteGuard<glw::GLint64> value; |
| gl.glGetInteger64i_v(target, index, &value); |
| |
| if (!checkError(result, gl, "glGetInteger64i_v")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| |
| default: |
| DE_ASSERT(false); |
| break; |
| } |
| } |
| |
| void queryAttributeState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLenum target, |
| int index, QueriedState &state) |
| { |
| switch (type) |
| { |
| case QUERY_ATTRIBUTE_INTEGER: |
| { |
| StateQueryMemoryWriteGuard<glw::GLint> value; |
| gl.glGetVertexAttribiv(index, target, &value); |
| |
| if (!checkError(result, gl, "glGetVertexAttribiv")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| case QUERY_ATTRIBUTE_FLOAT: |
| { |
| StateQueryMemoryWriteGuard<glw::GLfloat> value; |
| gl.glGetVertexAttribfv(index, target, &value); |
| |
| if (!checkError(result, gl, "glGetVertexAttribfv")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| case QUERY_ATTRIBUTE_PURE_INTEGER: |
| { |
| StateQueryMemoryWriteGuard<glw::GLint> value; |
| gl.glGetVertexAttribIiv(index, target, &value); |
| |
| if (!checkError(result, gl, "glGetVertexAttribIiv")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| case QUERY_ATTRIBUTE_PURE_UNSIGNED_INTEGER: |
| { |
| StateQueryMemoryWriteGuard<glw::GLuint> value; |
| gl.glGetVertexAttribIuiv(index, target, &value); |
| |
| if (!checkError(result, gl, "glGetVertexAttribIuiv")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| default: |
| DE_ASSERT(false); |
| } |
| } |
| |
| void queryFramebufferState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLenum target, |
| glw::GLenum pname, QueriedState &state) |
| { |
| switch (type) |
| { |
| case QUERY_FRAMEBUFFER_INTEGER: |
| { |
| StateQueryMemoryWriteGuard<glw::GLint> value; |
| gl.glGetFramebufferParameteriv(target, pname, &value); |
| |
| if (!checkError(result, gl, "glGetVertexAttribiv")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| default: |
| DE_ASSERT(false); |
| } |
| } |
| |
| void queryProgramState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLuint program, |
| glw::GLenum pname, QueriedState &state) |
| { |
| switch (type) |
| { |
| case QUERY_PROGRAM_INTEGER: |
| { |
| StateQueryMemoryWriteGuard<glw::GLint> value; |
| gl.glGetProgramiv(program, pname, &value); |
| |
| if (!checkError(result, gl, "glGetProgramiv")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| case QUERY_PROGRAM_INTEGER_VEC3: |
| { |
| StateQueryMemoryWriteGuard<glw::GLint[3]> value; |
| gl.glGetProgramiv(program, pname, value); |
| |
| if (!checkError(result, gl, "glGetProgramiv")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| default: |
| DE_ASSERT(false); |
| } |
| } |
| |
| void queryPipelineState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLuint pipeline, |
| glw::GLenum pname, QueriedState &state) |
| { |
| switch (type) |
| { |
| case QUERY_PIPELINE_INTEGER: |
| { |
| StateQueryMemoryWriteGuard<glw::GLint> value; |
| gl.glGetProgramPipelineiv(pipeline, pname, &value); |
| |
| if (!checkError(result, gl, "glGetProgramiv")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| default: |
| DE_ASSERT(false); |
| } |
| } |
| |
| void queryTextureParamState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLenum target, |
| glw::GLenum pname, QueriedState &state) |
| { |
| switch (type) |
| { |
| case QUERY_TEXTURE_PARAM_INTEGER: |
| { |
| StateQueryMemoryWriteGuard<glw::GLint> value; |
| gl.glGetTexParameteriv(target, pname, &value); |
| |
| if (!checkError(result, gl, "glGetTexParameteriv")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| case QUERY_TEXTURE_PARAM_FLOAT: |
| { |
| StateQueryMemoryWriteGuard<glw::GLfloat> value; |
| gl.glGetTexParameterfv(target, pname, &value); |
| |
| if (!checkError(result, gl, "glGetTexParameterfv")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| case QUERY_TEXTURE_PARAM_PURE_INTEGER: |
| { |
| StateQueryMemoryWriteGuard<glw::GLint> value; |
| gl.glGetTexParameterIiv(target, pname, &value); |
| |
| if (!checkError(result, gl, "GetTexParameterIiv")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| case QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER: |
| { |
| StateQueryMemoryWriteGuard<glw::GLuint> value; |
| gl.glGetTexParameterIuiv(target, pname, &value); |
| |
| if (!checkError(result, gl, "GetTexParameterIuiv")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| case QUERY_TEXTURE_PARAM_INTEGER_VEC4: |
| { |
| StateQueryMemoryWriteGuard<glw::GLint[4]> value; |
| gl.glGetTexParameteriv(target, pname, value); |
| |
| if (!checkError(result, gl, "glGetTexParameteriv")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| case QUERY_TEXTURE_PARAM_FLOAT_VEC4: |
| { |
| StateQueryMemoryWriteGuard<glw::GLfloat[4]> value; |
| gl.glGetTexParameterfv(target, pname, value); |
| |
| if (!checkError(result, gl, "glGetTexParameterfv")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| case QUERY_TEXTURE_PARAM_PURE_INTEGER_VEC4: |
| { |
| StateQueryMemoryWriteGuard<glw::GLint[4]> value; |
| gl.glGetTexParameterIiv(target, pname, value); |
| |
| if (!checkError(result, gl, "GetTexParameterIiv")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| case QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER_VEC4: |
| { |
| StateQueryMemoryWriteGuard<glw::GLuint[4]> value; |
| gl.glGetTexParameterIuiv(target, pname, value); |
| |
| if (!checkError(result, gl, "GetTexParameterIuiv")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| default: |
| DE_ASSERT(false); |
| } |
| } |
| |
| void queryTextureLevelState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLenum target, |
| int level, glw::GLenum pname, QueriedState &state) |
| { |
| switch (type) |
| { |
| case QUERY_TEXTURE_LEVEL_INTEGER: |
| { |
| StateQueryMemoryWriteGuard<glw::GLint> value; |
| gl.glGetTexLevelParameteriv(target, level, pname, &value); |
| |
| if (!checkError(result, gl, "glGetTexLevelParameteriv")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| case QUERY_TEXTURE_LEVEL_FLOAT: |
| { |
| StateQueryMemoryWriteGuard<glw::GLfloat> value; |
| gl.glGetTexLevelParameterfv(target, level, pname, &value); |
| |
| if (!checkError(result, gl, "glGetTexLevelParameterfv")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| default: |
| DE_ASSERT(false); |
| } |
| } |
| |
| void queryPointerState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLenum pname, |
| QueriedState &state) |
| { |
| switch (type) |
| { |
| case QUERY_POINTER: |
| { |
| StateQueryMemoryWriteGuard<void *> value; |
| gl.glGetPointerv(pname, &value); |
| |
| if (!checkError(result, gl, "glGetPointerv")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| default: |
| DE_ASSERT(false); |
| } |
| } |
| |
| void queryObjectState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLuint handle, |
| QueriedState &state) |
| { |
| switch (type) |
| { |
| case QUERY_ISTEXTURE: |
| { |
| const glw::GLboolean value = gl.glIsTexture(handle); |
| |
| if (!checkError(result, gl, "glIsTexture")) |
| return; |
| |
| if (!verifyBooleanValidity(result, value)) |
| return; |
| |
| state = QueriedState(value == GL_TRUE); |
| break; |
| } |
| default: |
| DE_ASSERT(false); |
| } |
| } |
| |
| void queryQueryState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLenum target, |
| glw::GLenum pname, QueriedState &state) |
| { |
| switch (type) |
| { |
| case QUERY_QUERY: |
| { |
| StateQueryMemoryWriteGuard<glw::GLint> value; |
| gl.glGetQueryiv(target, pname, &value); |
| |
| if (!checkError(result, gl, "glGetQueryiv")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| default: |
| DE_ASSERT(false); |
| } |
| } |
| |
| void querySamplerState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLuint sampler, |
| glw::GLenum pname, QueriedState &state) |
| { |
| switch (type) |
| { |
| case QUERY_SAMPLER_PARAM_INTEGER: |
| { |
| StateQueryMemoryWriteGuard<glw::GLint> value; |
| gl.glGetSamplerParameteriv(sampler, pname, &value); |
| |
| if (!checkError(result, gl, "glGetSamplerParameteriv")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| case QUERY_SAMPLER_PARAM_FLOAT: |
| { |
| StateQueryMemoryWriteGuard<glw::GLfloat> value; |
| gl.glGetSamplerParameterfv(sampler, pname, &value); |
| |
| if (!checkError(result, gl, "glGetSamplerParameteriv")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| case QUERY_SAMPLER_PARAM_PURE_INTEGER: |
| { |
| StateQueryMemoryWriteGuard<glw::GLint> value; |
| gl.glGetSamplerParameterIiv(sampler, pname, &value); |
| |
| if (!checkError(result, gl, "glGetSamplerParameterIiv")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| case QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER: |
| { |
| StateQueryMemoryWriteGuard<glw::GLuint> value; |
| gl.glGetSamplerParameterIuiv(sampler, pname, &value); |
| |
| if (!checkError(result, gl, "glGetSamplerParameterIuiv")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| case QUERY_SAMPLER_PARAM_INTEGER_VEC4: |
| { |
| StateQueryMemoryWriteGuard<glw::GLint[4]> value; |
| gl.glGetSamplerParameteriv(sampler, pname, value); |
| |
| if (!checkError(result, gl, "glGetSamplerParameteriv")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| case QUERY_SAMPLER_PARAM_FLOAT_VEC4: |
| { |
| StateQueryMemoryWriteGuard<glw::GLfloat[4]> value; |
| gl.glGetSamplerParameterfv(sampler, pname, value); |
| |
| if (!checkError(result, gl, "glGetSamplerParameteriv")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| case QUERY_SAMPLER_PARAM_PURE_INTEGER_VEC4: |
| { |
| StateQueryMemoryWriteGuard<glw::GLint[4]> value; |
| gl.glGetSamplerParameterIiv(sampler, pname, value); |
| |
| if (!checkError(result, gl, "glGetSamplerParameterIiv")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| case QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER_VEC4: |
| { |
| StateQueryMemoryWriteGuard<glw::GLuint[4]> value; |
| gl.glGetSamplerParameterIuiv(sampler, pname, value); |
| |
| if (!checkError(result, gl, "glGetSamplerParameterIuiv")) |
| return; |
| |
| if (!value.verifyValidity(result)) |
| return; |
| |
| state = QueriedState(value); |
| break; |
| } |
| default: |
| DE_ASSERT(false); |
| } |
| } |
| |
| // verify |
| |
| void verifyBoolean(tcu::ResultCollector &result, QueriedState &state, bool expected) |
| { |
| switch (state.getType()) |
| { |
| case DATATYPE_BOOLEAN: |
| { |
| if (state.getBoolAccess() != expected) |
| { |
| std::ostringstream buf; |
| buf << "Expected " << glu::getBooleanStr(mapBoolToGLBoolean(expected)) << ", got " |
| << glu::getBooleanStr(mapBoolToGLBoolean(state.getBoolAccess())); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| case DATATYPE_INTEGER: |
| { |
| const glw::GLint reference = expected ? 1 : 0; |
| if (state.getIntAccess() != reference) |
| { |
| std::ostringstream buf; |
| buf << "Expected " << reference << ", got " << state.getIntAccess(); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| case DATATYPE_INTEGER64: |
| { |
| const glw::GLint64 reference = expected ? 1 : 0; |
| if (state.getInt64Access() != reference) |
| { |
| std::ostringstream buf; |
| buf << "Expected " << reference << ", got " << state.getInt64Access(); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| case DATATYPE_FLOAT: |
| { |
| const glw::GLfloat reference = expected ? 1.0f : 0.0f; |
| if (state.getFloatAccess() != reference) |
| { |
| std::ostringstream buf; |
| buf << "Expected " << reference << ", got " << state.getFloatAccess(); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| default: |
| DE_ASSERT(false); |
| break; |
| } |
| } |
| |
| void verifyInteger(tcu::ResultCollector &result, QueriedState &state, int expected) |
| { |
| switch (state.getType()) |
| { |
| case DATATYPE_BOOLEAN: |
| { |
| const bool reference = (expected != 0); |
| if (state.getBoolAccess() != reference) |
| { |
| std::ostringstream buf; |
| buf << "Expected " << glu::getBooleanStr(mapBoolToGLBoolean(reference)) << ", got " |
| << glu::getBooleanStr(mapBoolToGLBoolean(state.getBoolAccess())); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| case DATATYPE_INTEGER: |
| { |
| const glw::GLint reference = expected; |
| if (state.getIntAccess() != reference) |
| { |
| std::ostringstream buf; |
| buf << "Expected " << reference << "(" << de::toString(tcu::Format::Hex<8>(reference)) << ") , got " |
| << state.getIntAccess() << "(" << de::toString(tcu::Format::Hex<8>(state.getIntAccess())) << ")"; |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| case DATATYPE_INTEGER64: |
| { |
| const glw::GLint64 reference = (glw::GLint64)expected; |
| if (state.getInt64Access() != reference) |
| { |
| std::ostringstream buf; |
| buf << "Expected " << reference << "(" << de::toString(tcu::Format::Hex<8>(reference)) << "), got " |
| << state.getInt64Access() << "(" << de::toString(tcu::Format::Hex<8>(state.getInt64Access())) << ")"; |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| case DATATYPE_FLOAT: |
| { |
| const glw::GLfloat refValueMin = deInt32ToFloatRoundToNegInf(expected); |
| const glw::GLfloat refValueMax = deInt32ToFloatRoundToPosInf(expected); |
| |
| if (state.getFloatAccess() < refValueMin || state.getFloatAccess() > refValueMax || |
| deIsNaN(state.getFloatAccess())) |
| { |
| std::ostringstream buf; |
| |
| if (refValueMin == refValueMax) |
| buf << "Expected " << refValueMin << ", got " << state.getFloatAccess(); |
| else |
| buf << "Expected in range [" << refValueMin << ", " << refValueMax << "], got " |
| << state.getFloatAccess(); |
| |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| case DATATYPE_UNSIGNED_INTEGER: |
| { |
| const glw::GLuint reference = (glw::GLuint)expected; |
| if (state.getUintAccess() != reference) |
| { |
| std::ostringstream buf; |
| buf << "Expected " << reference << "(" << de::toString(tcu::Format::Hex<8>(reference)) << "), got " |
| << state.getUintAccess() << "(" << de::toString(tcu::Format::Hex<8>(state.getUintAccess())) << ")"; |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| default: |
| DE_ASSERT(false); |
| break; |
| } |
| } |
| |
| void verifyIntegerMin(tcu::ResultCollector &result, QueriedState &state, int minValue) |
| { |
| switch (state.getType()) |
| { |
| case DATATYPE_BOOLEAN: |
| { |
| if (minValue > 0 && state.getBoolAccess() != true) |
| { |
| std::ostringstream buf; |
| buf << "Expected GL_TRUE, got GL_FALSE"; |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| case DATATYPE_INTEGER: |
| { |
| if (state.getIntAccess() < minValue) |
| { |
| std::ostringstream buf; |
| buf << "Expected greater or equal to " << minValue << ", got " << state.getIntAccess(); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| case DATATYPE_INTEGER64: |
| { |
| if (state.getInt64Access() < minValue) |
| { |
| std::ostringstream buf; |
| buf << "Expected greater or equal to " << minValue << ", got " << state.getInt64Access(); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| case DATATYPE_FLOAT: |
| { |
| if (state.getFloatAccess() < deInt32ToFloatRoundToNegInf(minValue) || deIsNaN(state.getFloatAccess())) |
| { |
| std::ostringstream buf; |
| buf << "Expected greater or equal to " << minValue << ", got " << state.getFloatAccess(); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| default: |
| DE_ASSERT(false); |
| break; |
| } |
| } |
| |
| void verifyIntegerMax(tcu::ResultCollector &result, QueriedState &state, int maxValue) |
| { |
| switch (state.getType()) |
| { |
| case DATATYPE_BOOLEAN: |
| { |
| if (maxValue < 0 && state.getBoolAccess() != true) |
| { |
| std::ostringstream buf; |
| buf << "Expected GL_TRUE, got GL_FALSE"; |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| case DATATYPE_INTEGER: |
| { |
| if (state.getIntAccess() > maxValue) |
| { |
| std::ostringstream buf; |
| buf << "Expected less or equal to " << maxValue << ", got " << state.getIntAccess(); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| case DATATYPE_INTEGER64: |
| { |
| if (state.getInt64Access() > maxValue) |
| { |
| std::ostringstream buf; |
| buf << "Expected less or equal to " << maxValue << ", got " << state.getInt64Access(); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| case DATATYPE_FLOAT: |
| { |
| if (state.getFloatAccess() > deInt32ToFloatRoundToPosInf(maxValue) || deIsNaN(state.getFloatAccess())) |
| { |
| std::ostringstream buf; |
| buf << "Expected less or equal to " << maxValue << ", got " << state.getFloatAccess(); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| default: |
| DE_ASSERT(false); |
| break; |
| } |
| } |
| |
| void verifyFloat(tcu::ResultCollector &result, QueriedState &state, float expected) |
| { |
| switch (state.getType()) |
| { |
| case DATATYPE_BOOLEAN: |
| { |
| const bool reference = (expected != 0.0f); |
| |
| if (state.getBoolAccess() != reference) |
| { |
| std::ostringstream buf; |
| buf << "Expected " << glu::getBooleanStr(mapBoolToGLBoolean(reference)) << ", got " |
| << glu::getBooleanStr(mapBoolToGLBoolean(state.getBoolAccess())); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| case DATATYPE_INTEGER: |
| { |
| const glw::GLint refValueMin = roundGLfloatToNearestIntegerHalfDown<glw::GLint>(expected); |
| const glw::GLint refValueMax = roundGLfloatToNearestIntegerHalfUp<glw::GLint>(expected); |
| |
| if (state.getIntAccess() < refValueMin || state.getIntAccess() > refValueMax) |
| { |
| std::ostringstream buf; |
| |
| if (refValueMin == refValueMax) |
| buf << "Expected " << refValueMin << ", got " << state.getIntAccess(); |
| else |
| buf << "Expected in range [" << refValueMin << ", " << refValueMax << "], got " << state.getIntAccess(); |
| |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| case DATATYPE_FLOAT: |
| { |
| if (state.getFloatAccess() != expected) |
| { |
| std::ostringstream buf; |
| buf << "Expected " << expected << ", got " << state.getFloatAccess(); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| case DATATYPE_INTEGER64: |
| { |
| const glw::GLint64 refValueMin = roundGLfloatToNearestIntegerHalfDown<glw::GLint64>(expected); |
| const glw::GLint64 refValueMax = roundGLfloatToNearestIntegerHalfUp<glw::GLint64>(expected); |
| |
| if (state.getInt64Access() < refValueMin || state.getInt64Access() > refValueMax) |
| { |
| std::ostringstream buf; |
| |
| if (refValueMin == refValueMax) |
| buf << "Expected " << refValueMin << ", got " << state.getInt64Access(); |
| else |
| buf << "Expected in range [" << refValueMin << ", " << refValueMax << "], got " |
| << state.getInt64Access(); |
| |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| case DATATYPE_UNSIGNED_INTEGER: |
| { |
| const glw::GLuint refValueMin = roundGLfloatToNearestIntegerHalfDown<glw::GLuint>(expected); |
| const glw::GLuint refValueMax = roundGLfloatToNearestIntegerHalfUp<glw::GLuint>(expected); |
| |
| if (state.getUintAccess() < refValueMin || state.getUintAccess() > refValueMax) |
| { |
| std::ostringstream buf; |
| |
| if (refValueMin == refValueMax) |
| buf << "Expected " << refValueMin << ", got " << state.getUintAccess(); |
| else |
| buf << "Expected in range [" << refValueMin << ", " << refValueMax << "], got " |
| << state.getUintAccess(); |
| |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| default: |
| DE_ASSERT(false); |
| break; |
| } |
| } |
| |
| void verifyFloatMin(tcu::ResultCollector &result, QueriedState &state, float minValue) |
| { |
| switch (state.getType()) |
| { |
| case DATATYPE_BOOLEAN: |
| { |
| if (minValue > 0.0f && state.getBoolAccess() != true) |
| result.fail("expected GL_TRUE, got GL_FALSE"); |
| break; |
| } |
| |
| case DATATYPE_INTEGER: |
| { |
| const glw::GLint refValue = roundGLfloatToNearestIntegerHalfDown<glw::GLint>(minValue); |
| |
| if (state.getIntAccess() < refValue) |
| { |
| std::ostringstream buf; |
| buf << "Expected greater or equal to " << refValue << ", got " << state.getIntAccess(); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| case DATATYPE_FLOAT: |
| { |
| if (state.getFloatAccess() < minValue || deIsNaN(state.getFloatAccess())) |
| { |
| std::ostringstream buf; |
| buf << "Expected greater or equal to " << minValue << ", got " << state.getFloatAccess(); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| case DATATYPE_INTEGER64: |
| { |
| const glw::GLint64 refValue = roundGLfloatToNearestIntegerHalfDown<glw::GLint64>(minValue); |
| |
| if (state.getInt64Access() < refValue) |
| { |
| std::ostringstream buf; |
| buf << "Expected greater or equal to " << refValue << ", got " << state.getInt64Access(); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| default: |
| DE_ASSERT(false); |
| break; |
| } |
| } |
| |
| void verifyFloatMax(tcu::ResultCollector &result, QueriedState &state, float maxValue) |
| { |
| switch (state.getType()) |
| { |
| case DATATYPE_BOOLEAN: |
| { |
| if (maxValue < 0.0f && state.getBoolAccess() != true) |
| result.fail("expected GL_TRUE, got GL_FALSE"); |
| break; |
| } |
| |
| case DATATYPE_INTEGER: |
| { |
| const glw::GLint refValue = roundGLfloatToNearestIntegerHalfUp<glw::GLint>(maxValue); |
| |
| if (state.getIntAccess() > refValue) |
| { |
| std::ostringstream buf; |
| buf << "Expected less or equal to " << refValue << ", got " << state.getIntAccess(); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| case DATATYPE_FLOAT: |
| { |
| if (state.getFloatAccess() > maxValue || deIsNaN(state.getFloatAccess())) |
| { |
| std::ostringstream buf; |
| buf << "Expected less or equal to " << maxValue << ", got " << state.getFloatAccess(); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| case DATATYPE_INTEGER64: |
| { |
| const glw::GLint64 refValue = roundGLfloatToNearestIntegerHalfUp<glw::GLint64>(maxValue); |
| |
| if (state.getInt64Access() > refValue) |
| { |
| std::ostringstream buf; |
| buf << "Expected less or equal to " << refValue << ", got " << state.getInt64Access(); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| default: |
| DE_ASSERT(false); |
| break; |
| } |
| } |
| |
| void verifyIntegerVec3(tcu::ResultCollector &result, QueriedState &state, const tcu::IVec3 &expected) |
| { |
| switch (state.getType()) |
| { |
| case DATATYPE_INTEGER_VEC3: |
| { |
| if (state.getIntVec3Access()[0] != expected[0] || state.getIntVec3Access()[1] != expected[1] || |
| state.getIntVec3Access()[2] != expected[2]) |
| { |
| std::ostringstream buf; |
| buf << "Expected " << expected << ", got " << tcu::formatArray(state.getIntVec3Access()); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| default: |
| DE_ASSERT(false); |
| break; |
| } |
| } |
| |
| void verifyIntegerVec4(tcu::ResultCollector &result, QueriedState &state, const tcu::IVec4 &expected) |
| { |
| switch (state.getType()) |
| { |
| case DATATYPE_INTEGER_VEC4: |
| { |
| if (state.getIntVec4Access()[0] != expected[0] || state.getIntVec4Access()[1] != expected[1] || |
| state.getIntVec4Access()[2] != expected[2] || state.getIntVec4Access()[3] != expected[3]) |
| { |
| std::ostringstream buf; |
| buf << "Expected " << expected << ", got " << tcu::formatArray(state.getIntVec4Access()); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| default: |
| DE_ASSERT(false); |
| break; |
| } |
| } |
| |
| void verifyUnsignedIntegerVec4(tcu::ResultCollector &result, QueriedState &state, const tcu::UVec4 &expected) |
| { |
| switch (state.getType()) |
| { |
| case DATATYPE_UNSIGNED_INTEGER_VEC4: |
| { |
| if (state.getUintVec4Access()[0] != expected[0] || state.getUintVec4Access()[1] != expected[1] || |
| state.getUintVec4Access()[2] != expected[2] || state.getUintVec4Access()[3] != expected[3]) |
| { |
| std::ostringstream buf; |
| buf << "Expected " << expected << ", got " << tcu::formatArray(state.getUintVec4Access()); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| default: |
| DE_ASSERT(false); |
| break; |
| } |
| } |
| |
| void verifyBooleanVec4(tcu::ResultCollector &result, QueriedState &state, const tcu::BVec4 &expected) |
| { |
| switch (state.getType()) |
| { |
| case DATATYPE_BOOLEAN_VEC4: |
| { |
| const glw::GLboolean referenceVec4[4] = {mapBoolToGLBoolean(expected[0]), mapBoolToGLBoolean(expected[1]), |
| mapBoolToGLBoolean(expected[2]), mapBoolToGLBoolean(expected[3])}; |
| |
| const glw::GLboolean resultVec4[4] = { |
| mapBoolToGLBoolean(state.getBooleanVec4Access()[0]), mapBoolToGLBoolean(state.getBooleanVec4Access()[1]), |
| mapBoolToGLBoolean(state.getBooleanVec4Access()[2]), mapBoolToGLBoolean(state.getBooleanVec4Access()[3])}; |
| |
| if (resultVec4[0] != referenceVec4[0] || resultVec4[1] != referenceVec4[1] || |
| resultVec4[2] != referenceVec4[2] || resultVec4[3] != referenceVec4[3]) |
| { |
| std::ostringstream buf; |
| buf << "Expected " << glu::getBooleanPointerStr(referenceVec4, 4) << ", got " |
| << glu::getBooleanPointerStr(resultVec4, 4); |
| result.fail(buf.str()); |
| } |
| |
| break; |
| } |
| case DATATYPE_FLOAT_VEC4: |
| { |
| const glw::GLfloat reference[4] = {(expected[0] ? 1.0f : 0.0f), (expected[1] ? 1.0f : 0.0f), |
| (expected[2] ? 1.0f : 0.0f), (expected[3] ? 1.0f : 0.0f)}; |
| |
| if (state.getFloatVec4Access()[0] != reference[0] || state.getFloatVec4Access()[1] != reference[1] || |
| state.getFloatVec4Access()[2] != reference[2] || state.getFloatVec4Access()[3] != reference[3]) |
| { |
| std::ostringstream buf; |
| buf << "Expected " << reference << ", got " << tcu::formatArray(state.getFloatVec4Access()); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| case DATATYPE_INTEGER_VEC4: |
| { |
| const glw::GLint reference[4] = {(expected[0] ? 1 : 0), (expected[1] ? 1 : 0), (expected[2] ? 1 : 0), |
| (expected[3] ? 1 : 0)}; |
| |
| if (state.getIntVec4Access()[0] != reference[0] || state.getIntVec4Access()[1] != reference[1] || |
| state.getIntVec4Access()[2] != reference[2] || state.getIntVec4Access()[3] != reference[3]) |
| { |
| std::ostringstream buf; |
| buf << "Expected " << reference << ", got " << tcu::formatArray(state.getIntVec4Access()); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| case DATATYPE_INTEGER64_VEC4: |
| { |
| const glw::GLint64 reference[4] = {(expected[0] ? 1 : 0), (expected[1] ? 1 : 0), (expected[2] ? 1 : 0), |
| (expected[3] ? 1 : 0)}; |
| |
| if (state.getInt64Vec4Access()[0] != reference[0] || state.getInt64Vec4Access()[1] != reference[1] || |
| state.getInt64Vec4Access()[2] != reference[2] || state.getInt64Vec4Access()[3] != reference[3]) |
| { |
| std::ostringstream buf; |
| buf << "Expected " << reference << ", got " << tcu::formatArray(state.getInt64Vec4Access()); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| case DATATYPE_UNSIGNED_INTEGER_VEC4: |
| { |
| const glw::GLuint reference[4] = {(expected[0] ? 1u : 0u), (expected[1] ? 1u : 0u), (expected[2] ? 1u : 0u), |
| (expected[3] ? 1u : 0u)}; |
| |
| if (state.getUintVec4Access()[0] != reference[0] || state.getUintVec4Access()[1] != reference[1] || |
| state.getUintVec4Access()[2] != reference[2] || state.getUintVec4Access()[3] != reference[3]) |
| { |
| std::ostringstream buf; |
| buf << "Expected " << reference << ", got " << tcu::formatArray(state.getUintVec4Access()); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| default: |
| DE_ASSERT(false); |
| break; |
| } |
| } |
| |
| void verifyFloatVec4(tcu::ResultCollector &result, QueriedState &state, const tcu::Vec4 &expected) |
| { |
| switch (state.getType()) |
| { |
| case DATATYPE_FLOAT_VEC4: |
| { |
| if (state.getFloatVec4Access()[0] != expected[0] || state.getFloatVec4Access()[1] != expected[1] || |
| state.getFloatVec4Access()[2] != expected[2] || state.getFloatVec4Access()[3] != expected[3]) |
| { |
| std::ostringstream buf; |
| buf << "Expected " << expected << ", got " << tcu::formatArray(state.getFloatVec4Access()); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| case DATATYPE_INTEGER_VEC4: |
| { |
| bool anyError = false; |
| std::ostringstream expectation; |
| |
| for (int ndx = 0; ndx < 4; ++ndx) |
| { |
| const glw::GLint refValueMin = roundGLfloatToNearestIntegerHalfDown<glw::GLint>(expected[ndx]); |
| const glw::GLint refValueMax = roundGLfloatToNearestIntegerHalfUp<glw::GLint>(expected[ndx]); |
| |
| if (state.getIntVec4Access()[ndx] < refValueMin || state.getIntVec4Access()[ndx] > refValueMax) |
| { |
| std::ostringstream buf; |
| |
| if (ndx > 0) |
| expectation << " ,"; |
| |
| if (refValueMin == refValueMax) |
| buf << refValueMin; |
| else |
| buf << "[" << refValueMin << ", " << refValueMax << "]"; |
| } |
| } |
| |
| if (anyError) |
| { |
| std::ostringstream buf; |
| buf << "Expected {" << expectation.str() << "}, got " << tcu::formatArray(state.getIntVec4Access()); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| case DATATYPE_UNSIGNED_INTEGER_VEC4: |
| { |
| bool anyError = false; |
| std::ostringstream expectation; |
| |
| for (int ndx = 0; ndx < 4; ++ndx) |
| { |
| const glw::GLuint refValueMin = roundGLfloatToNearestIntegerHalfDown<glw::GLuint>(expected[ndx]); |
| const glw::GLuint refValueMax = roundGLfloatToNearestIntegerHalfUp<glw::GLuint>(expected[ndx]); |
| |
| if (state.getUintVec4Access()[ndx] < refValueMin || state.getUintVec4Access()[ndx] > refValueMax) |
| { |
| std::ostringstream buf; |
| |
| if (ndx > 0) |
| expectation << " ,"; |
| |
| if (refValueMin == refValueMax) |
| buf << refValueMin; |
| else |
| buf << "[" << refValueMin << ", " << refValueMax << "]"; |
| } |
| } |
| |
| if (anyError) |
| { |
| std::ostringstream buf; |
| buf << "Expected {" << expectation.str() << "}, got " << tcu::formatArray(state.getUintVec4Access()); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| default: |
| DE_ASSERT(false); |
| break; |
| } |
| } |
| |
| void verifyPointer(tcu::ResultCollector &result, QueriedState &state, const void *expected) |
| { |
| switch (state.getType()) |
| { |
| case DATATYPE_POINTER: |
| { |
| if (state.getPtrAccess() != expected) |
| { |
| std::ostringstream buf; |
| buf << "Expected " << expected << ", got " << state.getPtrAccess(); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| default: |
| DE_ASSERT(false); |
| break; |
| } |
| } |
| |
| static float normalizeI32Float(int32_t c) |
| { |
| return de::max((float)c / float((1ul << 31) - 1u), -1.0f); |
| } |
| |
| void verifyNormalizedI32Vec4(tcu::ResultCollector &result, QueriedState &state, const tcu::IVec4 &expected) |
| { |
| // \note: normalization precision is irrelevant for these tests, we can use very large thresholds |
| const float normalizationError = 0.1f; |
| const tcu::Vec4 reference(normalizeI32Float(expected[0]), normalizeI32Float(expected[1]), |
| normalizeI32Float(expected[2]), normalizeI32Float(expected[3])); |
| const tcu::Vec4 validHigh( |
| de::min(1.0f, reference[0] + normalizationError), de::min(1.0f, reference[1] + normalizationError), |
| de::min(1.0f, reference[2] + normalizationError), de::min(1.0f, reference[3] + normalizationError)); |
| const tcu::Vec4 validLow( |
| de::max(-1.0f, reference[0] - normalizationError), de::max(-1.0f, reference[1] - normalizationError), |
| de::max(-1.0f, reference[2] - normalizationError), de::max(-1.0f, reference[3] - normalizationError)); |
| |
| switch (state.getType()) |
| { |
| case DATATYPE_FLOAT_VEC4: |
| { |
| bool anyError = false; |
| std::ostringstream expectation; |
| |
| for (int ndx = 0; ndx < 4; ++ndx) |
| { |
| if (state.getFloatVec4Access()[ndx] < validLow[ndx] || state.getFloatVec4Access()[ndx] > validHigh[ndx]) |
| { |
| std::ostringstream buf; |
| |
| if (ndx > 0) |
| expectation << " ,"; |
| buf << "[" << validLow[ndx] << ", " << validHigh[ndx] << "]"; |
| } |
| } |
| |
| if (anyError) |
| { |
| std::ostringstream buf; |
| buf << "Expected {" << expectation.str() << "}, got " << tcu::formatArray(state.getFloatVec4Access()); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| case DATATYPE_INTEGER_VEC4: |
| { |
| bool anyError = false; |
| std::ostringstream expectation; |
| |
| for (int ndx = 0; ndx < 4; ++ndx) |
| { |
| const glw::GLint refValueMin = roundGLfloatToNearestIntegerHalfDown<glw::GLint>(validHigh[ndx]); |
| const glw::GLint refValueMax = roundGLfloatToNearestIntegerHalfUp<glw::GLint>(validLow[ndx]); |
| |
| if (state.getIntVec4Access()[ndx] < refValueMin || state.getIntVec4Access()[ndx] > refValueMax) |
| { |
| std::ostringstream buf; |
| |
| if (ndx > 0) |
| expectation << " ,"; |
| |
| if (refValueMin == refValueMax) |
| buf << refValueMin; |
| else |
| buf << "[" << refValueMin << ", " << refValueMax << "]"; |
| } |
| } |
| |
| if (anyError) |
| { |
| std::ostringstream buf; |
| buf << "Expected {" << expectation.str() << "}, got " << tcu::formatArray(state.getIntVec4Access()); |
| result.fail(buf.str()); |
| } |
| break; |
| } |
| |
| default: |
| DE_ASSERT(false); |
| break; |
| } |
| } |
| |
| // helpers |
| |
| void verifyStateBoolean(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, bool refValue, |
| QueryType type) |
| { |
| QueriedState state; |
| |
| queryState(result, gl, type, target, state); |
| |
| if (!state.isUndefined()) |
| verifyBoolean(result, state, refValue); |
| } |
| |
| void verifyStateInteger(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, int refValue, |
| QueryType type) |
| { |
| QueriedState state; |
| |
| queryState(result, gl, type, target, state); |
| |
| if (!state.isUndefined()) |
| verifyInteger(result, state, refValue); |
| } |
| |
| void verifyStateIntegerMin(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, int minValue, |
| QueryType type) |
| { |
| QueriedState state; |
| |
| queryState(result, gl, type, target, state); |
| |
| if (!state.isUndefined()) |
| verifyIntegerMin(result, state, minValue); |
| } |
| |
| void verifyStateIntegerMax(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, int maxValue, |
| QueryType type) |
| { |
| QueriedState state; |
| |
| queryState(result, gl, type, target, state); |
| |
| if (!state.isUndefined()) |
| verifyIntegerMax(result, state, maxValue); |
| } |
| |
| void verifyStateIntegerEqualToOther(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, |
| glw::GLenum other, QueryType type) |
| { |
| QueriedState stateA; |
| QueriedState stateB; |
| |
| queryState(result, gl, type, target, stateA); |
| queryState(result, gl, type, other, stateB); |
| |
| if (stateA.isUndefined() || stateB.isUndefined()) |
| return; |
| |
| switch (type) |
| { |
| case QUERY_BOOLEAN: |
| { |
| if (stateA.getBoolAccess() != stateB.getBoolAccess()) |
| result.fail("expected equal results"); |
| break; |
| } |
| |
| case QUERY_INTEGER: |
| { |
| if (stateA.getIntAccess() != stateB.getIntAccess()) |
| result.fail("expected equal results"); |
| break; |
| } |
| |
| case QUERY_INTEGER64: |
| { |
| if (stateA.getInt64Access() != stateB.getInt64Access()) |
| result.fail("expected equal results"); |
| break; |
| } |
| |
| case QUERY_FLOAT: |
| { |
| if (stateA.getFloatAccess() != stateB.getFloatAccess()) |
| result.fail("expected equal results"); |
| break; |
| } |
| |
| default: |
| DE_ASSERT(false); |
| break; |
| } |
| } |
| |
| void verifyStateFloat(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, float reference, |
| QueryType type) |
| { |
| QueriedState state; |
| |
| queryState(result, gl, type, target, state); |
| |
| if (!state.isUndefined()) |
| verifyFloat(result, state, reference); |
| } |
| |
| void verifyStateFloatMin(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, float minValue, |
| QueryType type) |
| { |
| QueriedState state; |
| |
| queryState(result, gl, type, target, state); |
| |
| if (!state.isUndefined()) |
| verifyFloatMin(result, state, minValue); |
| } |
| |
| void verifyStateFloatMax(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, float maxValue, |
| QueryType type) |
| { |
| QueriedState state; |
| |
| queryState(result, gl, type, target, state); |
| |
| if (!state.isUndefined()) |
| verifyFloatMax(result, state, maxValue); |
| } |
| |
| void verifyStatePointer(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, const void *expected, |
| QueryType type) |
| { |
| QueriedState state; |
| |
| queryPointerState(result, gl, type, target, state); |
| |
| if (!state.isUndefined()) |
| verifyPointer(result, state, expected); |
| } |
| |
| void verifyStateIndexedBoolean(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, int index, |
| bool expected, QueryType type) |
| { |
| QueriedState state; |
| |
| queryIndexedState(result, gl, type, target, index, state); |
| |
| if (!state.isUndefined()) |
| verifyBoolean(result, state, expected); |
| } |
| |
| void verifyStateIndexedBooleanVec4(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, int index, |
| const tcu::BVec4 &expected, QueryType type) |
| { |
| QueriedState state; |
| |
| queryIndexedState(result, gl, type, target, index, state); |
| |
| if (!state.isUndefined()) |
| verifyBooleanVec4(result, state, expected); |
| } |
| |
| void verifyStateIndexedInteger(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, int index, |
| int expected, QueryType type) |
| { |
| QueriedState state; |
| |
| queryIndexedState(result, gl, type, target, index, state); |
| |
| if (!state.isUndefined()) |
| verifyInteger(result, state, expected); |
| } |
| |
| void verifyStateIndexedIntegerMin(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, int index, |
| int minValue, QueryType type) |
| { |
| QueriedState state; |
| |
| queryIndexedState(result, gl, type, target, index, state); |
| |
| if (!state.isUndefined()) |
| verifyIntegerMin(result, state, minValue); |
| } |
| |
| void verifyStateAttributeInteger(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, int index, |
| int expected, QueryType type) |
| { |
| QueriedState state; |
| |
| queryAttributeState(result, gl, type, target, index, state); |
| |
| if (!state.isUndefined()) |
| verifyInteger(result, state, expected); |
| } |
| |
| void verifyStateFramebufferInteger(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, |
| glw::GLenum pname, int expected, QueryType type) |
| { |
| QueriedState state; |
| |
| queryFramebufferState(result, gl, type, target, pname, state); |
| |
| if (!state.isUndefined()) |
| verifyInteger(result, state, expected); |
| } |
| |
| void verifyStateFramebufferIntegerMin(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, |
| glw::GLenum pname, int minValue, QueryType type) |
| { |
| QueriedState state; |
| |
| queryFramebufferState(result, gl, type, target, pname, state); |
| |
| if (!state.isUndefined()) |
| verifyIntegerMin(result, state, minValue); |
| } |
| |
| void verifyStateProgramInteger(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLuint program, |
| glw::GLenum pname, int expected, QueryType type) |
| { |
| QueriedState state; |
| |
| queryProgramState(result, gl, type, program, pname, state); |
| |
| if (!state.isUndefined()) |
| verifyInteger(result, state, expected); |
| } |
| |
| void verifyStateProgramIntegerVec3(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLuint program, |
| glw::GLenum pname, const tcu::IVec3 &expected, QueryType type) |
| { |
| QueriedState state; |
| |
| queryProgramState(result, gl, type, program, pname, state); |
| |
| if (!state.isUndefined()) |
| verifyIntegerVec3(result, state, expected); |
| } |
| |
| void verifyStatePipelineInteger(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLuint pipeline, |
| glw::GLenum pname, int expected, QueryType type) |
| { |
| QueriedState state; |
| |
| queryPipelineState(result, gl, type, pipeline, pname, state); |
| |
| if (!state.isUndefined()) |
| verifyInteger(result, state, expected); |
| } |
| |
| void verifyStateTextureParamInteger(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, |
| glw::GLenum pname, int expected, QueryType type) |
| { |
| QueriedState state; |
| |
| queryTextureParamState(result, gl, type, target, pname, state); |
| |
| if (!state.isUndefined()) |
| verifyInteger(result, state, expected); |
| } |
| |
| void verifyStateTextureParamFloat(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, |
| glw::GLenum pname, float expected, QueryType type) |
| { |
| QueriedState state; |
| |
| queryTextureParamState(result, gl, type, target, pname, state); |
| |
| if (!state.isUndefined()) |
| verifyFloat(result, state, expected); |
| } |
| |
| void verifyStateTextureParamFloatVec4(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, |
| glw::GLenum pname, const tcu::Vec4 &expected, QueryType type) |
| { |
| QueriedState state; |
| |
| queryTextureParamState(result, gl, type, target, pname, state); |
| |
| if (!state.isUndefined()) |
| verifyFloatVec4(result, state, expected); |
| } |
| |
| void verifyStateTextureParamNormalizedI32Vec4(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, |
| glw::GLenum pname, const tcu::IVec4 &expected, QueryType type) |
| { |
| QueriedState state; |
| |
| queryTextureParamState(result, gl, type, target, pname, state); |
| |
| if (!state.isUndefined()) |
| verifyNormalizedI32Vec4(result, state, expected); |
| } |
| |
| void verifyStateTextureParamIntegerVec4(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, |
| glw::GLenum pname, const tcu::IVec4 &expected, QueryType type) |
| { |
| QueriedState state; |
| |
| queryTextureParamState(result, gl, type, target, pname, state); |
| |
| if (!state.isUndefined()) |
| verifyIntegerVec4(result, state, expected); |
| } |
| |
| void verifyStateTextureParamUnsignedIntegerVec4(tcu::ResultCollector &result, glu::CallLogWrapper &gl, |
| glw::GLenum target, glw::GLenum pname, const tcu::UVec4 &expected, |
| QueryType type) |
| { |
| QueriedState state; |
| |
| queryTextureParamState(result, gl, type, target, pname, state); |
| |
| if (!state.isUndefined()) |
| verifyUnsignedIntegerVec4(result, state, expected); |
| } |
| |
| void verifyStateTextureLevelInteger(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, |
| int level, glw::GLenum pname, int expected, QueryType type) |
| { |
| QueriedState state; |
| |
| queryTextureLevelState(result, gl, type, target, level, pname, state); |
| |
| if (!state.isUndefined()) |
| verifyInteger(result, state, expected); |
| } |
| |
| void verifyStateObjectBoolean(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLuint handle, bool expected, |
| QueryType type) |
| { |
| QueriedState state; |
| |
| queryObjectState(result, gl, type, handle, state); |
| |
| if (!state.isUndefined()) |
| verifyBoolean(result, state, expected); |
| } |
| |
| void verifyStateQueryInteger(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, |
| glw::GLenum pname, int expected, QueryType type) |
| { |
| QueriedState state; |
| |
| queryQueryState(result, gl, type, target, pname, state); |
| |
| if (!state.isUndefined()) |
| verifyInteger(result, state, expected); |
| } |
| |
| void verifyStateSamplerParamInteger(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLuint sampler, |
| glw::GLenum pname, int expected, QueryType type) |
| { |
| QueriedState state; |
| |
| querySamplerState(result, gl, type, sampler, pname, state); |
| |
| if (!state.isUndefined()) |
| verifyInteger(result, state, expected); |
| } |
| |
| void verifyStateSamplerParamFloat(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLuint sampler, |
| glw::GLenum pname, float expected, QueryType type) |
| { |
| QueriedState state; |
| |
| querySamplerState(result, gl, type, sampler, pname, state); |
| |
| if (!state.isUndefined()) |
| verifyFloat(result, state, expected); |
| } |
| |
| void verifyStateSamplerParamFloatVec4(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLuint sampler, |
| glw::GLenum pname, const tcu::Vec4 &expected, QueryType type) |
| { |
| QueriedState state; |
| |
| querySamplerState(result, gl, type, sampler, pname, state); |
| |
| if (!state.isUndefined()) |
| verifyFloatVec4(result, state, expected); |
| } |
| |
| void verifyStateSamplerParamNormalizedI32Vec4(tcu::ResultCollector &result, glu::CallLogWrapper &gl, |
| glw::GLuint sampler, glw::GLenum pname, const tcu::IVec4 &expected, |
| QueryType type) |
| { |
| QueriedState state; |
| |
| querySamplerState(result, gl, type, sampler, pname, state); |
| |
| if (!state.isUndefined()) |
| verifyNormalizedI32Vec4(result, state, expected); |
| } |
| |
| void verifyStateSamplerParamIntegerVec4(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLuint sampler, |
| glw::GLenum pname, const tcu::IVec4 &expected, QueryType type) |
| { |
| QueriedState state; |
| |
| querySamplerState(result, gl, type, sampler, pname, state); |
| |
| if (!state.isUndefined()) |
| verifyIntegerVec4(result, state, expected); |
| } |
| |
| void verifyStateSamplerParamUnsignedIntegerVec4(tcu::ResultCollector &result, glu::CallLogWrapper &gl, |
| glw::GLuint sampler, glw::GLenum pname, const tcu::UVec4 &expected, |
| QueryType type) |
| { |
| QueriedState state; |
| |
| querySamplerState(result, gl, type, sampler, pname, state); |
| |
| if (!state.isUndefined()) |
| verifyUnsignedIntegerVec4(result, state, expected); |
| } |
| |
| } // namespace StateQueryUtil |
| } // namespace gls |
| } // namespace deqp |
