| /*------------------------------------------------------------------------- |
| * OpenGL Conformance Test Suite |
| * ----------------------------- |
| * |
| * Copyright (c) 2014-2016 The Khronos Group Inc. |
| * |
| * 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 |
| */ /*-------------------------------------------------------------------*/ |
| |
| #include "es31cDrawIndirectTests.hpp" |
| #include "gluContextInfo.hpp" |
| #include "glwEnums.hpp" |
| #include "tcuMatrix.hpp" |
| #include "tcuRenderTarget.hpp" |
| #include "tcuVectorUtil.hpp" |
| |
| #include <map> |
| |
| namespace glcts |
| { |
| using namespace glw; |
| namespace |
| { |
| |
| class DILogger |
| { |
| public: |
| DILogger() : null_log_(0) |
| { |
| } |
| |
| DILogger(const DILogger& rhs) |
| { |
| null_log_ = rhs.null_log_; |
| if (!null_log_) |
| { |
| str_ << rhs.str_.str(); |
| } |
| } |
| |
| ~DILogger() |
| { |
| s_tcuLog->writeMessage(str_.str().c_str()); |
| if (!str_.str().empty()) |
| { |
| s_tcuLog->writeMessage(NL); |
| } |
| } |
| |
| template <class T> |
| DILogger& operator<<(const T& t) |
| { |
| if (!null_log_) |
| { |
| str_ << t; |
| } |
| return *this; |
| } |
| |
| DILogger& nullify() |
| { |
| null_log_ = true; |
| return *this; |
| } |
| |
| static void setOutput(tcu::TestLog& log) |
| { |
| s_tcuLog = &log; |
| } |
| |
| private: |
| void operator=(const DILogger&); |
| bool null_log_; |
| std::ostringstream str_; |
| static tcu::TestLog* s_tcuLog; |
| }; |
| tcu::TestLog* DILogger::s_tcuLog = NULL; |
| |
| class DIResult |
| { |
| public: |
| DIResult() : status_(NO_ERROR) |
| { |
| } |
| |
| DILogger error() |
| { |
| return sub_result(ERROR); |
| } |
| long code() const |
| { |
| return status_; |
| } |
| DILogger sub_result(long _code) |
| { |
| if (_code == NO_ERROR) |
| { |
| return sub_result_inner(_code).nullify(); |
| } |
| else |
| { |
| return sub_result_inner(_code); |
| } |
| } |
| |
| private: |
| DILogger sub_result_inner(long _code) |
| { |
| status_ |= _code; |
| return DILogger(); |
| } |
| DILogger logger_; |
| long status_; |
| }; |
| |
| namespace test_api |
| { |
| struct ES3 |
| { |
| static bool isES() |
| { |
| return true; |
| } |
| static std::string glslVer(bool = false) |
| { |
| return "#version 310 es"; |
| } |
| static void ES_Only() |
| { |
| } |
| }; |
| |
| struct GL |
| { |
| static bool isES() |
| { |
| return false; |
| } |
| static std::string glslVer(bool compute = false) |
| { |
| if (compute) |
| { |
| return "#version 430"; |
| } |
| else |
| { |
| return "#version 400"; |
| } |
| } |
| static void GL_Only() |
| { |
| } |
| }; |
| } |
| |
| namespace shaders |
| { |
| |
| template <typename api> |
| std::string vshSimple() |
| { |
| return api::glslVer() + NL "in vec4 i_vertex;" NL "void main()" NL "{" NL " gl_Position = i_vertex;" NL "}"; |
| } |
| template <typename api> |
| std::string vshSimple_point() |
| { |
| return api::glslVer() + NL "in vec4 i_vertex;" NL "void main()" NL "{" NL " gl_Position = i_vertex;" NL |
| "#if defined(GL_ES)" NL " gl_PointSize = 1.0;" NL "#endif" NL "}"; |
| } |
| |
| template <typename api> |
| std::string fshSimple() |
| { |
| return api::glslVer() + NL "precision highp float; " NL "out vec4 outColor;" NL "void main() {" NL |
| " outColor = vec4(0.1,0.2,0.3,1.0);" NL "}"; |
| } |
| } |
| |
| class DrawIndirectBase : public glcts::SubcaseBase |
| { |
| protected: |
| typedef std::vector<unsigned int> CDataArray; |
| typedef std::vector<tcu::Vec3> CVertexArray; |
| typedef std::vector<tcu::Vec4> CColorArray; |
| typedef std::vector<GLuint> CElementArray; |
| |
| enum TDrawFunction |
| { |
| DRAW_ARRAYS, |
| DRAW_ELEMENTS, |
| }; |
| |
| typedef struct |
| { |
| GLuint count; |
| GLuint primCount; |
| GLuint first; |
| GLuint reservedMustBeZero; |
| } DrawArraysIndirectCommand; |
| |
| typedef struct |
| { |
| GLuint count; |
| GLuint primCount; |
| GLuint firstIndex; |
| GLint baseVertex; |
| GLuint reservedMustBeZero; |
| } DrawElementsIndirectCommand; |
| |
| int getWindowWidth() |
| { |
| return m_context.getRenderContext().getRenderTarget().getWidth(); |
| } |
| |
| int getWindowHeight() |
| { |
| return m_context.getRenderContext().getRenderTarget().getHeight(); |
| } |
| |
| void getDataSize(int& width, int& height) |
| { |
| width = std::min(getWindowWidth(), 16384); // Cap width to 16384 |
| height = std::min(getWindowHeight(), 4 * 16384 / width); // Height is 4 if width is capped |
| } |
| |
| GLuint CreateComputeProgram(const std::string& cs, bool linkAndCheck) |
| { |
| const GLuint p = glCreateProgram(); |
| |
| const GLuint sh = glCreateShader(GL_COMPUTE_SHADER); |
| glAttachShader(p, sh); |
| glDeleteShader(sh); |
| const char* const src[1] = { cs.c_str() }; |
| glShaderSource(sh, 1, src, NULL); |
| glCompileShader(sh); |
| |
| if (linkAndCheck) |
| { |
| glLinkProgram(p); |
| if (!CheckProgram(p)) |
| { |
| return 0; |
| } |
| } |
| |
| return p; |
| } |
| |
| GLuint CreateProgram(const std::string& vs, const std::string& gs, const std::string& fs, bool linkAndCheck) |
| { |
| const GLuint p = glCreateProgram(); |
| |
| if (!vs.empty()) |
| { |
| const GLuint sh = glCreateShader(GL_VERTEX_SHADER); |
| glAttachShader(p, sh); |
| glDeleteShader(sh); |
| const char* const src[1] = { vs.c_str() }; |
| glShaderSource(sh, 1, src, NULL); |
| glCompileShader(sh); |
| } |
| if (!gs.empty()) |
| { |
| const GLuint sh = glCreateShader(GL_GEOMETRY_SHADER); |
| glAttachShader(p, sh); |
| glDeleteShader(sh); |
| const char* const src[1] = { gs.c_str() }; |
| glShaderSource(sh, 1, src, NULL); |
| glCompileShader(sh); |
| } |
| if (!fs.empty()) |
| { |
| const GLuint sh = glCreateShader(GL_FRAGMENT_SHADER); |
| glAttachShader(p, sh); |
| glDeleteShader(sh); |
| const char* const src[1] = { fs.c_str() }; |
| glShaderSource(sh, 1, src, NULL); |
| glCompileShader(sh); |
| } |
| |
| if (linkAndCheck) |
| { |
| glLinkProgram(p); |
| if (!CheckProgram(p)) |
| { |
| return 0; |
| } |
| } |
| |
| return p; |
| } |
| |
| long CheckProgram(GLuint program) |
| { |
| DIResult status; |
| GLint progStatus; |
| glGetProgramiv(program, GL_LINK_STATUS, &progStatus); |
| |
| if (progStatus == GL_FALSE) |
| { |
| |
| status.error() << "GL_LINK_STATUS is false"; |
| |
| GLint attached_shaders; |
| glGetProgramiv(program, GL_ATTACHED_SHADERS, &attached_shaders); |
| |
| if (attached_shaders > 0) |
| { |
| std::vector<GLuint> shaders(attached_shaders); |
| glGetAttachedShaders(program, attached_shaders, NULL, &shaders[0]); |
| |
| for (GLint i = 0; i < attached_shaders; ++i) |
| { |
| // shader type |
| GLenum type; |
| glGetShaderiv(shaders[i], GL_SHADER_TYPE, reinterpret_cast<GLint*>(&type)); |
| switch (type) |
| { |
| case GL_VERTEX_SHADER: |
| status.error() << "*** Vertex Shader ***\n"; |
| break; |
| case GL_FRAGMENT_SHADER: |
| status.error() << "*** Fragment Shader ***\n"; |
| break; |
| case GL_COMPUTE_SHADER: |
| status.error() << "*** Compute Shader ***\n"; |
| break; |
| default: |
| status.error() << "*** Unknown Shader ***\n"; |
| break; |
| } |
| |
| // shader source |
| GLint length; |
| glGetShaderiv(shaders[i], GL_SHADER_SOURCE_LENGTH, &length); |
| if (length > 0) |
| { |
| std::vector<GLchar> source(length); |
| glGetShaderSource(shaders[i], length, NULL, &source[0]); |
| status.error() << source[0]; |
| } |
| |
| // shader info log |
| glGetShaderiv(shaders[i], GL_INFO_LOG_LENGTH, &length); |
| if (length > 0) |
| { |
| std::vector<GLchar> log(length); |
| glGetShaderInfoLog(shaders[i], length, NULL, &log[0]); |
| status.error() << &log[0]; |
| } |
| } |
| } |
| |
| // program info log |
| GLint length; |
| glGetProgramiv(program, GL_INFO_LOG_LENGTH, &length); |
| if (length > 0) |
| { |
| std::vector<GLchar> log(length); |
| glGetProgramInfoLog(program, length, NULL, &log[0]); |
| status.error() << &log[0]; |
| } |
| } |
| |
| return status.code() == NO_ERROR; |
| } |
| |
| template <typename api> |
| void ReadPixelsFloat(int x, int y, int width, int height, void* data); |
| |
| template <typename api> |
| void GetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data); |
| |
| template <typename T> |
| void DataGen(std::vector<T>& data, unsigned int sizeX, unsigned int sizeY, T valueMin, T valueMax) |
| { |
| data.resize(sizeX * sizeY, 0); |
| T range = valueMax - valueMin; |
| T stepX = range / sizeX; |
| T stepY = range / sizeY; |
| |
| for (unsigned int i = 0; i < sizeY; ++i) |
| { |
| T valueY = i * stepY; |
| |
| for (unsigned int j = 0; j < sizeX; ++j) |
| { |
| data[j + i * sizeX] = valueMin + j * stepX + valueY; |
| } |
| } |
| } |
| |
| template <typename T> |
| long DataCompare(const std::vector<T>& dataRef, unsigned int widthRef, unsigned int heightRef, |
| const std::vector<T>& dataTest, unsigned int widthTest, unsigned int heightTest, |
| unsigned offsetYRef = 0, unsigned offsetYTest = 0) |
| { |
| if (widthRef * heightRef > dataRef.size()) |
| throw std::runtime_error("Invalid reference buffer resolution!"); |
| |
| if (widthTest * heightTest > dataTest.size()) |
| throw std::runtime_error("Invalid test buffer resolution!"); |
| |
| unsigned int width = std::min(widthRef, widthTest); |
| unsigned int height = std::min(heightRef, heightTest); |
| |
| for (unsigned int i = 0; i < height; ++i) |
| { |
| unsigned int offsetRef = (i + offsetYRef) * widthRef; |
| unsigned int offsetTest = (i + offsetYTest) * widthTest; |
| |
| for (size_t j = 0; j < width; ++j) |
| { |
| if (dataRef[offsetRef + j] != dataTest[offsetTest + j]) |
| { |
| DIResult status; |
| status.error() << "Compare failed: different values [x: " << j << ", y: " << i + offsetYTest |
| << ", reference: " << dataRef[offsetRef + j] |
| << ", test: " << dataTest[offsetTest + j] << "]"; |
| return status.code(); |
| } |
| } |
| } |
| |
| return NO_ERROR; |
| } |
| |
| template <typename api> |
| long BindingPointCheck(GLuint expectedValue) |
| { |
| DIResult status; |
| |
| GLint valueInt = -9999; |
| glGetIntegerv(GL_DRAW_INDIRECT_BUFFER_BINDING, &valueInt); |
| if (valueInt != static_cast<GLint>(expectedValue)) |
| { |
| status.error() << "glGetIntegerv(GL_DRAW_INDIRECT_BUFFER_BINDING) returned invalid value: " << valueInt |
| << ", expected: " << expectedValue; |
| } |
| |
| GLboolean valueBool = expectedValue ? GL_FALSE : GL_TRUE; |
| glGetBooleanv(GL_DRAW_INDIRECT_BUFFER_BINDING, &valueBool); |
| if (valueBool != (expectedValue ? GL_TRUE : GL_FALSE)) |
| { |
| status.error() << "glGetBooleanv(GL_DRAW_INDIRECT_BUFFER_BINDING) returned invalid value: " |
| << BoolToString(valueBool) |
| << ", expected: " << BoolToString(expectedValue ? GL_TRUE : GL_FALSE); |
| } |
| |
| GLfloat valueFloat = -9999; |
| GLfloat expectedFloatValue = static_cast<GLfloat>(expectedValue); |
| glGetFloatv(GL_DRAW_INDIRECT_BUFFER_BINDING, &valueFloat); |
| if (valueFloat != expectedFloatValue) |
| { |
| status.error() << "glGetFloatv(GL_DRAW_INDIRECT_BUFFER_BINDING) returned invalid value: " << valueFloat |
| << ", expected: " << expectedValue; |
| } |
| |
| if (!api::isES()) |
| { |
| GLdouble valueDouble = -9999; |
| glGetDoublev(GL_DRAW_INDIRECT_BUFFER_BINDING, &valueDouble); |
| if (valueDouble != static_cast<GLdouble>(expectedValue)) |
| { |
| status.error() << "glGetDoublev(GL_DRAW_INDIRECT_BUFFER_BINDING) returned invalid value: " |
| << valueDouble << ", expected: " << expectedValue; |
| } |
| } |
| |
| return status.code(); |
| } |
| |
| template <typename T> |
| long BuffersCompare(const std::vector<T>& bufferTest, unsigned int widthTest, unsigned int heightTest, |
| const std::vector<T>& bufferRef, unsigned int widthRef, unsigned int heightRef) |
| { |
| |
| const tcu::PixelFormat& pixelFormat = m_context.getRenderContext().getRenderTarget().getPixelFormat(); |
| tcu::Vec4 epsilon = tcu::Vec4( |
| 1.f / static_cast<float>(1 << pixelFormat.redBits), 1.f / static_cast<float>(1 << pixelFormat.greenBits), |
| 1.f / static_cast<float>(1 << pixelFormat.blueBits), 1.f / static_cast<float>(1 << pixelFormat.alphaBits)); |
| |
| double stepX = widthRef / static_cast<double>(widthTest); |
| double stepY = heightRef / static_cast<double>(heightTest); |
| for (unsigned int i = 0; i < heightTest; ++i) |
| { |
| unsigned int offsetTest = i * widthTest; |
| unsigned int offsetRef = static_cast<int>(i * stepY + 0.5) * widthRef; |
| for (unsigned int j = 0; j < widthTest; ++j) |
| { |
| unsigned int posXRef = static_cast<int>(j * stepX + 0.5); |
| if (!ColorVerify(bufferTest[j + offsetTest], bufferRef[posXRef + offsetRef], epsilon)) |
| { |
| DIResult status; |
| status.error() << "(x,y)= (" << j << "," << i << "). Color RGBA(" << bufferTest[j + offsetTest][0] |
| << "," << bufferTest[j + offsetTest][1] << "," << bufferTest[j + offsetTest][2] |
| << "," << bufferTest[j + offsetTest][3] << ") is different than expected RGBA(" |
| << bufferRef[posXRef + offsetRef][0] << "," << bufferRef[posXRef + offsetRef][1] |
| << "," << bufferRef[posXRef + offsetRef][2] << "," |
| << bufferRef[posXRef + offsetRef][3] << ")"; |
| return status.code(); |
| } |
| } |
| } |
| return NO_ERROR; |
| } |
| |
| template <typename T> |
| bool ColorVerify(T color, T colorExpected, tcu::Vec4 epsilon) |
| { |
| for (int i = 0; i < 3; ++i) |
| { |
| if (fabsf(colorExpected[i] - color[i]) > epsilon[i]) |
| return false; |
| } |
| return true; |
| } |
| |
| long BufferCheck(const CDataArray& dataRef, unsigned int widthRef, unsigned int heightRef, const void* bufTest, |
| unsigned int widthTest, unsigned int heightTest, unsigned int offsetYRef = 0, |
| unsigned int offsetYTest = 0) |
| { |
| if (bufTest == 0) |
| { |
| throw std::runtime_error("Invalid test buffer!"); |
| } |
| |
| CDataArray dataTest(widthTest * heightTest, 0); |
| memcpy(&dataTest[0], bufTest, widthTest * heightTest * sizeof(unsigned int)); |
| |
| return DataCompare(dataRef, widthRef, heightRef, dataTest, widthTest, heightTest, offsetYRef, offsetYTest); |
| } |
| |
| template <typename api> |
| long StateValidate(GLboolean mapped, GLbitfield access, GLbitfield accessFlag, GLintptr offset, GLsizeiptr length) |
| { |
| DIResult result; |
| |
| if (!api::isES()) |
| { |
| int v; |
| glGetBufferParameteriv(GL_DRAW_INDIRECT_BUFFER, GL_BUFFER_ACCESS, &v); |
| if (v != static_cast<int>(access)) |
| { |
| result.error() << "glGetBufferParameteriv(GL_BUFFER_ACCESS) returned incorrect state: " |
| << AccessToString(v) << ", expected: " << AccessToString(access); |
| } |
| } |
| |
| int v; |
| glGetBufferParameteriv(GL_DRAW_INDIRECT_BUFFER, GL_BUFFER_ACCESS_FLAGS, &v); |
| if (v != static_cast<int>(accessFlag)) |
| { |
| result.error() << "glGetBufferParameteriv(GL_BUFFER_ACCESS_FLAGS) returned incorrect state: " << v |
| << ", expected: " << accessFlag; |
| } |
| |
| glGetBufferParameteriv(GL_DRAW_INDIRECT_BUFFER, GL_BUFFER_MAPPED, &v); |
| if (v != mapped) |
| { |
| result.error() << "glGetBufferParameteriv(GL_BUFFER_MAPPED) returned incorrect state: " |
| << BoolToString((GLboolean)v) << ", expected: " << BoolToString((GLboolean)access); |
| } |
| |
| glGetBufferParameteriv(GL_DRAW_INDIRECT_BUFFER, GL_BUFFER_MAP_OFFSET, &v); |
| if (v != offset) |
| { |
| result.error() << "glGetBufferParameteriv(GL_BUFFER_MAP_OFFSET) returned incorrect offset: " << v |
| << ", expected: " << offset; |
| } |
| |
| glGetBufferParameteriv(GL_DRAW_INDIRECT_BUFFER, GL_BUFFER_MAP_LENGTH, &v); |
| if (v != length) |
| { |
| result.error() << "glGetBufferParameteriv(GL_BUFFER_MAP_LENGTH) returned incorrect length: " << v |
| << ", expected: " << length; |
| } |
| |
| return result.code(); |
| } |
| |
| void PointsGen(unsigned int drawSizeX, unsigned int drawSizeY, CColorArray& output) |
| { |
| output.reserve(drawSizeY * 2); |
| float rasterSizeX = 2.0f / static_cast<float>(getWindowWidth()); |
| float rasterSizeY = 2.0f / static_cast<float>(getWindowHeight()); |
| for (unsigned int i = 0; i < drawSizeY; ++i) |
| { |
| float offsetY = -1.0f + rasterSizeY * static_cast<float>(i) + rasterSizeY / 2; |
| for (unsigned int j = 0; j < drawSizeX; ++j) |
| { |
| float offsetX = -1.0f + rasterSizeX * static_cast<float>(j) + rasterSizeX / 2; |
| output.push_back(tcu::Vec4(offsetX, offsetY, 0.0f, 1.0f)); |
| } |
| } |
| } |
| |
| float LinesOffsetY(unsigned int i, float rasterSize) |
| { |
| // Offset lines slightly from the center of pixels so as not to hit rasterizer |
| // tie-break conditions (the right-edge of the screen at half-integer pixel |
| // heights is the right corner of a diamond). rasterSize/16 is the smallest |
| // offset that the spec guarantees the rasterizer can resolve. |
| return -1.0f + rasterSize * static_cast<float>(i) + rasterSize / 2 + rasterSize / 16; |
| } |
| |
| void LinesGen(unsigned int, unsigned int drawSizeY, CColorArray& output) |
| { |
| output.reserve(drawSizeY * 2); |
| float rasterSize = 2.0f / static_cast<float>(getWindowHeight()); |
| for (unsigned int i = 0; i < drawSizeY; ++i) |
| { |
| float offsetY = LinesOffsetY(i, rasterSize); |
| output.push_back(tcu::Vec4(-1.0f, offsetY, 0.0f, 1.0f)); |
| output.push_back(tcu::Vec4(1.0f, offsetY, 0.0f, 1.0f)); |
| } |
| } |
| |
| void LinesAdjacencyGen(unsigned int, unsigned int drawSizeY, CColorArray& output) |
| { |
| float rasterSize = 2.0f / static_cast<float>(getWindowHeight()); |
| for (unsigned int i = 0; i < drawSizeY; ++i) |
| { |
| float offsetY = LinesOffsetY(i, rasterSize); |
| output.push_back(tcu::Vec4(-1.5f, -1.0f + offsetY, 0.0f, 1.0f)); //adj |
| output.push_back(tcu::Vec4(-1.0f, offsetY, 0.0f, 1.0f)); |
| output.push_back(tcu::Vec4(1.0f, offsetY, 0.0f, 1.0f)); |
| output.push_back(tcu::Vec4(1.5f, -1.0f + offsetY, 0.0f, 1.0f)); //adj |
| } |
| } |
| |
| void LineStripAdjacencyGen(unsigned int, unsigned int drawSizeY, CColorArray& output) |
| { |
| float rasterSize = 2.0f / static_cast<float>(getWindowHeight()); |
| output.push_back(tcu::Vec4(-1.5f, rasterSize / 2, 0.0f, 1.0f)); |
| for (unsigned int i = 0; i < drawSizeY; ++i) |
| { |
| float offsetY = LinesOffsetY(i, rasterSize); |
| output.push_back(tcu::Vec4(-1.0f, offsetY, 0.0f, 1.0f)); |
| output.push_back(tcu::Vec4(-1.0f, offsetY, 0.0f, 1.0f)); |
| output.push_back(tcu::Vec4(1.0f, offsetY, 0.0f, 1.0f)); |
| output.push_back(tcu::Vec4(1.0f, offsetY, 0.0f, 1.0f)); |
| } |
| output.push_back(tcu::Vec4(1.5f, 1.0f - rasterSize / 2, 0.0f, 1.0f)); |
| } |
| |
| void TrianglesGen(unsigned int drawSizeX, unsigned int drawSizeY, CColorArray& output) |
| { |
| output.reserve(drawSizeX * 2 * 6); |
| |
| switch (drawSizeX) |
| { |
| case 1: |
| { |
| output.push_back(tcu::Vec4(-1.0f, -1.0f, 0.0f, 1.0f)); |
| output.push_back(tcu::Vec4(4.0f, -1.0f, 0.0f, 1.0f)); |
| output.push_back(tcu::Vec4(-1.0f, 4.0f, 0.0f, 1.0f)); |
| } |
| break; |
| case 0: |
| { |
| throw std::runtime_error("Invalid drawSizeX!"); |
| } |
| default: |
| { |
| float drawStepX = 2.0f / static_cast<float>(drawSizeX); |
| float drawStepY = 2.0f / static_cast<float>(drawSizeY); |
| |
| for (unsigned int i = 0; i < drawSizeY; ++i) |
| { |
| float offsetY = -1.0f + drawStepY * static_cast<float>(i); |
| for (unsigned int j = 0; j < drawSizeX; ++j) |
| { |
| float offsetX = -1.0f + drawStepX * static_cast<float>(j); |
| |
| output.push_back(tcu::Vec4(offsetX, offsetY, 0.0f, 1.0f)); |
| output.push_back(tcu::Vec4(offsetX + drawStepX, offsetY, 0.0f, 1.0f)); |
| output.push_back(tcu::Vec4(offsetX, offsetY + drawStepY, 0.0f, 1.0f)); |
| |
| output.push_back(tcu::Vec4(offsetX + drawStepX, offsetY, 0.0f, 1.0f)); |
| output.push_back(tcu::Vec4(offsetX + drawStepX, offsetY + drawStepY, 0.0f, 1.0f)); |
| output.push_back(tcu::Vec4(offsetX, offsetY + drawStepY, 0.0f, 1.0f)); |
| } |
| } |
| } |
| break; |
| } |
| } |
| |
| void TrianglesAdjacencyGen(unsigned int drawSizeX, unsigned int drawSizeY, CColorArray& output) |
| { |
| // Add a small amount (quarter pixel) of jitter to add to the rectangle sides to avoid |
| // triangle edges landing precisely on fragment centers. |
| float jigX = 0.5f / getWindowWidth(); |
| float jigY = 0.5f / getWindowHeight(); |
| |
| float sizeX = 1.0f / static_cast<float>(drawSizeX); |
| float sizeY = 1.0f / static_cast<float>(drawSizeY); |
| |
| for (unsigned int i = 0; i < drawSizeX; ++i) |
| { |
| float offsetY = -0.5f + jigY + sizeY * static_cast<float>(i); |
| for (unsigned int j = 0; j < drawSizeY; ++j) |
| { |
| float offsetX = -0.5f + jigX + sizeX * static_cast<float>(j); |
| |
| output.push_back(tcu::Vec4(offsetX, offsetY, 0.0f, 1.0f)); |
| output.push_back(tcu::Vec4(offsetX - sizeX, offsetY + sizeY, 0.0f, 1.0f)); |
| output.push_back(tcu::Vec4(offsetX, offsetY + sizeY, 0.0f, 1.0f)); |
| output.push_back(tcu::Vec4(offsetX + sizeX, offsetY + sizeY, 0.0f, 1.0f)); |
| output.push_back(tcu::Vec4(offsetX + sizeX, offsetY, 0.0f, 1.0f)); |
| output.push_back(tcu::Vec4(offsetX + sizeX, offsetY - sizeY, 0.0f, 1.0f)); |
| |
| output.push_back(tcu::Vec4(offsetX + sizeX, offsetY + sizeY, 0.0f, 1.0f)); |
| output.push_back(tcu::Vec4(offsetX + 2 * sizeX, offsetY, 0.0f, 1.0f)); |
| output.push_back(tcu::Vec4(offsetX + sizeX, offsetY, 0.0f, 1.0f)); |
| output.push_back(tcu::Vec4(offsetX, offsetY, 0.0f, 1.0f)); |
| output.push_back(tcu::Vec4(offsetX, offsetY + sizeY, 0.0f, 1.0f)); |
| output.push_back(tcu::Vec4(offsetX, offsetY + 2 * sizeY, 0.0f, 1.0f)); |
| } |
| } |
| } |
| |
| void TriangleStripAdjacencyGen(unsigned int drawSizeX, unsigned int drawSizeY, CColorArray& output) |
| { |
| // Add a small amount (quarter pixel) of jitter to add to the rectangle sides to avoid |
| // triangle edges landing precisely on fragment centers. |
| float jigX = 0.5f / getWindowWidth(); |
| float jigY = 0.5f / getWindowHeight(); |
| |
| float sizeX = 1.0f / static_cast<float>(drawSizeX); |
| float sizeY = 1.0f / static_cast<float>(drawSizeY); |
| |
| for (unsigned int i = 0; i < drawSizeX; ++i) |
| { |
| float offsetY = -0.5f + jigY + sizeY * static_cast<float>(i); |
| for (unsigned int j = 0; j < drawSizeY; ++j) |
| { |
| float offsetX = -0.5f + jigX + sizeX * static_cast<float>(j); |
| |
| output.push_back(tcu::Vec4(offsetX, offsetY, 0.0f, 1.0f)); |
| output.push_back(tcu::Vec4(offsetX - sizeX, offsetY + sizeY, 0.0f, 1.0f)); |
| output.push_back(tcu::Vec4(offsetX, offsetY + sizeY, 0.0f, 1.0f)); |
| output.push_back(tcu::Vec4(offsetX + sizeX, offsetY - sizeY, 0.0f, 1.0f)); |
| output.push_back(tcu::Vec4(offsetX + sizeX, offsetY, 0.0f, 1.0f)); |
| output.push_back(tcu::Vec4(offsetX, offsetY + 2 * sizeY, 0.0f, 1.0f)); |
| output.push_back(tcu::Vec4(offsetX + sizeX, offsetY + sizeY, 0.0f, 1.0f)); |
| output.push_back(tcu::Vec4(offsetX + 2 * sizeX, offsetY - sizeY, 0.0f, 1.0f)); |
| } |
| } |
| } |
| |
| void PrimitiveGen(GLenum primitiveType, unsigned int drawSizeX, unsigned int drawSizeY, CColorArray& output) |
| { |
| switch (primitiveType) |
| { |
| case GL_POINTS: |
| PointsGen(drawSizeX, drawSizeY, output); |
| break; |
| case GL_LINES: |
| case GL_LINE_STRIP: |
| case GL_LINE_LOOP: |
| LinesGen(drawSizeX, drawSizeY, output); |
| break; |
| case GL_LINES_ADJACENCY: |
| LinesAdjacencyGen(drawSizeX, drawSizeY, output); |
| break; |
| case GL_LINE_STRIP_ADJACENCY: |
| LineStripAdjacencyGen(drawSizeX, drawSizeY, output); |
| break; |
| case GL_TRIANGLES: |
| case GL_TRIANGLE_STRIP: |
| case GL_TRIANGLE_FAN: |
| TrianglesGen(drawSizeX, drawSizeY, output); |
| break; |
| case GL_TRIANGLES_ADJACENCY: |
| TrianglesAdjacencyGen(drawSizeX, drawSizeY, output); |
| break; |
| case GL_TRIANGLE_STRIP_ADJACENCY: |
| TriangleStripAdjacencyGen(drawSizeX, drawSizeY, output); |
| break; |
| default: |
| throw std::runtime_error("Unknown primitive type!"); |
| } |
| } |
| |
| std::string BoolToString(GLboolean value) |
| { |
| if (value == GL_TRUE) |
| return "GL_TRUE"; |
| |
| return "GL_FALSE"; |
| } |
| |
| std::string AccessToString(GLbitfield access) |
| { |
| switch (access) |
| { |
| case GL_READ_WRITE: |
| return "GL_READ_WRITE"; |
| case GL_READ_ONLY: |
| return "GL_READ_ONLY"; |
| case GL_WRITE_ONLY: |
| return "GL_WRITE_ONLY"; |
| default: |
| throw std::runtime_error("Invalid access type!"); |
| } |
| } |
| }; |
| |
| template <> |
| void DrawIndirectBase::ReadPixelsFloat<test_api::GL>(int x, int y, int width, int height, void* data) |
| { |
| glReadPixels(x, y, width, height, GL_RGBA, GL_FLOAT, data); |
| } |
| |
| template <> |
| void DrawIndirectBase::ReadPixelsFloat<test_api::ES3>(int x, int y, int width, int height, void* data) |
| { |
| // Use 1010102 pixel buffer for RGB10_A2 FBO to preserve precision during pixel transfer |
| std::vector<GLuint> uData(width * height); |
| const tcu::PixelFormat& pixelFormat = m_context.getRenderContext().getRenderTarget().getPixelFormat(); |
| GLfloat* fData = reinterpret_cast<GLfloat*>(data); |
| GLenum type = ((pixelFormat.redBits == 10) && |
| (pixelFormat.greenBits == 10) && |
| (pixelFormat.blueBits == 10) && |
| (pixelFormat.alphaBits == 2)) ? |
| GL_UNSIGNED_INT_2_10_10_10_REV : |
| GL_UNSIGNED_BYTE; |
| |
| glReadPixels(x, y, width, height, GL_RGBA, type, &uData[0]); |
| |
| if (type == GL_UNSIGNED_BYTE) |
| { |
| for (size_t i = 0; i < uData.size(); i++) |
| { |
| GLubyte* uCompData = reinterpret_cast<GLubyte*>(&uData[i]); |
| |
| for (size_t c = 0; c < 4; c++) |
| { |
| fData[i * 4 + c] = float(uCompData[c]) / 255.0f; |
| } |
| } |
| } |
| else |
| { |
| for (size_t i = 0; i < uData.size(); i++) |
| { |
| fData[i * 4] = float(uData[i] & 0x3FF) / 1023.0f; |
| fData[i * 4 + 1] = float((uData[i] >> 10) & 0x3FF) / 1023.0f; |
| fData[i * 4 + 2] = float((uData[i] >> 20) & 0x3FF) / 1023.0f; |
| fData[i * 4 + 3] = float((uData[i] >> 30) & 0x3) / 3.0f; |
| } |
| } |
| } |
| |
| template <> |
| void DrawIndirectBase::GetBufferSubData<test_api::GL>(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data) |
| { |
| glGetBufferSubData(target, offset, size, data); |
| } |
| |
| template <> |
| void DrawIndirectBase::GetBufferSubData<test_api::ES3>(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data) |
| { |
| void* ptr = glMapBufferRange(target, offset, size, GL_MAP_READ_BIT); |
| memcpy(data, ptr, size); |
| glUnmapBuffer(target); |
| } |
| |
| template <typename api> |
| struct CDefaultBindingPoint : public DrawIndirectBase |
| { |
| virtual std::string Title() |
| { |
| return "Draw Indirect: Check default binding point"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that default binding point is set to zero"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "Use glGetIntegerv, glGetBooleanv, glGetFloatv, glGetDoublev to get default binding point"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if default binding point is zero"; |
| } |
| |
| virtual long Run() |
| { |
| return BindingPointCheck<api>(0); |
| } |
| }; |
| |
| template <typename api> |
| struct CZeroBindingPoint : public DrawIndirectBase |
| { |
| virtual std::string Title() |
| { |
| return "Draw Indirect: Zero binding point"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that binding point is set to zero"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "Bind zero and check that binding point is set to zero"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if binding point is set to zero"; |
| } |
| |
| virtual long Run() |
| { |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, 0); |
| |
| return BindingPointCheck<api>(0); |
| } |
| }; |
| |
| template <typename api> |
| struct CSingleBindingPoint : public DrawIndirectBase |
| { |
| virtual std::string Title() |
| { |
| return "Draw Indirect: Single binding point"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that binding point is set to correct value"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "Bind non-zero buffer and check that binding point is set to correct value"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if binding point is set to correct value"; |
| } |
| |
| virtual long Run() |
| { |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _buffer); |
| |
| long ret = BindingPointCheck<api>(_buffer); |
| |
| return ret; |
| } |
| |
| virtual long Cleanup() |
| { |
| glDeleteBuffers(1, &_buffer); |
| return BindingPointCheck<api>(0); |
| } |
| |
| private: |
| GLuint _buffer; |
| }; |
| |
| template <typename api> |
| class CMultiBindingPoint : public DrawIndirectBase |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "Draw Indirect: Multi binding point"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that binding points are set to correct value"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "Bind in loop non-zero buffers and check that binding points are set to correct value"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if binding points are set to correct value"; |
| } |
| |
| virtual long Run() |
| { |
| DIResult result; |
| |
| const int buffNum = sizeof(_buffers) / sizeof(_buffers[0]); |
| |
| glGenBuffers(buffNum, _buffers); |
| |
| for (int i = 0; i < buffNum; ++i) |
| { |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _buffers[i]); |
| result.sub_result(BindingPointCheck<api>(_buffers[i])); |
| } |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDeleteBuffers(sizeof(_buffers) / sizeof(_buffers[0]), _buffers); |
| return BindingPointCheck<api>(0); |
| } |
| |
| private: |
| GLuint _buffers[10]; |
| }; |
| |
| template <typename api> |
| struct CDeleteBindingPoint : public DrawIndirectBase |
| { |
| virtual std::string Title() |
| { |
| return "Draw Indirect: Delete binding point"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that after deleting buffer, binding point is set to correct value"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "Bind non-zero buffer, delete buffer, check that binding point is set to 0"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if binding point is set to correct value"; |
| } |
| |
| virtual long Run() |
| { |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _buffer); |
| glDeleteBuffers(1, &_buffer); |
| return BindingPointCheck<api>(0); |
| } |
| |
| private: |
| GLuint _buffer; |
| }; |
| |
| template <typename api> |
| struct CBufferData : public DrawIndirectBase |
| { |
| virtual std::string Title() |
| { |
| return "Check functions: glBufferData and GetBufferSubData<api>"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that glBufferData and GetBufferSubData<api> accepts GL_DRAW_INDIRECT_BUFFER enum"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create buffer" NL "2. Bind buffer" NL "3. Set data using glBufferData" NL |
| "4. Get data using GetBufferSubData<api>" NL "5. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| virtual long Run() |
| { |
| DIResult result; |
| |
| int dataWidth, dataHeight; |
| getDataSize(dataWidth, dataHeight); |
| |
| CDataArray dataTest(dataWidth * dataHeight, 0); |
| |
| glGenBuffers(sizeof(_buffers) / sizeof(_buffers[0]), _buffers); |
| CDataArray dataRef1; |
| DataGen<unsigned int>(dataRef1, dataWidth, dataHeight, 0, 50); |
| |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _buffers[1]); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, (GLsizeiptr)(dataRef1.size() * sizeof(unsigned int)), &dataRef1[0], |
| GL_DYNAMIC_DRAW); |
| result.sub_result(BindingPointCheck<api>(_buffers[1])); |
| |
| GetBufferSubData<api>(GL_DRAW_INDIRECT_BUFFER, 0, (GLsizeiptr)(dataTest.size() * sizeof(unsigned int)), |
| &dataTest[0]); |
| result.sub_result(DataCompare(dataRef1, dataWidth, dataHeight, dataTest, dataWidth, dataHeight)); |
| |
| CDataArray dataRef2; |
| DataGen<unsigned int>(dataRef2, dataWidth, dataHeight, 10, 70); |
| |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _buffers[2]); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, (GLsizeiptr)(dataRef2.size() * sizeof(unsigned int)), &dataRef2[0], |
| GL_STREAM_DRAW); |
| result.sub_result(BindingPointCheck<api>(_buffers[2])); |
| |
| GetBufferSubData<api>(GL_DRAW_INDIRECT_BUFFER, 0, (GLsizeiptr)(dataTest.size() * sizeof(unsigned int)), |
| &dataTest[0]); |
| result.sub_result(DataCompare(dataRef2, dataWidth, dataHeight, dataTest, dataWidth, dataHeight)); |
| |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _buffers[3]); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, 300, NULL, GL_STATIC_DRAW); |
| result.sub_result(BindingPointCheck<api>(_buffers[3])); |
| |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _buffers[4]); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, 400, NULL, GL_DYNAMIC_READ); |
| result.sub_result(BindingPointCheck<api>(_buffers[4])); |
| |
| CDataArray dataRef5; |
| DataGen<unsigned int>(dataRef5, dataWidth, dataHeight, 0, 50); |
| |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _buffers[5]); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, (GLsizeiptr)(dataRef5.size() * sizeof(unsigned int)), &dataRef5[0], |
| GL_STREAM_READ); |
| result.sub_result(BindingPointCheck<api>(_buffers[5])); |
| |
| GetBufferSubData<api>(GL_DRAW_INDIRECT_BUFFER, 0, (GLsizeiptr)(dataTest.size() * sizeof(unsigned int)), |
| &dataTest[0]); |
| result.sub_result(DataCompare(dataRef5, dataWidth, dataHeight, dataTest, dataWidth, dataHeight)); |
| |
| CDataArray dataRef6; |
| DataGen<unsigned int>(dataRef6, dataWidth, dataHeight, 10, 40); |
| |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _buffers[6]); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, (GLsizeiptr)(dataRef6.size() * sizeof(unsigned int)), &dataRef6[0], |
| GL_STATIC_READ); |
| result.sub_result(BindingPointCheck<api>(_buffers[6])); |
| |
| GetBufferSubData<api>(GL_DRAW_INDIRECT_BUFFER, 0, (GLsizeiptr)(dataTest.size() * sizeof(unsigned int)), |
| &dataTest[0]); |
| result.sub_result(DataCompare(dataRef6, dataWidth, dataHeight, dataTest, dataWidth, dataHeight)); |
| |
| CDataArray dataRef7; |
| DataGen<unsigned int>(dataRef7, dataWidth, dataHeight, 4, 70); |
| |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _buffers[7]); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, (GLsizeiptr)(dataRef7.size() * sizeof(unsigned int)), &dataRef7[0], |
| GL_DYNAMIC_COPY); |
| result.sub_result(BindingPointCheck<api>(_buffers[7])); |
| |
| GetBufferSubData<api>(GL_DRAW_INDIRECT_BUFFER, 0, (GLsizeiptr)(dataTest.size() * sizeof(unsigned int)), |
| &dataTest[0]); |
| result.sub_result(DataCompare(dataRef7, dataWidth, dataHeight, dataTest, dataWidth, dataHeight)); |
| |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _buffers[8]); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, 800, NULL, GL_STREAM_COPY); |
| result.sub_result(BindingPointCheck<api>(_buffers[8])); |
| |
| CDataArray dataRef9; |
| DataGen<unsigned int>(dataRef9, dataWidth, dataHeight, 18, 35); |
| |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _buffers[9]); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, (GLsizeiptr)(dataRef9.size() * sizeof(unsigned int)), &dataRef9[0], |
| GL_STATIC_COPY); |
| result.sub_result(BindingPointCheck<api>(_buffers[9])); |
| |
| GetBufferSubData<api>(GL_DRAW_INDIRECT_BUFFER, 0, (GLsizeiptr)(dataTest.size() * sizeof(unsigned int)), |
| &dataTest[0]); |
| result.sub_result(DataCompare(dataRef9, dataWidth, dataHeight, dataTest, dataWidth, dataHeight)); |
| |
| //reallocation: same size |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, (GLsizeiptr)(dataRef9.size() * sizeof(unsigned int)), &dataRef9[0], |
| GL_STATIC_COPY); |
| GetBufferSubData<api>(GL_DRAW_INDIRECT_BUFFER, 0, (GLsizeiptr)(dataTest.size() * sizeof(unsigned int)), |
| &dataTest[0]); |
| result.sub_result(DataCompare(dataRef9, dataWidth, dataHeight, dataTest, dataWidth, dataHeight)); |
| |
| //reallocation: larger size |
| DataGen<unsigned int>(dataRef9, dataWidth * 2, dataHeight * 2, 18, 35); |
| dataTest.resize(dataRef9.size()); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, (GLsizeiptr)(dataRef9.size() * sizeof(unsigned int)), &dataRef9[0], |
| GL_STATIC_COPY); |
| GetBufferSubData<api>(GL_DRAW_INDIRECT_BUFFER, 0, (GLsizeiptr)(dataTest.size() * sizeof(unsigned int)), |
| &dataTest[0]); |
| result.sub_result( |
| DataCompare(dataRef9, dataWidth * 2, dataHeight * 2, dataTest, dataWidth * 2, dataHeight * 2)); |
| |
| //reallocation: smaller size |
| DataGen<unsigned int>(dataRef9, dataWidth / 2, dataHeight / 2, 18, 35); |
| dataTest.resize(dataRef9.size()); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, (GLsizeiptr)(dataRef9.size() * sizeof(unsigned int)), &dataRef9[0], |
| GL_STATIC_COPY); |
| GetBufferSubData<api>(GL_DRAW_INDIRECT_BUFFER, 0, (GLsizeiptr)(dataTest.size() * sizeof(unsigned int)), |
| &dataTest[0]); |
| result.sub_result( |
| DataCompare(dataRef9, dataWidth / 2, dataHeight / 2, dataTest, dataWidth / 2, dataHeight / 2)); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDeleteBuffers(sizeof(_buffers) / sizeof(_buffers[0]), _buffers); |
| return BindingPointCheck<api>(0); |
| } |
| |
| private: |
| GLuint _buffers[10]; |
| }; |
| |
| template <typename api> |
| struct CBufferSubData : public DrawIndirectBase |
| { |
| virtual std::string Title() |
| { |
| return "Check function: glBufferSubData and GetBufferSubData<api>"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that glBufferSubData and GetBufferSubData<api> accepts GL_DRAW_INDIRECT_BUFFER enum"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create buffer" NL "2. Bind buffer" NL "3. Allocate buffer using glBufferData" NL |
| "4. Set data using glBufferSubData" NL "5. Get data using GetBufferSubData<api>" NL "6. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| virtual long Run() |
| { |
| DIResult result; |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _buffer); |
| |
| CDataArray dataRef; |
| int dataWidth, dataHeight; |
| getDataSize(dataWidth, dataHeight); |
| DataGen<unsigned int>(dataRef, dataWidth, dataHeight, 4, 70); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, (GLsizeiptr)(dataRef.size() * sizeof(unsigned int)), NULL, |
| GL_DYNAMIC_DRAW); |
| glBufferSubData(GL_DRAW_INDIRECT_BUFFER, 0, (GLsizeiptr)(dataRef.size() * sizeof(unsigned int)), &dataRef[0]); |
| |
| CDataArray dataTest(dataWidth * dataHeight, 0); |
| GetBufferSubData<api>(GL_DRAW_INDIRECT_BUFFER, 0, (GLsizeiptr)(dataTest.size() * sizeof(unsigned int)), |
| &dataTest[0]); |
| |
| result.sub_result(DataCompare(dataRef, dataWidth, dataHeight, dataTest, dataWidth, dataHeight)); |
| |
| CDataArray dataSubRef; |
| DataGen<unsigned int>(dataSubRef, dataWidth / 2, dataHeight / 2, 80, 90); |
| glBufferSubData(GL_DRAW_INDIRECT_BUFFER, 4, (GLsizeiptr)(dataSubRef.size() * sizeof(unsigned int)), |
| &dataSubRef[0]); |
| std::copy(dataSubRef.begin(), dataSubRef.end(), dataRef.begin() + 1); |
| |
| GetBufferSubData<api>(GL_DRAW_INDIRECT_BUFFER, 0, (GLsizeiptr)(dataTest.size() * sizeof(unsigned int)), |
| &dataTest[0]); |
| result.sub_result(DataCompare(dataRef, dataWidth, dataHeight, dataTest, dataWidth, dataHeight)); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDeleteBuffers(1, &_buffer); |
| return BindingPointCheck<api>(0); |
| } |
| |
| private: |
| GLuint _buffer; |
| }; |
| |
| template <typename api> |
| struct CBufferMap : public DrawIndirectBase |
| { |
| virtual std::string Title() |
| { |
| return "Check functions: glMapBuffer, glUnmapBuffer and getParameteriv"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that glMapBuffer, glUnmapBuffer and getParameteriv accepts GL_DRAW_INDIRECT_BUFFER enum"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create buffer" NL "2. Bind buffer" NL "3. Set data" NL "4. Map buffer" NL |
| "5. Verify mapped buffer" NL "6. Check state" NL "7. Unmap buffer" NL "8. Check state"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| virtual long Run() |
| { |
| DIResult result; |
| |
| api::GL_Only(); |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _buffer); |
| |
| CDataArray dataRef; |
| int dataWidth, dataHeight; |
| getDataSize(dataWidth, dataHeight); |
| DataGen<unsigned int>(dataRef, dataWidth, dataHeight, 30, 50); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, (GLsizeiptr)(dataRef.size() * sizeof(unsigned int)), &dataRef[0], |
| GL_DYNAMIC_DRAW); |
| |
| result.sub_result(StateValidate<api>(GL_FALSE, GL_READ_WRITE, 0, 0, 0)); |
| |
| void* buf = glMapBuffer(GL_DRAW_INDIRECT_BUFFER, GL_READ_ONLY); |
| if (buf == 0) |
| { |
| result.error() << "glMapBuffer(GL_DRAW_INDIRECT_BUFFER, GL_READ_ONLY) returned NULL"; |
| } |
| |
| if (buf) |
| { |
| result.sub_result(BufferCheck(dataRef, dataWidth, dataHeight, buf, dataWidth, dataHeight)); |
| |
| result.sub_result(StateValidate<api>(GL_TRUE, GL_READ_ONLY, GL_MAP_READ_BIT, 0, |
| (GLsizeiptr)(dataRef.size() * sizeof(unsigned int)))); |
| |
| if (glUnmapBuffer(GL_DRAW_INDIRECT_BUFFER) == GL_FALSE) |
| { |
| result.error() << "glUnmapBuffer(GL_DRAW_INDIRECT_BUFFER) returned GL_FALSE, expected GL_TRUE"; |
| } |
| buf = 0; |
| |
| result.sub_result(StateValidate<api>(GL_FALSE, GL_READ_WRITE, 0, 0, 0)); |
| } |
| |
| buf = glMapBuffer(GL_DRAW_INDIRECT_BUFFER, GL_WRITE_ONLY); |
| if (buf == 0) |
| { |
| result.error() << "glMapBuffer(GL_DRAW_INDIRECT_BUFFER, GL_WRITE_ONLY) returned NULL"; |
| } |
| |
| if (buf) |
| { |
| result.sub_result(BufferCheck(dataRef, dataWidth, dataHeight, buf, dataWidth, dataHeight)); |
| |
| result.sub_result(StateValidate<api>(GL_TRUE, GL_WRITE_ONLY, GL_MAP_WRITE_BIT, 0, |
| (GLsizeiptr)(dataRef.size() * sizeof(unsigned int)))); |
| |
| if (glUnmapBuffer(GL_DRAW_INDIRECT_BUFFER) != GL_TRUE) |
| { |
| result.error() << "glUnmapBuffer(GL_DRAW_INDIRECT_BUFFER) returned GL_FALSE, expected GL_TRUE"; |
| } |
| buf = 0; |
| |
| result.sub_result(StateValidate<api>(GL_FALSE, GL_READ_WRITE, 0, 0, 0)); |
| } |
| |
| buf = glMapBuffer(GL_DRAW_INDIRECT_BUFFER, GL_READ_WRITE); |
| if (buf == 0) |
| { |
| result.error() << "glMapBuffer(GL_DRAW_INDIRECT_BUFFER, GL_READ_WRITE) returned NULL"; |
| } |
| |
| if (buf) |
| { |
| result.sub_result(BufferCheck(dataRef, dataWidth, dataHeight, buf, dataWidth, dataHeight)); |
| |
| result.sub_result(StateValidate<api>(GL_TRUE, GL_READ_WRITE, GL_MAP_WRITE_BIT | GL_MAP_READ_BIT, 0, |
| (GLsizeiptr)(dataRef.size() * sizeof(unsigned int)))); |
| |
| if (glUnmapBuffer(GL_DRAW_INDIRECT_BUFFER) == GL_FALSE) |
| { |
| result.error() << "glUnmapBuffer(GL_DRAW_INDIRECT_BUFFER) returned GL_FALSE, expected GL_TRUE"; |
| } |
| buf = 0; |
| |
| result.sub_result(StateValidate<api>(GL_FALSE, GL_READ_WRITE, 0, 0, 0)); |
| } |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDeleteBuffers(1, &_buffer); |
| return BindingPointCheck<api>(0); |
| } |
| |
| private: |
| GLuint _buffer; |
| }; |
| |
| template <typename api> |
| struct CBufferGetPointerv : public DrawIndirectBase |
| { |
| virtual std::string Title() |
| { |
| return "Check functions: glBuffergetPointerv"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that glBuffergetPointerv accepts GL_DRAW_INDIRECT_BUFFER enum"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create buffer" NL "2. Bind buffer" NL "3. Set data" NL "4. Map buffer" NL |
| "5. Get a pointer to buffer" NL "6. Compare pointers from point 4) and 5)" NL |
| "7. Verify mapped buffer" NL "8. Unmap buffer"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| virtual long Run() |
| { |
| DIResult result; |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _buffer); |
| |
| CDataArray dataRef; |
| int dataWidth, dataHeight; |
| getDataSize(dataWidth, dataHeight); |
| DataGen<unsigned int>(dataRef, dataWidth, dataHeight, 30, 50); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, (GLsizeiptr)(dataRef.size() * sizeof(unsigned int)), &dataRef[0], |
| GL_DYNAMIC_DRAW); |
| |
| void* ptr = 0; |
| glGetBufferPointerv(GL_DRAW_INDIRECT_BUFFER, GL_BUFFER_MAP_POINTER, &ptr); |
| |
| if (ptr != 0) |
| { |
| result.error() << "glGetBufferPointerv(GL_DRAW_INDIRECT_BUFFER, GL_BUFFER_MAP_POINTER) returned invalid " |
| "pointer, expected: NULL"; |
| } |
| |
| void* buf = glMapBufferRange(GL_DRAW_INDIRECT_BUFFER, 0, (GLsizeiptr)(dataRef.size() * sizeof(unsigned int)), |
| GL_MAP_READ_BIT); |
| if (buf == 0) |
| { |
| result.error() << "glMapBufferRange(GL_DRAW_INDIRECT_BUFFER, GL_MAP_READ_BIT) returned NULL"; |
| |
| return result.code(); |
| } |
| |
| glGetBufferPointerv(GL_DRAW_INDIRECT_BUFFER, GL_BUFFER_MAP_POINTER, &ptr); |
| |
| if (ptr == 0) |
| { |
| result.error() << "glGetBufferPointerv(GL_DRAW_INDIRECT_BUFFER, GL_BUFFER_MAP_POINTER) returned NULL"; |
| } |
| |
| if (ptr) |
| { |
| result.sub_result(BufferCheck(dataRef, dataWidth, dataHeight, ptr, dataWidth, dataHeight)); |
| } |
| |
| if (ptr != buf) |
| { |
| result.error() << "glGetBufferPointerv(GL_DRAW_INDIRECT_BUFFER, GL_BUFFER_MAP_POINTER) different pointer " |
| "than glMapBuffer(GL_DRAW_INDIRECT_BUFFER)"; |
| } |
| |
| if (glUnmapBuffer(GL_DRAW_INDIRECT_BUFFER) == GL_FALSE) |
| { |
| result.error() << "glUnmapBuffer(GL_DRAW_INDIRECT_BUFFER) returned GL_FALSE, expected GL_TRUE"; |
| } |
| buf = 0; |
| ptr = 0; |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDeleteBuffers(1, &_buffer); |
| return BindingPointCheck<api>(0); |
| } |
| |
| private: |
| GLuint _buffer; |
| }; |
| |
| template <class api> |
| struct CBufferMapRange : public DrawIndirectBase |
| { |
| virtual std::string Title() |
| { |
| return "Check functions: glMapRangeBuffer, glUnmapBuffer and getParameteriv"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that glMapRangeBuffer, glUnmapBuffer and getParameteriv accepts GL_DRAW_INDIRECT_BUFFER enum"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "Bind non-zero buffer and check that binding point is set to correct value"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "1. Create buffer" NL "2. Bind buffer" NL "3. Set data" NL "4. Map buffer using glMapBufferRange" NL |
| "5. Check state" NL "6. Verify mapped buffer" NL "7. Unmap buffer" NL "8. Check state"; |
| } |
| |
| virtual long Run() |
| { |
| DIResult result; |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _buffer); |
| |
| CDataArray dataRef; |
| int dataWidth, dataHeight; |
| getDataSize(dataWidth, dataHeight); |
| DataGen<unsigned int>(dataRef, dataWidth, dataHeight, 30, 50); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, (GLsizeiptr)(dataRef.size() * sizeof(unsigned int)), &dataRef[0], |
| GL_DYNAMIC_DRAW); |
| |
| result.sub_result(StateValidate<api>(GL_FALSE, GL_READ_WRITE, 0, 0, 0)); |
| |
| void* buf = glMapBufferRange(GL_DRAW_INDIRECT_BUFFER, 0, (GLsizeiptr)(dataRef.size() * sizeof(unsigned int)), |
| GL_MAP_READ_BIT); |
| if (buf == 0) |
| { |
| result.error() << "glMapBuffer(GL_DRAW_INDIRECT_BUFFER, GL_MAP_READ_BIT) returned NULL"; |
| } |
| |
| if (buf) |
| { |
| result.sub_result(BufferCheck(dataRef, dataWidth, dataHeight, buf, dataWidth, dataHeight)); |
| |
| result.sub_result(StateValidate<api>(GL_TRUE, GL_READ_ONLY, GL_MAP_READ_BIT, 0, |
| (GLsizeiptr)(dataRef.size() * sizeof(unsigned int)))); |
| |
| if (glUnmapBuffer(GL_DRAW_INDIRECT_BUFFER) == GL_FALSE) |
| { |
| result.error() << "glUnmapBuffer(GL_DRAW_INDIRECT_BUFFER) returned GL_FALSE, expected GL_TRUE"; |
| } |
| buf = 0; |
| |
| result.sub_result(StateValidate<api>(GL_FALSE, GL_READ_WRITE, 0, 0, 0)); |
| } |
| |
| buf = glMapBufferRange(GL_DRAW_INDIRECT_BUFFER, 0, (GLsizeiptr)(dataRef.size() / 2 * sizeof(unsigned int)), |
| GL_MAP_WRITE_BIT); |
| if (buf == 0) |
| { |
| result.error() << "glMapBufferRange(GL_DRAW_INDIRECT_BUFFER, GL_MAP_WRITE_BIT) returned NULL"; |
| } |
| |
| if (buf) |
| { |
| result.sub_result(BufferCheck(dataRef, dataWidth, dataHeight / 2, buf, dataWidth, dataHeight / 2)); |
| |
| result.sub_result(StateValidate<api>(GL_TRUE, GL_WRITE_ONLY, GL_MAP_WRITE_BIT, 0, |
| (GLsizeiptr)(dataRef.size() / 2 * sizeof(unsigned int)))); |
| |
| if (glUnmapBuffer(GL_DRAW_INDIRECT_BUFFER) == GL_FALSE) |
| { |
| result.error() << "glUnmapBuffer(GL_DRAW_INDIRECT_BUFFER) returned GL_FALSE, expected GL_TRUE"; |
| } |
| buf = 0; |
| |
| result.sub_result(StateValidate<api>(GL_FALSE, GL_READ_WRITE, 0, 0, 0)); |
| } |
| |
| buf = glMapBufferRange(GL_DRAW_INDIRECT_BUFFER, (GLintptr)(dataRef.size() / 4 * sizeof(unsigned int)), |
| (GLsizeiptr)(dataRef.size() / 2 * sizeof(unsigned int)), GL_MAP_WRITE_BIT); |
| if (buf == 0) |
| { |
| result.error() << "glMapBufferRange(GL_DRAW_INDIRECT_BUFFER, GL_MAP_WRITE_BIT) returned NULL"; |
| } |
| |
| if (buf) |
| { |
| result.sub_result( |
| BufferCheck(dataRef, dataWidth, dataHeight / 2, buf, dataWidth, dataHeight / 2, dataHeight / 4)); |
| |
| result.sub_result(StateValidate<api>(GL_TRUE, GL_WRITE_ONLY, GL_MAP_WRITE_BIT, |
| (GLintptr)(dataRef.size() / 4 * sizeof(unsigned int)), |
| (GLsizeiptr)(dataRef.size() / 2 * sizeof(unsigned int)))); |
| |
| if (glUnmapBuffer(GL_DRAW_INDIRECT_BUFFER) == GL_FALSE) |
| { |
| result.error() << "glUnmapBuffer(GL_DRAW_INDIRECT_BUFFER) returned GL_FALSE, expected GL_TRUE"; |
| } |
| buf = 0; |
| |
| result.sub_result(StateValidate<api>(GL_FALSE, GL_READ_WRITE, 0, 0, 0)); |
| } |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDeleteBuffers(1, &_buffer); |
| return BindingPointCheck<api>(0); |
| } |
| |
| private: |
| GLuint _buffer; |
| }; |
| |
| template <class api> |
| struct CBufferFlushMappedRange : public DrawIndirectBase |
| { |
| virtual std::string Title() |
| { |
| return "Check functions: glFlushMappedBufferRange"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that glFlushMappedBufferRange and getParameteriv accepts GL_DRAW_INDIRECT_BUFFER enum"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create buffer" NL "2. Bind buffer" NL "3. Set data" NL |
| "4. Map buffer with GL_MAP_FLUSH_EXPLICIT_BIT flag" NL "5. Check state" NL "6. Modify mapped buffer" NL |
| "7. Flush buffer" NL "8. Unmap buffer" NL "9. Check state" NL "10. Verify buffer"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| virtual long Run() |
| { |
| DIResult result; |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _buffer); |
| |
| CDataArray dataRef; |
| int dataWidth, dataHeight; |
| getDataSize(dataWidth, dataHeight); |
| DataGen<unsigned int>(dataRef, dataWidth, dataHeight, 1, 1000); |
| |
| CDataArray dataRef2; |
| DataGen<unsigned int>(dataRef2, dataWidth, dataHeight, 1000, 2000); |
| |
| const int halfSize = dataHeight / 2 * dataWidth; |
| const int quarterSize = dataHeight / 4 * dataWidth; |
| |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, (GLsizeiptr)(dataRef.size() * sizeof(unsigned int)), &dataRef[0], |
| GL_DYNAMIC_DRAW); |
| |
| result.sub_result(StateValidate<api>(GL_FALSE, GL_READ_WRITE, 0, 0, 0)); |
| |
| void* buf = glMapBufferRange(GL_DRAW_INDIRECT_BUFFER, quarterSize * sizeof(unsigned int), |
| halfSize * sizeof(unsigned int), GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT); |
| |
| if (buf == 0) |
| { |
| result.error() << "glMapBufferRange(GL_DRAW_INDIRECT_BUFFER, GL_MAP_WRITE_BIT) returned NULL"; |
| } |
| |
| if (buf) |
| { |
| result.sub_result(StateValidate<api>(GL_TRUE, GL_WRITE_ONLY, GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT, |
| quarterSize * sizeof(unsigned int), halfSize * sizeof(unsigned int))); |
| |
| memcpy(buf, &dataRef2[quarterSize], halfSize * sizeof(unsigned int)); |
| glFlushMappedBufferRange(GL_DRAW_INDIRECT_BUFFER, 0, halfSize * sizeof(unsigned int)); |
| |
| if (glUnmapBuffer(GL_DRAW_INDIRECT_BUFFER) == GL_FALSE) |
| { |
| result.error() << "glUnmapBuffer(GL_DRAW_INDIRECT_BUFFER) returned GL_FALSE, expected GL_TRUE"; |
| } |
| buf = 0; |
| |
| result.sub_result(StateValidate<api>(GL_FALSE, GL_READ_WRITE, 0, 0, 0)); |
| } |
| |
| CDataArray dataTest(dataWidth * dataHeight, 0); |
| GetBufferSubData<api>(GL_DRAW_INDIRECT_BUFFER, 0, (GLsizeiptr)(dataTest.size() * sizeof(unsigned int)), |
| &dataTest[0]); |
| |
| result.sub_result(DataCompare(dataRef, dataWidth, dataHeight / 4, dataTest, dataWidth, dataHeight / 4)); |
| |
| result.sub_result(DataCompare(dataRef2, dataWidth, dataHeight / 2, dataTest, dataWidth, dataHeight / 2, |
| dataHeight / 4, dataHeight / 4)); |
| |
| result.sub_result(DataCompare(dataRef, dataWidth, dataHeight / 4, dataTest, dataWidth, dataHeight / 4, |
| dataHeight * 3 / 4, dataHeight * 3 / 4)); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDeleteBuffers(1, &_buffer); |
| return BindingPointCheck<api>(0); |
| } |
| |
| private: |
| GLuint _buffer; |
| }; |
| |
| template <class api> |
| struct CBufferBindRange : public DrawIndirectBase |
| { |
| virtual std::string Title() |
| { |
| return "Check functions: glBindBufferRange"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that glBindBufferRange accepts GL_DRAW_INDIRECT_BUFFER enum"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create buffer" NL "2. Bind buffer using glBindBufferRange" NL "3. Set data" NL "4. Verify buffer"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| virtual long Run() |
| { |
| DIResult result; |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _buffer); |
| |
| CDataArray dataRef; |
| int dataWidth, dataHeight; |
| getDataSize(dataWidth, dataHeight); |
| DataGen<unsigned int>(dataRef, dataWidth, dataHeight, 1, 100); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, dataRef.size() * sizeof(unsigned int), &dataRef[0], GL_DYNAMIC_DRAW); |
| |
| CDataArray dataTest(dataWidth * dataHeight, 0); |
| GetBufferSubData<api>(GL_DRAW_INDIRECT_BUFFER, 0, dataTest.size() * sizeof(unsigned int), &dataTest[0]); |
| result.sub_result(DataCompare(dataRef, dataWidth, dataHeight, dataTest, dataWidth, dataHeight)); |
| |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, 0); |
| result.sub_result(BindingPointCheck<api>(0)); |
| |
| glBindBufferRange(GL_DRAW_INDIRECT_BUFFER, 0, _buffer, 0, dataTest.size() * sizeof(unsigned int) / 4); |
| result.sub_result(BindingPointCheck<api>(_buffer)); |
| |
| CDataArray dataRef2; |
| DataGen<unsigned int>(dataRef2, dataWidth, dataHeight / 2, 10, 15); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, dataRef2.size() * sizeof(unsigned int) / 4, &dataRef2[0], |
| GL_DYNAMIC_DRAW); |
| |
| GetBufferSubData<api>(GL_DRAW_INDIRECT_BUFFER, 0, dataTest.size() * sizeof(unsigned int), &dataTest[0]); |
| result.sub_result(DataCompare(dataRef2, dataWidth, dataHeight / 4, dataTest, dataWidth, dataHeight / 4)); |
| result.sub_result(DataCompare(dataRef, dataWidth, dataHeight * 3 / 4, dataTest, dataWidth, dataHeight * 3 / 4, |
| dataHeight / 4, dataHeight / 4)); |
| |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, 0); |
| result.sub_result(BindingPointCheck<api>(0)); |
| |
| glBindBufferRange(GL_DRAW_INDIRECT_BUFFER, 0, _buffer, dataTest.size() * sizeof(unsigned int) / 4, |
| dataTest.size() * sizeof(unsigned int) / 4); |
| result.sub_result(BindingPointCheck<api>(_buffer)); |
| |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, dataRef2.size() * sizeof(unsigned int) / 2, |
| &dataRef2[dataRef2.size() / 2], GL_DYNAMIC_DRAW); |
| result.sub_result(DataCompare(dataRef2, dataWidth, dataHeight / 2, dataTest, dataWidth, dataHeight / 2)); |
| result.sub_result(DataCompare(dataRef, dataWidth, dataHeight / 2, dataTest, dataWidth, dataHeight / 2, |
| dataHeight / 2, dataHeight / 2)); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDeleteBuffers(1, &_buffer); |
| |
| return BindingPointCheck<api>(0); |
| } |
| |
| private: |
| GLuint _buffer; |
| }; |
| |
| template <class api> |
| struct CBufferBindBase : public DrawIndirectBase |
| { |
| virtual std::string Title() |
| { |
| return "Check functions: glBindBufferBase"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that glBindBufferBase accepts GL_DRAW_INDIRECT_BUFFER enum"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create buffer" NL "2. Bind buffer using glBindBufferBase" NL "3. Set data" NL "4. Verify buffer"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| virtual long Run() |
| { |
| DIResult result; |
| |
| glGenBuffers(2, _buffers); |
| |
| int dataWidth, dataHeight; |
| getDataSize(dataWidth, dataHeight); |
| CDataArray dataTest(dataWidth * dataHeight, 0); |
| |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _buffers[0]); |
| CDataArray dataRef1; |
| DataGen<unsigned int>(dataRef1, dataWidth, dataHeight, 1, 100); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, dataRef1.size() * sizeof(unsigned int), &dataRef1[0], GL_DYNAMIC_DRAW); |
| |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, 0); |
| result.sub_result(BindingPointCheck<api>(0)); |
| |
| GetBufferSubData<api>(GL_DRAW_INDIRECT_BUFFER, 0, dataTest.size() * sizeof(unsigned int), &dataTest[0]); |
| result.sub_result(DataCompare(dataRef1, dataWidth, dataHeight, dataTest, dataWidth, dataHeight)); |
| result.sub_result(BindingPointCheck<api>(_buffers[0])); |
| |
| glBindBufferBase(GL_DRAW_INDIRECT_BUFFER, 0, _buffers[1]); |
| result.sub_result(BindingPointCheck<api>(_buffers[1])); |
| |
| CDataArray dataRef2; |
| DataGen<unsigned int>(dataRef2, dataWidth, dataHeight, 50, 70); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, dataRef2.size() * sizeof(unsigned int), &dataRef2[0], GL_DYNAMIC_DRAW); |
| |
| GetBufferSubData<api>(GL_DRAW_INDIRECT_BUFFER, 0, dataTest.size() * sizeof(unsigned int), &dataTest[0]); |
| result.sub_result(DataCompare(dataRef2, dataWidth, dataHeight, dataTest, dataWidth, dataHeight)); |
| |
| result.sub_result(BindingPointCheck<api>(_buffers[1])); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDeleteBuffers(2, _buffers); |
| return BindingPointCheck<api>(0); |
| } |
| |
| private: |
| GLuint _buffers[2]; |
| }; |
| |
| template <class api> |
| struct CBufferCopySubData : public DrawIndirectBase |
| { |
| virtual std::string Title() |
| { |
| return "Check functions: glCopyBufferSubData"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that glCopyBufferSubData accepts GL_DRAW_INDIRECT_BUFFER enum"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create buffer" NL "2. Bind buffer" NL "3. Set data" NL "4. Verify buffer" NL |
| "5. Modify buffer using glCopyBufferSubData" NL "6. Verify buffer"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| virtual long Run() |
| { |
| DIResult result; |
| int dataWidth, dataHeight; |
| getDataSize(dataWidth, dataHeight); |
| CDataArray dataTest(dataWidth * dataHeight, 0); |
| |
| glGenBuffers(2, _buffers); |
| glBindBuffer(GL_ARRAY_BUFFER, _buffers[0]); |
| |
| CDataArray dataRef1; |
| DataGen<unsigned int>(dataRef1, dataWidth, dataHeight, 1, 100); |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(dataRef1.size() * sizeof(unsigned int)), &dataRef1[0], |
| GL_DYNAMIC_DRAW); |
| |
| GetBufferSubData<api>(GL_ARRAY_BUFFER, 0, (GLsizeiptr)(dataTest.size() * sizeof(unsigned int)), &dataTest[0]); |
| result.sub_result(DataCompare(dataRef1, dataWidth, dataHeight, dataTest, dataWidth, dataHeight)); |
| |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _buffers[1]); |
| |
| CDataArray dataRef2; |
| DataGen<unsigned int>(dataRef2, dataWidth, dataHeight, 10, 30); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, (GLsizeiptr)(dataRef2.size() * sizeof(unsigned int)), &dataRef2[0], |
| GL_DYNAMIC_DRAW); |
| |
| GetBufferSubData<api>(GL_DRAW_INDIRECT_BUFFER, 0, (GLsizeiptr)(dataTest.size() * sizeof(unsigned int)), |
| &dataTest[0]); |
| result.sub_result(DataCompare(dataRef2, dataWidth, dataHeight, dataTest, dataWidth, dataHeight)); |
| |
| glCopyBufferSubData(GL_ARRAY_BUFFER, GL_DRAW_INDIRECT_BUFFER, 0, 0, |
| (GLsizeiptr)(dataTest.size() * sizeof(unsigned int))); |
| |
| GetBufferSubData<api>(GL_DRAW_INDIRECT_BUFFER, 0, (GLsizeiptr)(dataTest.size() * sizeof(unsigned int)), |
| &dataTest[0]); |
| result.sub_result(DataCompare(dataRef1, dataWidth, dataHeight, dataTest, dataWidth, dataHeight)); |
| |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, (GLsizeiptr)(dataRef2.size() * sizeof(unsigned int)), &dataRef2[0], |
| GL_DYNAMIC_DRAW); |
| |
| GetBufferSubData<api>(GL_DRAW_INDIRECT_BUFFER, 0, (GLsizeiptr)(dataTest.size() * sizeof(unsigned int)), |
| &dataTest[0]); |
| result.sub_result(DataCompare(dataRef2, dataWidth, dataHeight, dataTest, dataWidth, dataHeight)); |
| |
| glCopyBufferSubData(GL_DRAW_INDIRECT_BUFFER, GL_ARRAY_BUFFER, 0, 0, |
| (GLsizeiptr)(dataTest.size() * sizeof(unsigned int))); |
| |
| GetBufferSubData<api>(GL_ARRAY_BUFFER, 0, (GLsizeiptr)(dataTest.size() * sizeof(unsigned int)), &dataTest[0]); |
| result.sub_result(DataCompare(dataRef2, dataWidth, dataHeight, dataTest, dataWidth, dataHeight)); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDeleteBuffers(2, _buffers); |
| return BindingPointCheck<api>(0); |
| } |
| |
| private: |
| GLuint _buffers[2]; |
| }; |
| |
| class CBasicVertexDef : public DrawIndirectBase |
| { |
| public: |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| template <typename api> |
| long Run() |
| { |
| CColorArray coords; |
| PrimitiveGen(_primitiveType, _drawSizeX, _drawSizeY, coords); |
| |
| _program = CreateProgram(shaders::vshSimple<api>(), "", shaders::fshSimple<api>(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| glGenBuffers(1, &_vbo); |
| glBindBuffer(GL_ARRAY_BUFFER, _vbo); |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords.size() * sizeof(coords[0])), &coords[0], GL_STATIC_DRAW); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(coords[0]), 0); |
| glEnableVertexAttribArray(0); |
| |
| DrawArraysIndirectCommand indirectArrays = { 0, 0, 0, 0 }; |
| DrawElementsIndirectCommand indirectElements = { 0, 0, 0, 0, 0 }; |
| |
| CElementArray elements(coords.size(), 0); |
| for (size_t i = 0; i < elements.size(); ++i) |
| { |
| elements[i] = static_cast<GLuint>(i); |
| } |
| |
| switch (_drawFunc) |
| { |
| case DRAW_ARRAYS: |
| { |
| indirectArrays.count = static_cast<GLuint>(coords.size()); |
| indirectArrays.primCount = 1; |
| indirectArrays.first = 0; |
| indirectArrays.reservedMustBeZero = 0; |
| |
| { |
| GLuint buffer; |
| glGenBuffers(1, &buffer); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, buffer); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(indirectArrays), &indirectArrays, GL_STATIC_DRAW); |
| glDrawArraysIndirect(_primitiveType, 0); |
| glDeleteBuffers(1, &buffer); |
| } |
| } |
| break; |
| case DRAW_ELEMENTS: |
| { |
| indirectElements.count = static_cast<GLuint>(coords.size()); |
| indirectElements.primCount = 1; |
| indirectElements.firstIndex = 0; |
| indirectElements.baseVertex = 0; |
| indirectElements.reservedMustBeZero = 0; |
| |
| glGenBuffers(1, &_ebo); |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ebo); |
| glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)(elements.size() * sizeof(elements[0])), &elements[0], |
| GL_STATIC_DRAW); |
| |
| { |
| GLuint buffer; |
| glGenBuffers(1, &buffer); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, buffer); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(indirectElements), &indirectElements, GL_STATIC_DRAW); |
| glDrawElementsIndirect(_primitiveType, GL_UNSIGNED_INT, 0); |
| glDeleteBuffers(1, &buffer); |
| } |
| } |
| break; |
| default: |
| throw std::runtime_error("Unknown draw function!"); |
| break; |
| } |
| |
| CColorArray bufferRef(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.1f, 0.2f, 0.3f, 1.0f)); |
| CColorArray bufferTest(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.0f)); |
| ReadPixelsFloat<api>(0, 0, getWindowWidth(), getWindowHeight(), &bufferTest[0]); |
| |
| DIResult result; |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight(), bufferRef, getWindowWidth(), |
| getWindowHeight())); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glBindBuffer(GL_ARRAY_BUFFER, 0); |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); |
| glBindVertexArray(0); |
| glUseProgram(0); |
| |
| if (_vao) |
| { |
| glDeleteVertexArrays(1, &_vao); |
| } |
| if (_vbo) |
| { |
| glDeleteBuffers(1, &_vbo); |
| } |
| if (_ebo) |
| { |
| glDeleteBuffers(1, &_ebo); |
| } |
| if (_program) |
| { |
| glDeleteProgram(_program); |
| } |
| |
| return NO_ERROR; |
| } |
| |
| CBasicVertexDef(TDrawFunction drawFunc, GLenum primitiveType, unsigned int drawSizeX, unsigned int drawSizeY) |
| : _drawFunc(drawFunc) |
| , _primitiveType(primitiveType) |
| , _drawSizeX(drawSizeX) |
| , _drawSizeY(drawSizeY) |
| , _vao(0) |
| , _vbo(0) |
| , _ebo(0) |
| , _program(0) |
| { |
| } |
| |
| private: |
| TDrawFunction _drawFunc; |
| GLenum _primitiveType; |
| unsigned int _drawSizeX; |
| unsigned int _drawSizeY; |
| |
| GLuint _vao; |
| GLuint _vbo, _ebo; |
| GLuint _program; |
| |
| CBasicVertexDef() |
| { |
| } |
| }; |
| |
| class CBasicVertexInstancingDef : public DrawIndirectBase |
| { |
| public: |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| template <typename api> |
| long Run() |
| { |
| CColorArray coords; |
| PrimitiveGen(GL_TRIANGLES, _drawSizeX, _drawSizeY, coords); |
| |
| CColorArray coords_instanced(4); |
| coords_instanced[0] = tcu::Vec4(0.5, 0.5, 0.0, 0.0); |
| coords_instanced[1] = tcu::Vec4(-0.5, 0.5, 0.0, 0.0); |
| coords_instanced[2] = tcu::Vec4(-0.5, -0.5, 0.0, 0.0); |
| coords_instanced[3] = tcu::Vec4(0.5, -0.5, 0.0, 0.0); |
| |
| CColorArray colors_instanced(2); |
| colors_instanced[0] = tcu::Vec4(1.0, 0.0, 0.0, 1.0); |
| colors_instanced[1] = tcu::Vec4(0.0, 1.0, 0.0, 1.0); |
| |
| _program = CreateProgram(Vsh<api>(), "", Fsh<api>(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| glGenBuffers(1, &_vbo); |
| glBindBuffer(GL_ARRAY_BUFFER, _vbo); |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords.size() * sizeof(coords[0]) + |
| coords_instanced.size() * sizeof(coords_instanced[0]) + |
| colors_instanced.size() * sizeof(colors_instanced[0])), |
| NULL, GL_STATIC_DRAW); |
| |
| const size_t coords_offset = 0; |
| const size_t coords_instanced_offset = coords_offset + coords.size() * sizeof(coords[0]); |
| const size_t colors_instanced_offset = |
| coords_instanced_offset + coords_instanced.size() * sizeof(coords_instanced[0]); |
| |
| glBufferSubData(GL_ARRAY_BUFFER, coords_offset, (GLsizeiptr)(coords.size() * sizeof(coords[0])), &coords[0]); |
| glBufferSubData(GL_ARRAY_BUFFER, (GLintptr)coords_instanced_offset, |
| (GLsizeiptr)(coords_instanced.size() * sizeof(coords_instanced[0])), &coords_instanced[0]); |
| glBufferSubData(GL_ARRAY_BUFFER, (GLintptr)colors_instanced_offset, |
| (GLsizeiptr)(colors_instanced.size() * sizeof(colors_instanced[0])), &colors_instanced[0]); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| |
| //i_vertex (coords) |
| glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, reinterpret_cast<glw::GLvoid*>(coords_offset)); |
| glEnableVertexAttribArray(0); |
| |
| //i_vertex_instanced (coords_instanced) |
| glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, reinterpret_cast<glw::GLvoid*>(coords_instanced_offset)); |
| glEnableVertexAttribArray(1); |
| glVertexAttribDivisor(1, 1); |
| |
| //i_vertex_color_instanced (color_instanced) |
| glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, 0, reinterpret_cast<glw::GLvoid*>(colors_instanced_offset)); |
| glEnableVertexAttribArray(2); |
| glVertexAttribDivisor(2, 3); |
| |
| DrawArraysIndirectCommand indirectArrays = { 0, 0, 0, 0 }; |
| DrawElementsIndirectCommand indirectElements = { 0, 0, 0, 0, 0 }; |
| |
| CElementArray elements(coords.size(), 0); |
| for (size_t i = 0; i < elements.size(); ++i) |
| { |
| elements[i] = static_cast<GLuint>(i); |
| } |
| |
| switch (_drawFunc) |
| { |
| case DRAW_ARRAYS: |
| { |
| indirectArrays.count = static_cast<GLuint>(coords.size()); |
| indirectArrays.primCount = 4; |
| indirectArrays.first = 0; |
| indirectArrays.reservedMustBeZero = 0; |
| |
| { |
| GLuint buffer; |
| glGenBuffers(1, &buffer); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, buffer); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(indirectArrays), &indirectArrays, GL_STATIC_DRAW); |
| glDrawArraysIndirect(GL_TRIANGLES, 0); |
| glDeleteBuffers(1, &buffer); |
| } |
| } |
| break; |
| case DRAW_ELEMENTS: |
| { |
| indirectElements.count = static_cast<GLuint>(coords.size()); |
| indirectElements.primCount = 4; |
| indirectElements.firstIndex = 0; |
| indirectElements.baseVertex = 0; |
| indirectElements.reservedMustBeZero = 0; |
| |
| glGenBuffers(1, &_ebo); |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ebo); |
| glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)(elements.size() * sizeof(elements[0])), &elements[0], |
| GL_STATIC_DRAW); |
| |
| { |
| GLuint buffer; |
| glGenBuffers(1, &buffer); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, buffer); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(indirectElements), &indirectElements, GL_STATIC_DRAW); |
| glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_INT, 0); |
| glDeleteBuffers(1, &buffer); |
| } |
| } |
| break; |
| default: |
| throw std::runtime_error("Unknown draw function!"); |
| break; |
| } |
| |
| CColorArray bufferRef1(getWindowWidth() / 2 * getWindowHeight() / 2, colors_instanced[0]); |
| CColorArray bufferRef2(getWindowWidth() / 2 * getWindowHeight() / 2, colors_instanced[1]); |
| |
| CColorArray bufferTest(getWindowWidth() / 2 * getWindowHeight() / 2, tcu::Vec4(0.0f)); |
| DIResult result; |
| |
| ReadPixelsFloat<api>(0, 0, getWindowWidth() / 2, getWindowHeight() / 2, &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth() / 2, getWindowHeight() / 2, bufferRef1, |
| getWindowWidth() / 2, getWindowHeight() / 2)); |
| |
| ReadPixelsFloat<api>((getWindowWidth() + 1) / 2, 0, getWindowWidth() / 2, getWindowHeight() / 2, |
| &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth() / 2, getWindowHeight() / 2, bufferRef2, |
| getWindowWidth() / 2, getWindowHeight() / 2)); |
| |
| ReadPixelsFloat<api>(0, (getWindowHeight() + 1) / 2, getWindowWidth() / 2, getWindowHeight() / 2, |
| &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth() / 2, getWindowHeight() / 2, bufferRef1, |
| getWindowWidth() / 2, getWindowHeight() / 2)); |
| |
| ReadPixelsFloat<api>((getWindowWidth() + 1) / 2, (getWindowHeight() + 1) / 2, getWindowWidth() / 2, |
| getWindowHeight() / 2, &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth() / 2, getWindowHeight() / 2, bufferRef1, |
| getWindowWidth() / 2, getWindowHeight() / 2)); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glBindBuffer(GL_ARRAY_BUFFER, 0); |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); |
| glBindVertexArray(0); |
| glUseProgram(0); |
| |
| if (_vao) |
| { |
| glDeleteVertexArrays(1, &_vao); |
| } |
| if (_vbo) |
| { |
| glDeleteBuffers(1, &_vbo); |
| } |
| if (_ebo) |
| { |
| glDeleteBuffers(1, &_ebo); |
| } |
| if (_program) |
| { |
| glDeleteProgram(_program); |
| } |
| |
| return NO_ERROR; |
| } |
| |
| template <typename api> |
| std::string Vsh() |
| { |
| return api::glslVer() + NL |
| "layout(location = 0) in vec4 i_vertex;" NL "layout(location = 1) in vec4 i_vertex_instanced;" NL |
| "layout(location = 2) in vec4 i_vertex_color_instanced;" NL "out vec4 vertex_color_instanced;" NL |
| "void main()" NL "{" NL " gl_Position = vec4(i_vertex.xyz * .5, 1.0) + i_vertex_instanced;" NL |
| " vertex_color_instanced = i_vertex_color_instanced;" NL "}"; |
| } |
| |
| template <typename api> |
| std::string Fsh() |
| { |
| return api::glslVer() + NL "precision highp float; " NL "in vec4 vertex_color_instanced;" NL |
| "out vec4 outColor;" NL "void main() {" NL " outColor = vertex_color_instanced;" NL |
| "}"; |
| } |
| |
| CBasicVertexInstancingDef(TDrawFunction drawFunc) |
| : _drawFunc(drawFunc), _drawSizeX(2), _drawSizeY(2), _vao(0), _vbo(0), _ebo(0), _program(0) |
| { |
| } |
| |
| private: |
| TDrawFunction _drawFunc; |
| unsigned int _drawSizeX; |
| unsigned int _drawSizeY; |
| |
| GLuint _vao; |
| GLuint _vbo, _ebo; |
| GLuint _program; |
| |
| CBasicVertexInstancingDef() |
| { |
| } |
| }; |
| |
| template <typename api> |
| class CVBODrawArraysSingle : public CBasicVertexDef |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "VBO: Single primitive using glDrawArraysIndirect"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that the vertex attributes can be sourced from VBO for glDrawArraysIndirect"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Define a primitive using VBO" NL "2. Draw primitive using glDrawArraysIndirect" NL |
| "3. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CVBODrawArraysSingle() : CBasicVertexDef(DRAW_ARRAYS, GL_TRIANGLES, 1, 1) |
| { |
| } |
| virtual long Run() |
| { |
| return CBasicVertexDef::Run<api>(); |
| } |
| }; |
| |
| template <typename api> |
| class CVBODrawArraysMany : public CBasicVertexDef |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "VBO: Many primitives using glDrawArraysIndirect"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that the vertex attributes can be sourced from VBO for glDrawArraysIndirect"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Define primitives using VBO" NL "2. Draw primitive using glDrawArraysIndirect" NL |
| "3. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CVBODrawArraysMany() : CBasicVertexDef(DRAW_ARRAYS, GL_TRIANGLES, 8, 8) |
| { |
| } |
| virtual long Run() |
| { |
| return CBasicVertexDef::Run<api>(); |
| } |
| }; |
| |
| template <typename api> |
| class CVBODrawArraysInstancing : public CBasicVertexInstancingDef |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "VBO: Single primitive using glDrawArraysIndirect, multiple instances"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that the vertex attributes can be sourced from VBO for glDrawArraysIndirect"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Define a primitive using VBO" NL "2. Draw primitive using glDrawArraysIndirect" NL |
| "3. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CVBODrawArraysInstancing() : CBasicVertexInstancingDef(DRAW_ARRAYS) |
| { |
| } |
| virtual long Run() |
| { |
| return CBasicVertexInstancingDef::Run<api>(); |
| } |
| }; |
| |
| class CBasicXFBPausedDef : public DrawIndirectBase |
| { |
| public: |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| template <typename api> |
| long Run() |
| { |
| CColorArray coords; |
| PrimitiveGen(GL_TRIANGLES, _drawSizeX, _drawSizeY, coords); |
| |
| _program = CreateProgram(Vsh<api>(), "", shaders::fshSimple<api>(), false); |
| |
| const GLchar* varyings[] = { "dataOut" }; |
| glTransformFeedbackVaryings(_program, 1, varyings, GL_INTERLEAVED_ATTRIBS); |
| glLinkProgram(_program); |
| if (!CheckProgram(_program)) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| glGenBuffers(1, &_vbo); |
| glBindBuffer(GL_ARRAY_BUFFER, _vbo); |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords.size() * sizeof(coords[0])), &coords[0], GL_STATIC_DRAW); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(coords[0]), 0); |
| glEnableVertexAttribArray(0); |
| |
| DrawArraysIndirectCommand indirectArrays = { 0, 0, 0, 0 }; |
| DrawElementsIndirectCommand indirectElements = { 0, 0, 0, 0, 0 }; |
| |
| CElementArray elements(coords.size(), 0); |
| for (size_t i = 0; i < elements.size(); ++i) |
| { |
| elements[i] = static_cast<GLuint>(i); |
| } |
| |
| glGenTransformFeedbacks(1, &_xfo); |
| glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, _xfo); |
| |
| glGenBuffers(1, &_xfbo); |
| glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, _xfbo); |
| glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 1024, NULL, GL_STATIC_DRAW); |
| glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, _xfbo); |
| |
| glBeginTransformFeedback(GL_TRIANGLES); |
| glPauseTransformFeedback(); |
| |
| switch (_drawFunc) |
| { |
| case DRAW_ARRAYS: |
| { |
| indirectArrays.count = static_cast<GLuint>(coords.size()); |
| indirectArrays.primCount = 1; |
| indirectArrays.first = 0; |
| indirectArrays.reservedMustBeZero = 0; |
| |
| { |
| GLuint buffer; |
| glGenBuffers(1, &buffer); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, buffer); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(indirectArrays), &indirectArrays, GL_STATIC_DRAW); |
| glDrawArraysIndirect(GL_TRIANGLES, 0); |
| glDeleteBuffers(1, &buffer); |
| } |
| } |
| break; |
| case DRAW_ELEMENTS: |
| { |
| indirectElements.count = static_cast<GLuint>(coords.size()); |
| indirectElements.primCount = 1; |
| indirectElements.firstIndex = 0; |
| indirectElements.baseVertex = 0; |
| indirectElements.reservedMustBeZero = 0; |
| |
| glGenBuffers(1, &_ebo); |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ebo); |
| glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)(elements.size() * sizeof(elements[0])), &elements[0], |
| GL_STATIC_DRAW); |
| |
| { |
| GLuint buffer; |
| glGenBuffers(1, &buffer); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, buffer); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(indirectElements), &indirectElements, GL_STATIC_DRAW); |
| glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_INT, 0); |
| glDeleteBuffers(1, &buffer); |
| } |
| } |
| |
| break; |
| default: |
| throw std::runtime_error("Unknown draw function!"); |
| break; |
| } |
| |
| glResumeTransformFeedback(); |
| glEndTransformFeedback(); |
| |
| CColorArray bufferRef(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.1f, 0.2f, 0.3f, 1.0f)); |
| CColorArray bufferTest(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.0f)); |
| ReadPixelsFloat<api>(0, 0, getWindowWidth(), getWindowHeight(), &bufferTest[0]); |
| |
| DIResult result; |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight(), bufferRef, getWindowWidth(), |
| getWindowHeight())); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glBindBuffer(GL_ARRAY_BUFFER, 0); |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); |
| glBindVertexArray(0); |
| glUseProgram(0); |
| |
| if (_vao) |
| { |
| glDeleteVertexArrays(1, &_vao); |
| } |
| if (_vbo) |
| { |
| glDeleteBuffers(1, &_vbo); |
| } |
| if (_ebo) |
| { |
| glDeleteBuffers(1, &_ebo); |
| } |
| if (_xfbo) |
| { |
| glDeleteBuffers(1, &_xfbo); |
| } |
| if (_program) |
| { |
| glDeleteProgram(_program); |
| } |
| if (_xfo) |
| { |
| glDeleteTransformFeedbacks(1, &_xfo); |
| } |
| |
| return NO_ERROR; |
| } |
| |
| template <typename api> |
| std::string Vsh() |
| { |
| return api::glslVer() + NL "in vec4 i_vertex;" NL "out vec4 dataOut;" NL "void main()" NL "{" NL |
| " gl_Position = i_vertex;" NL " dataOut = i_vertex;" NL "}"; |
| } |
| |
| CBasicXFBPausedDef(TDrawFunction drawFunc) |
| : _drawFunc(drawFunc), _drawSizeX(2), _drawSizeY(2), _vao(0), _vbo(0), _ebo(0), _xfbo(0), _program(0), _xfo(0) |
| { |
| } |
| |
| private: |
| TDrawFunction _drawFunc; |
| unsigned int _drawSizeX; |
| unsigned int _drawSizeY; |
| |
| GLuint _vao; |
| GLuint _vbo, _ebo, _xfbo; |
| GLuint _program; |
| GLuint _xfo; |
| |
| CBasicXFBPausedDef() |
| { |
| } |
| }; |
| |
| template <typename api> |
| class CVBODrawArraysXFBPaused : public CBasicXFBPausedDef |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "VBO: glDrawArraysIndirect, in paused transform feedback operation"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify glDrawArraysIndirect works, if XFB is active and paused"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Define a primitive using VBO" NL "2. Draw primitive using glDrawArraysIndirect" NL |
| "3. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CVBODrawArraysXFBPaused() : CBasicXFBPausedDef(DRAW_ARRAYS) |
| { |
| } |
| virtual long Run() |
| { |
| return CBasicXFBPausedDef::Run<api>(); |
| } |
| }; |
| |
| template <typename api> |
| class CVBODrawElementsSingle : public CBasicVertexDef |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "VBO: Single primitive using glDrawElementsIndirect"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that the vertex attributes can be sourced from VBO for glDrawElementsIndirect"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Define a primitive using VBO" NL "2. Draw primitive using glDrawElementsIndirect" NL |
| "3. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CVBODrawElementsSingle() : CBasicVertexDef(DRAW_ELEMENTS, GL_TRIANGLES, 1, 1) |
| { |
| } |
| virtual long Run() |
| { |
| return CBasicVertexDef::Run<api>(); |
| } |
| }; |
| |
| template <typename api> |
| class CVBODrawElementsMany : public CBasicVertexDef |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "VBO: Many primitives using glDrawElementsIndirect"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that the vertex attributes can be sourced from VBO for glDrawElementsIndirect"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Define primitives using VBO" NL "2. Draw primitive using glDrawElementsIndirect" NL |
| "3. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CVBODrawElementsMany() : CBasicVertexDef(DRAW_ELEMENTS, GL_TRIANGLES, 8, 8) |
| { |
| } |
| |
| virtual long Run() |
| { |
| return CBasicVertexDef::Run<api>(); |
| } |
| }; |
| |
| template <typename api> |
| class CVBODrawElementsInstancing : public CBasicVertexInstancingDef |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "VBO: Single primitive using glDrawElementsIndirect, multiple instances"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that the vertex attributes can be sourced from VBO for glDrawElementsIndirect"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Define a primitive using VBO" NL "2. Draw primitive using glDrawElementsIndirect" NL |
| "3. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CVBODrawElementsInstancing() : CBasicVertexInstancingDef(DRAW_ELEMENTS) |
| { |
| } |
| virtual long Run() |
| { |
| return CBasicVertexInstancingDef::Run<api>(); |
| } |
| }; |
| |
| template <typename api> |
| class CVBODrawElementsXFBPaused : public CBasicXFBPausedDef |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "VBO: glDrawElementsIndirect, in paused transform feedback operation"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify glDrawElementsIndirect works, if XFB is active and paused"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Define a primitive using VBO" NL "2. Draw primitive using glDrawArraysIndirect" NL |
| "3. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CVBODrawElementsXFBPaused() : CBasicXFBPausedDef(DRAW_ELEMENTS) |
| { |
| } |
| virtual long Run() |
| { |
| return CBasicXFBPausedDef::Run<api>(); |
| } |
| }; |
| |
| template <typename api> |
| class CBufferIndirectDrawArraysSimple : public DrawIndirectBase |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "Indirect buffer glDrawArraysIndirect: many primitives simple"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that it is possible to draw primitives with specified indirect structure" NL "in a buffer"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and fill VBO" NL "2. Create indirect buffer" NL |
| "3. Draw primitives using glDrawArraysIndirect" NL "4. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| virtual long Run() |
| { |
| _program = CreateProgram(shaders::vshSimple<api>(), "", shaders::fshSimple<api>(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| CColorArray coords; |
| PrimitiveGen(GL_TRIANGLES, 8, 8, coords); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, _buffer); |
| |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords.size() * sizeof(coords[0])), &coords[0], GL_STREAM_DRAW); |
| glVertexAttribPointer(0, sizeof(coords[0]) / sizeof(float), GL_FLOAT, GL_FALSE, sizeof(coords[0]), 0); |
| glEnableVertexAttribArray(0); |
| |
| DrawArraysIndirectCommand indirectArrays = { 0, 0, 0, 0 }; |
| indirectArrays.count = static_cast<GLuint>(coords.size()); |
| indirectArrays.primCount = 1; |
| indirectArrays.first = 0; |
| indirectArrays.reservedMustBeZero = 0; |
| |
| glGenBuffers(1, &_bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawArraysIndirectCommand), &indirectArrays, GL_STATIC_DRAW); |
| |
| glDrawArraysIndirect(GL_TRIANGLES, 0); |
| |
| CColorArray bufferRef(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.1f, 0.2f, 0.3f, 1.0f)); |
| CColorArray bufferTest(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.0f)); |
| |
| DIResult result; |
| ReadPixelsFloat<api>(0, 0, getWindowWidth(), getWindowHeight(), &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight(), bufferRef, getWindowWidth(), |
| getWindowHeight())); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glUseProgram(0); |
| glDeleteProgram(_program); |
| glDeleteVertexArrays(1, &_vao); |
| glDeleteBuffers(1, &_buffer); |
| glDeleteBuffers(1, &_bufferIndirect); |
| return NO_ERROR; |
| } |
| |
| private: |
| GLuint _program; |
| GLuint _vao, _buffer, _bufferIndirect; |
| }; |
| |
| template <typename api> |
| class CBufferIndirectDrawArraysNoFirst : public DrawIndirectBase |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "Indirect buffer glDrawArraysIndirect: non-zero 'first' argument"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that it is possible to draw primitives with specified non-zero 'first' argument" NL |
| "in indirect buffer"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and fill VBO" NL "2. Create indirect buffer" NL |
| "3. Draw primitives using glDrawArraysIndirect" NL "4. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| virtual long Run() |
| { |
| _program = CreateProgram(shaders::vshSimple<api>(), "", shaders::fshSimple<api>(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| CColorArray coords; |
| PrimitiveGen(GL_TRIANGLES, 8, 8, coords); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, _buffer); |
| |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords.size() * sizeof(coords[0])), &coords[0], GL_STREAM_DRAW); |
| glVertexAttribPointer(0, sizeof(coords[0]) / sizeof(float), GL_FLOAT, GL_FALSE, sizeof(coords[0]), 0); |
| glEnableVertexAttribArray(0); |
| |
| DrawArraysIndirectCommand indirectArrays = { 0, 0, 0, 0 }; |
| indirectArrays.count = static_cast<GLuint>(coords.size()) / 2; |
| indirectArrays.primCount = 1; |
| indirectArrays.first = static_cast<GLuint>(coords.size()) / 2; |
| indirectArrays.reservedMustBeZero = 0; |
| |
| glGenBuffers(1, &_bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawArraysIndirectCommand), &indirectArrays, GL_STATIC_DRAW); |
| |
| glDrawArraysIndirect(GL_TRIANGLES, 0); |
| |
| CColorArray bufferRef1(getWindowWidth() * getWindowHeight() / 2, tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f)); |
| CColorArray bufferRef2(getWindowWidth() * getWindowHeight() / 2, tcu::Vec4(0.1f, 0.2f, 0.3f, 1.0f)); |
| CColorArray bufferTest(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.0f)); |
| |
| DIResult result; |
| ReadPixelsFloat<api>(0, 0, getWindowWidth(), getWindowHeight() / 2, &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight() / 2, bufferRef1, |
| getWindowWidth(), getWindowHeight() / 2)); |
| |
| ReadPixelsFloat<api>(0, (getWindowHeight() + 1) / 2, getWindowWidth(), getWindowHeight() / 2, &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight() / 2, bufferRef2, |
| getWindowWidth(), getWindowHeight() / 2)); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glUseProgram(0); |
| glDeleteProgram(_program); |
| glDeleteVertexArrays(1, &_vao); |
| glDeleteBuffers(1, &_buffer); |
| glDeleteBuffers(1, &_bufferIndirect); |
| return NO_ERROR; |
| } |
| |
| private: |
| GLuint _program; |
| GLuint _vao, _buffer, _bufferIndirect; |
| }; |
| |
| template <typename api> |
| class CBufferIndirectDrawArraysOffset : public DrawIndirectBase |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "Indirect buffer glDrawArraysIndirect: offset as a function parameter"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that it is possible to draw primitives with offset as a function parameter"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and fill VBO" NL "2. Create indirect buffer" NL |
| "3. Draw primitives using glDrawArraysIndirect with offset" NL "4. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| virtual long Run() |
| { |
| _program = CreateProgram(shaders::vshSimple<api>(), "", shaders::fshSimple<api>(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| CColorArray coords; |
| PrimitiveGen(GL_TRIANGLES, 8, 8, coords); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, _buffer); |
| |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords.size() * sizeof(coords[0])), &coords[0], GL_STREAM_DRAW); |
| glVertexAttribPointer(0, sizeof(coords[0]) / sizeof(float), GL_FLOAT, GL_FALSE, sizeof(coords[0]), 0); |
| glEnableVertexAttribArray(0); |
| |
| DrawArraysIndirectCommand indirectArrays = { 0, 0, 0, 0 }; |
| indirectArrays.count = static_cast<GLuint>(coords.size()); |
| indirectArrays.primCount = 1; |
| indirectArrays.first = 0; |
| indirectArrays.reservedMustBeZero = 0; |
| |
| glGenBuffers(1, &_bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawArraysIndirectCommand) * 3, NULL, GL_STATIC_DRAW); |
| glBufferSubData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawArraysIndirectCommand), sizeof(DrawArraysIndirectCommand), |
| &indirectArrays); |
| glDrawArraysIndirect(GL_TRIANGLES, (void*)sizeof(DrawArraysIndirectCommand)); |
| |
| CColorArray bufferRef(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.1f, 0.2f, 0.3f, 1.0f)); |
| CColorArray bufferTest(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.0f)); |
| |
| DIResult result; |
| ReadPixelsFloat<api>(0, 0, getWindowWidth(), getWindowHeight(), &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight(), bufferRef, getWindowWidth(), |
| getWindowHeight())); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glUseProgram(0); |
| glDeleteProgram(_program); |
| glDeleteVertexArrays(1, &_vao); |
| glDeleteBuffers(1, &_buffer); |
| glDeleteBuffers(1, &_bufferIndirect); |
| return NO_ERROR; |
| } |
| |
| private: |
| GLuint _program; |
| GLuint _vao, _buffer, _bufferIndirect; |
| }; |
| |
| template <typename api> |
| class CBufferIndirectDrawElementsSimple : public DrawIndirectBase |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "Indirect buffer glDrawElementsIndirect: many primitives simple"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that it is possible to draw primitives with specified indirect structure" NL "in a buffer"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and fill VBO" NL "2. Create indirect buffer" NL |
| "3. Draw primitives using glDrawElementsIndirect" NL "4. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| virtual long Run() |
| { |
| _program = CreateProgram(shaders::vshSimple<api>(), "", shaders::fshSimple<api>(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| CColorArray coords; |
| PrimitiveGen(GL_TRIANGLES, 8, 8, coords); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, _buffer); |
| |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords.size() * sizeof(coords[0])), &coords[0], GL_STREAM_DRAW); |
| glVertexAttribPointer(0, sizeof(coords[0]) / sizeof(float), GL_FLOAT, GL_FALSE, sizeof(coords[0]), 0); |
| glEnableVertexAttribArray(0); |
| |
| DrawElementsIndirectCommand indirectElements = { 0, 0, 0, 0, 0 }; |
| indirectElements.count = static_cast<GLuint>(coords.size()); |
| indirectElements.primCount = 1; |
| indirectElements.baseVertex = 0; |
| indirectElements.firstIndex = 0; |
| indirectElements.reservedMustBeZero = 0; |
| |
| CElementArray elements(coords.size(), 0); |
| for (size_t i = 0; i < elements.size(); ++i) |
| { |
| elements[i] = static_cast<GLuint>(i); |
| } |
| |
| glGenBuffers(1, &_bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawElementsIndirectCommand), &indirectElements, GL_STATIC_DRAW); |
| |
| glGenBuffers(1, &_ebo); |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ebo); |
| glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)(elements.size() * sizeof(elements[0])), &elements[0], |
| GL_STATIC_DRAW); |
| |
| glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_INT, 0); |
| |
| CColorArray bufferRef(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.1f, 0.2f, 0.3f, 1.0f)); |
| CColorArray bufferTest(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.0f)); |
| |
| DIResult result; |
| ReadPixelsFloat<api>(0, 0, getWindowWidth(), getWindowHeight(), &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight(), bufferRef, getWindowWidth(), |
| getWindowHeight())); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glUseProgram(0); |
| glDeleteProgram(_program); |
| glDeleteVertexArrays(1, &_vao); |
| glDeleteBuffers(1, &_buffer); |
| glDeleteBuffers(1, &_bufferIndirect); |
| glDeleteBuffers(1, &_ebo); |
| return NO_ERROR; |
| } |
| |
| private: |
| GLuint _program; |
| GLuint _vao, _buffer, _bufferIndirect, _ebo; |
| }; |
| |
| template <typename api> |
| class CBufferIndirectDrawElementsNoFirstIndex : public DrawIndirectBase |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "Indirect buffer glDrawElementsIndirect: non-zero first index"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that it is possible to draw primitives with non-zero first index" NL "in indirect buffer"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and fill VBO" NL "2. Create indirect buffer" NL |
| "3. Draw primitives using glDrawElementsIndirect" NL "4. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| virtual long Run() |
| { |
| _program = CreateProgram(shaders::vshSimple<api>(), "", shaders::fshSimple<api>(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| CColorArray coords; |
| PrimitiveGen(GL_TRIANGLES, 8, 8, coords); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, _buffer); |
| |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords.size() * sizeof(coords[0])), &coords[0], GL_STREAM_DRAW); |
| glVertexAttribPointer(0, sizeof(coords[0]) / sizeof(float), GL_FLOAT, GL_FALSE, sizeof(coords[0]), 0); |
| glEnableVertexAttribArray(0); |
| |
| DrawElementsIndirectCommand indirectElements = { 0, 0, 0, 0, 0 }; |
| indirectElements.count = static_cast<GLuint>(coords.size()) / 2; |
| indirectElements.primCount = 1; |
| indirectElements.baseVertex = 0; |
| indirectElements.firstIndex = static_cast<GLuint>(coords.size()) / 2; |
| indirectElements.reservedMustBeZero = 0; |
| |
| CElementArray elements(coords.size(), 0); |
| for (size_t i = 0; i < elements.size(); ++i) |
| { |
| elements[i] = static_cast<GLuint>(i); |
| } |
| |
| glGenBuffers(1, &_bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawElementsIndirectCommand), &indirectElements, GL_STATIC_DRAW); |
| |
| glGenBuffers(1, &_ebo); |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ebo); |
| glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)(elements.size() * sizeof(elements[0])), &elements[0], |
| GL_STATIC_DRAW); |
| |
| glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_INT, 0); |
| |
| CColorArray bufferRef1(getWindowWidth() * getWindowHeight() / 2, tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f)); |
| CColorArray bufferRef2(getWindowWidth() * getWindowHeight() / 2, tcu::Vec4(0.1f, 0.2f, 0.3f, 1.0f)); |
| CColorArray bufferTest(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.0f)); |
| |
| DIResult result; |
| ReadPixelsFloat<api>(0, 0, getWindowWidth(), getWindowHeight() / 2, &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight() / 2, bufferRef1, |
| getWindowWidth(), getWindowHeight() / 2)); |
| |
| ReadPixelsFloat<api>(0, (getWindowHeight() + 1) / 2, getWindowWidth(), getWindowHeight() / 2, &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight() / 2, bufferRef2, |
| getWindowWidth(), getWindowHeight() / 2)); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glUseProgram(0); |
| glDeleteProgram(_program); |
| glDeleteVertexArrays(1, &_vao); |
| glDeleteBuffers(1, &_buffer); |
| glDeleteBuffers(1, &_ebo); |
| glDeleteBuffers(1, &_bufferIndirect); |
| return NO_ERROR; |
| } |
| |
| private: |
| GLuint _program; |
| GLuint _vao, _buffer, _bufferIndirect, _ebo; |
| }; |
| |
| template <typename api> |
| class CBufferIndirectDrawElementsNoBasevertex : public DrawIndirectBase |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "Indirect buffer glDrawElementsIndirect: non-zero base vertex"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that it is possible to draw primitives with non-zero base vertex" NL "in indirect buffer"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and fill VBO" NL "2. Create indirect buffer" NL |
| "3. Draw primitives using glDrawElementsIndirect" NL "4. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| virtual long Run() |
| { |
| _program = CreateProgram(shaders::vshSimple<api>(), "", shaders::fshSimple<api>(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| CColorArray coords; |
| PrimitiveGen(GL_TRIANGLES, 8, 8, coords); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, _buffer); |
| |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords.size() * sizeof(coords[0])), &coords[0], GL_STREAM_DRAW); |
| glVertexAttribPointer(0, sizeof(coords[0]) / sizeof(float), GL_FLOAT, GL_FALSE, sizeof(coords[0]), 0); |
| glEnableVertexAttribArray(0); |
| |
| DrawElementsIndirectCommand indirectElements = { 0, 0, 0, 0, 0 }; |
| indirectElements.count = static_cast<GLuint>(coords.size()) / 2; |
| indirectElements.primCount = 1; |
| indirectElements.baseVertex = static_cast<GLint>(coords.size()) / 2; |
| indirectElements.firstIndex = 0; |
| indirectElements.reservedMustBeZero = 0; |
| |
| CElementArray elements(coords.size(), 0); |
| for (size_t i = 0; i < elements.size(); ++i) |
| { |
| elements[i] = static_cast<GLuint>(i); |
| } |
| |
| glGenBuffers(1, &_bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawElementsIndirectCommand), &indirectElements, GL_STATIC_DRAW); |
| |
| glGenBuffers(1, &_ebo); |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ebo); |
| glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)(elements.size() * sizeof(elements[0])), &elements[0], |
| GL_STATIC_DRAW); |
| |
| glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_INT, 0); |
| |
| CColorArray bufferRef1(getWindowWidth() * getWindowHeight() / 2, tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f)); |
| CColorArray bufferRef2(getWindowWidth() * getWindowHeight() / 2, tcu::Vec4(0.1f, 0.2f, 0.3f, 1.0f)); |
| CColorArray bufferTest(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.0f)); |
| |
| DIResult result; |
| ReadPixelsFloat<api>(0, 0, getWindowWidth(), getWindowHeight() / 2, &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight() / 2, bufferRef1, |
| getWindowWidth(), getWindowHeight() / 2)); |
| |
| ReadPixelsFloat<api>(0, (getWindowHeight() + 1) / 2, getWindowWidth(), getWindowHeight() / 2, &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight() / 2, bufferRef2, |
| getWindowWidth(), getWindowHeight() / 2)); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glUseProgram(0); |
| glDeleteProgram(_program); |
| glDeleteVertexArrays(1, &_vao); |
| glDeleteBuffers(1, &_buffer); |
| glDeleteBuffers(1, &_ebo); |
| glDeleteBuffers(1, &_bufferIndirect); |
| return NO_ERROR; |
| } |
| |
| private: |
| GLuint _program; |
| GLuint _vao, _buffer, _ebo, _bufferIndirect; |
| }; |
| |
| template <typename api> |
| class CBufferIndirectDrawElementsOffset : public DrawIndirectBase |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "Indirect buffer glDrawElementsIndirect: offset as a function parameter"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that it is possible to draw primitives with offset as a function parameter"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and fill VBO" NL "2. Create indirect buffer" NL |
| "3. Draw primitives using glDrawElementsIndirect with offset" NL "4. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| virtual long Run() |
| { |
| _program = CreateProgram(shaders::vshSimple<api>(), "", shaders::fshSimple<api>(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| CColorArray coords; |
| PrimitiveGen(GL_TRIANGLES, 8, 8, coords); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, _buffer); |
| |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords.size() * sizeof(coords[0])), &coords[0], GL_STREAM_DRAW); |
| glVertexAttribPointer(0, sizeof(coords[0]) / sizeof(float), GL_FLOAT, GL_FALSE, sizeof(coords[0]), 0); |
| glEnableVertexAttribArray(0); |
| |
| DrawElementsIndirectCommand indirectElements = { 0, 0, 0, 0, 0 }; |
| indirectElements.count = static_cast<GLuint>(coords.size()); |
| indirectElements.primCount = 1; |
| indirectElements.baseVertex = 0; |
| indirectElements.firstIndex = 0; |
| indirectElements.reservedMustBeZero = 0; |
| |
| CElementArray elements(coords.size(), 0); |
| for (size_t i = 0; i < elements.size(); ++i) |
| { |
| elements[i] = static_cast<GLuint>(i); |
| } |
| |
| glGenBuffers(1, &_bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawElementsIndirectCommand) * 3, NULL, GL_STATIC_DRAW); |
| glBufferSubData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawElementsIndirectCommand), |
| sizeof(DrawElementsIndirectCommand), &indirectElements); |
| |
| glGenBuffers(1, &_ebo); |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ebo); |
| glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)(elements.size() * sizeof(elements[0])), &elements[0], |
| GL_STATIC_DRAW); |
| glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_INT, (void*)sizeof(DrawElementsIndirectCommand)); |
| |
| CColorArray bufferRef(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.1f, 0.2f, 0.3f, 1.0f)); |
| CColorArray bufferTest(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.0f)); |
| |
| DIResult result; |
| ReadPixelsFloat<api>(0, 0, getWindowWidth(), getWindowHeight(), &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight(), bufferRef, getWindowWidth(), |
| getWindowHeight())); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glUseProgram(0); |
| glDeleteProgram(_program); |
| glDeleteVertexArrays(1, &_vao); |
| glDeleteBuffers(1, &_buffer); |
| glDeleteBuffers(1, &_ebo); |
| glDeleteBuffers(1, &_bufferIndirect); |
| return NO_ERROR; |
| } |
| |
| private: |
| GLuint _program; |
| GLuint _vao, _buffer, _ebo, _bufferIndirect; |
| }; |
| |
| class CBasicVertexIDsDef : public DrawIndirectBase |
| { |
| public: |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| template <typename api> |
| long Run() |
| { |
| CColorArray coords; |
| PrimitiveGen(GL_TRIANGLES, _drawSizeX, _drawSizeY, coords); |
| |
| CColorArray coords_instanced(4); |
| coords_instanced[0] = tcu::Vec4(0.5, 0.5, 0.0, 0.0); |
| coords_instanced[1] = tcu::Vec4(-0.5, 0.5, 0.0, 0.0); |
| coords_instanced[2] = tcu::Vec4(-0.5, -0.5, 0.0, 0.0); |
| coords_instanced[3] = tcu::Vec4(0.5, -0.5, 0.0, 0.0); |
| |
| std::vector<glw::GLfloat> ref_VertexId(coords.size()); |
| for (size_t i = 0; i < ref_VertexId.size(); i++) |
| { |
| ref_VertexId[i] = glw::GLfloat(i); |
| } |
| |
| std::vector<glw::GLfloat> ref_InstanceId(4); |
| for (size_t i = 0; i < ref_InstanceId.size(); i++) |
| { |
| ref_InstanceId[i] = glw::GLfloat(i); |
| } |
| |
| _program = CreateProgram(Vsh<api>(), "", Fsh<api>(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| glGenBuffers(1, &_vbo); |
| glBindBuffer(GL_ARRAY_BUFFER, _vbo); |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords.size() * sizeof(coords[0]) + |
| coords_instanced.size() * sizeof(coords_instanced[0]) + |
| ref_VertexId.size() * sizeof(ref_VertexId[0]) + |
| ref_InstanceId.size() * sizeof(ref_InstanceId[0])), |
| NULL, GL_STATIC_DRAW); |
| |
| const size_t coords_offset = 0; |
| const size_t coords_instanced_offset = coords_offset + coords.size() * sizeof(coords[0]); |
| const size_t ref_VertexId_offset = |
| coords_instanced_offset + coords_instanced.size() * sizeof(coords_instanced[0]); |
| const size_t ref_InstanceId_offset = ref_VertexId_offset + ref_VertexId.size() * sizeof(ref_VertexId[0]); |
| |
| glBufferSubData(GL_ARRAY_BUFFER, coords_offset, (GLsizeiptr)(coords.size() * sizeof(coords[0])), &coords[0]); |
| glBufferSubData(GL_ARRAY_BUFFER, (GLintptr)coords_instanced_offset, |
| (GLsizeiptr)(coords_instanced.size() * sizeof(coords_instanced[0])), &coords_instanced[0]); |
| glBufferSubData(GL_ARRAY_BUFFER, (GLintptr)ref_VertexId_offset, |
| (GLsizeiptr)(ref_VertexId.size() * sizeof(ref_VertexId[0])), &ref_VertexId[0]); |
| glBufferSubData(GL_ARRAY_BUFFER, (GLintptr)ref_InstanceId_offset, |
| (GLsizeiptr)(ref_InstanceId.size() * sizeof(ref_InstanceId[0])), &ref_InstanceId[0]); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| |
| //i_vertex (coords) |
| glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, reinterpret_cast<glw::GLvoid*>(coords_offset)); |
| glEnableVertexAttribArray(0); |
| |
| //i_vertex_instanced (coords_instanced) |
| glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, reinterpret_cast<glw::GLvoid*>(coords_instanced_offset)); |
| glEnableVertexAttribArray(1); |
| glVertexAttribDivisor(1, 1); |
| |
| //i_ref_VertexId |
| glVertexAttribPointer(2, 1, GL_FLOAT, GL_FALSE, 0, reinterpret_cast<glw::GLvoid*>(ref_VertexId_offset)); |
| glEnableVertexAttribArray(2); |
| //i_ref_InstanceId |
| glVertexAttribPointer(3, 1, GL_FLOAT, GL_FALSE, 0, reinterpret_cast<glw::GLvoid*>(ref_InstanceId_offset)); |
| glEnableVertexAttribArray(3); |
| glVertexAttribDivisor(3, 1); |
| |
| DrawArraysIndirectCommand indirectArrays = { 0, 0, 0, 0 }; |
| DrawElementsIndirectCommand indirectElements = { 0, 0, 0, 0, 0 }; |
| |
| CElementArray elements(coords.size(), 0); |
| for (size_t i = 0; i < elements.size(); ++i) |
| { |
| elements[i] = static_cast<GLuint>(i); |
| } |
| |
| switch (_drawFunc) |
| { |
| case DRAW_ARRAYS: |
| { |
| indirectArrays.count = static_cast<GLuint>(coords.size()); |
| indirectArrays.primCount = 4; |
| indirectArrays.first = 0; |
| indirectArrays.reservedMustBeZero = 0; |
| |
| { |
| GLuint buffer; |
| glGenBuffers(1, &buffer); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, buffer); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(indirectArrays), &indirectArrays, GL_STATIC_DRAW); |
| glDrawArraysIndirect(GL_TRIANGLES, 0); |
| glDeleteBuffers(1, &buffer); |
| } |
| } |
| break; |
| case DRAW_ELEMENTS: |
| { |
| indirectElements.count = static_cast<GLuint>(coords.size()); |
| indirectElements.primCount = 4; |
| indirectElements.firstIndex = 0; |
| indirectElements.baseVertex = 0; |
| indirectElements.reservedMustBeZero = 0; |
| |
| glGenBuffers(1, &_ebo); |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ebo); |
| glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)(elements.size() * sizeof(elements[0])), &elements[0], |
| GL_STATIC_DRAW); |
| |
| { |
| GLuint buffer; |
| glGenBuffers(1, &buffer); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, buffer); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(indirectElements), &indirectElements, GL_STATIC_DRAW); |
| glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_INT, 0); |
| glDeleteBuffers(1, &buffer); |
| } |
| } |
| break; |
| default: |
| throw std::runtime_error("Unknown draw function!"); |
| break; |
| } |
| |
| CColorArray bufferRef1(getWindowWidth() / 2 * getWindowHeight() / 2, tcu::Vec4(0.0f, 1.0f, 0.5f, 0.0f)); |
| CColorArray bufferRef2(getWindowWidth() / 2 * getWindowHeight() / 2, tcu::Vec4(0.0f, 1.0f, 0.75f, 0.0f)); |
| CColorArray bufferRef3(getWindowWidth() / 2 * getWindowHeight() / 2, tcu::Vec4(0.0f, 1.0f, 0.25f, 0.0f)); |
| CColorArray bufferRef4(getWindowWidth() / 2 * getWindowHeight() / 2, tcu::Vec4(0.0f, 1.0f, 0.0f, 0.0f)); |
| |
| CColorArray bufferTest(getWindowWidth() / 2 * getWindowHeight() / 2, tcu::Vec4(0.0f)); |
| DIResult result; |
| |
| ReadPixelsFloat<api>(0, 0, getWindowWidth() / 2, getWindowHeight() / 2, &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth() / 2, getWindowHeight() / 2, bufferRef1, |
| getWindowWidth() / 2, getWindowHeight() / 2)); |
| |
| ReadPixelsFloat<api>((getWindowWidth() + 1) / 2, 0, getWindowWidth() / 2, getWindowHeight() / 2, |
| &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth() / 2, getWindowHeight() / 2, bufferRef2, |
| getWindowWidth() / 2, getWindowHeight() / 2)); |
| |
| ReadPixelsFloat<api>(0, (getWindowHeight() + 1) / 2, getWindowWidth() / 2, getWindowHeight() / 2, |
| &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth() / 2, getWindowHeight() / 2, bufferRef3, |
| getWindowWidth() / 2, getWindowHeight() / 2)); |
| |
| ReadPixelsFloat<api>((getWindowWidth() + 1) / 2, (getWindowHeight() + 1) / 2, getWindowWidth() / 2, |
| getWindowHeight() / 2, &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth() / 2, getWindowHeight() / 2, bufferRef4, |
| getWindowWidth() / 2, getWindowHeight() / 2)); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glBindBuffer(GL_ARRAY_BUFFER, 0); |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); |
| glBindVertexArray(0); |
| glUseProgram(0); |
| |
| if (_vao) |
| { |
| glDeleteVertexArrays(1, &_vao); |
| } |
| if (_vbo) |
| { |
| glDeleteBuffers(1, &_vbo); |
| } |
| if (_ebo) |
| { |
| glDeleteBuffers(1, &_ebo); |
| } |
| if (_program) |
| { |
| glDeleteProgram(_program); |
| } |
| |
| return NO_ERROR; |
| } |
| |
| template <typename api> |
| std::string Vsh() |
| { |
| return api::glslVer() + NL |
| "layout(location = 0) in vec4 i_vertex;" NL "layout(location = 1) in vec4 i_vertex_instanced;" NL |
| "layout(location = 2) in float i_ref_VertexId;" NL "layout(location = 3) in float i_ref_InstanceId;" NL |
| "out vec4 val_Result;" NL "void main()" NL "{" NL |
| " gl_Position = vec4(i_vertex.xyz * .5, 1.0) + i_vertex_instanced;" NL |
| " if ( gl_VertexID == int(i_ref_VertexId + .5) && gl_InstanceID == int(i_ref_InstanceId + .5)) {" NL |
| " val_Result = vec4(0.0, 1.0, float(gl_InstanceID) / 4.0, 1.0);" NL " } else {" NL |
| " val_Result = vec4(1.0, 0.0, 0.0, 1.0);" NL " }" NL "}"; |
| } |
| |
| template <typename api> |
| std::string Fsh() |
| { |
| return api::glslVer() + NL "precision highp float; " NL "in vec4 val_Result;" NL "out vec4 outColor;" NL |
| "void main() {" NL " outColor = val_Result;" NL "}"; |
| } |
| |
| CBasicVertexIDsDef(TDrawFunction drawFunc) |
| : _drawFunc(drawFunc), _drawSizeX(2), _drawSizeY(2), _vao(0), _vbo(0), _ebo(0), _program(0) |
| { |
| } |
| |
| private: |
| TDrawFunction _drawFunc; |
| unsigned int _drawSizeX; |
| unsigned int _drawSizeY; |
| |
| GLuint _vao; |
| GLuint _vbo, _ebo; |
| GLuint _program; |
| |
| CBasicVertexIDsDef() |
| { |
| } |
| }; |
| |
| template <typename api> |
| class CBufferIndirectDrawArraysVertexIds : public CBasicVertexIDsDef |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "Indirect buffer glDrawArraysIndirect: all non-zero arguments, verify vertex ids"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that it is possible to draw primitives with all non-zero arguments" NL "in indirect buffer"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and fill VBO" NL "2. Create indirect buffer" NL |
| "3. Draw primitives using glDrawArraysIndirect" NL "4. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| virtual long Run() |
| { |
| return CBasicVertexIDsDef::Run<api>(); |
| } |
| |
| CBufferIndirectDrawArraysVertexIds() : CBasicVertexIDsDef(DRAW_ARRAYS) |
| { |
| } |
| }; |
| |
| template <typename api> |
| class CBufferIndirectDrawElementsVertexIds : public CBasicVertexIDsDef |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "Indirect buffer glDrawElementsIndirect: all non-zero arguments, verify vertex ids"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that it is possible to draw primitives with all non-zero arguments" NL "in indirect buffer"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and fill VBO" NL "2. Create indirect buffer" NL |
| "3. Draw primitives using glDrawElementsIndirect" NL "4. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| virtual long Run() |
| { |
| return CBasicVertexIDsDef::Run<api>(); |
| } |
| |
| CBufferIndirectDrawElementsVertexIds() : CBasicVertexIDsDef(DRAW_ELEMENTS) |
| { |
| } |
| }; |
| |
| template <typename api> |
| class CIndicesDataTypeUnsignedShort : public DrawIndirectBase |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "glDrawElementsIndirect indices data type: unsigned short"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that unsigned short indices are accepted by glDrawElementsIndirect"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and fill VBO" NL "2. Create indirect buffer" NL "3. Create element buffer" NL |
| "4. Draw primitives using glDrawElementsIndirect" NL "5. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| virtual long Run() |
| { |
| _program = CreateProgram(shaders::vshSimple<api>(), "", shaders::fshSimple<api>(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| CColorArray coords; |
| PrimitiveGen(GL_TRIANGLES, 8, 8, coords); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, _buffer); |
| |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords.size() * sizeof(coords[0])), &coords[0], GL_STREAM_DRAW); |
| glVertexAttribPointer(0, sizeof(coords[0]) / sizeof(float), GL_FLOAT, GL_FALSE, sizeof(coords[0]), 0); |
| glEnableVertexAttribArray(0); |
| |
| DrawElementsIndirectCommand indirectElements = { 0, 0, 0, 0, 0 }; |
| indirectElements.count = static_cast<GLuint>(coords.size()) / 2; |
| indirectElements.primCount = 1; |
| indirectElements.baseVertex = -static_cast<GLint>(coords.size()) / 4; |
| indirectElements.firstIndex = static_cast<GLuint>(coords.size()) / 4; |
| indirectElements.reservedMustBeZero = 0; |
| |
| std::vector<GLushort> elements(coords.size(), 0); |
| for (size_t i = 0; i < elements.size(); ++i) |
| { |
| elements[i] = static_cast<GLushort>(i); |
| } |
| |
| glGenBuffers(1, &_bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawElementsIndirectCommand), NULL, GL_STATIC_DRAW); |
| glBufferSubData(GL_DRAW_INDIRECT_BUFFER, 0, sizeof(DrawElementsIndirectCommand), &indirectElements); |
| |
| glGenBuffers(1, &_ebo); |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ebo); |
| glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)(elements.size() * sizeof(elements[0])), &elements[0], |
| GL_STATIC_DRAW); |
| |
| glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT, 0); |
| |
| CColorArray bufferRef1(getWindowWidth() * getWindowHeight() / 2, tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f)); |
| CColorArray bufferRef2(getWindowWidth() * getWindowHeight() / 2, tcu::Vec4(0.1f, 0.2f, 0.3f, 1.0f)); |
| CColorArray bufferTest(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.0f)); |
| |
| DIResult result; |
| ReadPixelsFloat<api>(0, 0, getWindowWidth(), getWindowHeight() / 2, &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight() / 2, bufferRef2, |
| getWindowWidth(), getWindowHeight() / 2)); |
| |
| ReadPixelsFloat<api>(0, (getWindowHeight() + 1) / 2, getWindowWidth(), getWindowHeight() / 2, &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight() / 2, bufferRef1, |
| getWindowWidth(), getWindowHeight() / 2)); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glUseProgram(0); |
| glDeleteProgram(_program); |
| glDeleteVertexArrays(1, &_vao); |
| glDeleteBuffers(1, &_buffer); |
| glDeleteBuffers(1, &_ebo); |
| glDeleteBuffers(1, &_bufferIndirect); |
| return NO_ERROR; |
| } |
| |
| private: |
| GLuint _program; |
| GLuint _vao, _buffer, _ebo, _bufferIndirect; |
| }; |
| |
| template <typename api> |
| class CIndicesDataTypeUnsignedByte : public DrawIndirectBase |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "glDrawElementsIndirect indices data type: unsigned byte"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that unsigned byte indices are accepted by glDrawElementsIndirect"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and fill VBO" NL "2. Create indirect buffer" NL "3. Create element buffer" NL |
| "4. Draw primitives using glDrawElementsIndirect" NL "5. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| virtual long Run() |
| { |
| _program = CreateProgram(shaders::vshSimple<api>(), "", shaders::fshSimple<api>(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| CColorArray coords; |
| PrimitiveGen(GL_TRIANGLES, 2, 2, coords); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, _buffer); |
| |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords.size() * sizeof(coords[0])), &coords[0], GL_STREAM_DRAW); |
| glVertexAttribPointer(0, sizeof(coords[0]) / sizeof(float), GL_FLOAT, GL_FALSE, sizeof(coords[0]), 0); |
| glEnableVertexAttribArray(0); |
| |
| DrawElementsIndirectCommand indirectElements = { 0, 0, 0, 0, 0 }; |
| indirectElements.count = static_cast<GLuint>(coords.size()) / 2; |
| indirectElements.primCount = 1; |
| indirectElements.baseVertex = -static_cast<GLint>(coords.size()) / 4; |
| indirectElements.firstIndex = static_cast<GLuint>(coords.size()) / 4; |
| indirectElements.reservedMustBeZero = 0; |
| |
| std::vector<GLubyte> elements(coords.size(), 0); |
| for (size_t i = 0; i < elements.size(); ++i) |
| { |
| elements[i] = static_cast<GLubyte>(i); |
| } |
| |
| glGenBuffers(1, &_bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawElementsIndirectCommand), NULL, GL_STATIC_DRAW); |
| glBufferSubData(GL_DRAW_INDIRECT_BUFFER, 0, sizeof(DrawElementsIndirectCommand), &indirectElements); |
| |
| glGenBuffers(1, &_ebo); |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ebo); |
| glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)(elements.size() * sizeof(elements[0])), &elements[0], |
| GL_STATIC_DRAW); |
| |
| glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_BYTE, 0); |
| |
| CColorArray bufferRef1(getWindowWidth() * getWindowHeight() / 2, tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f)); |
| CColorArray bufferRef2(getWindowWidth() * getWindowHeight() / 2, tcu::Vec4(0.1f, 0.2f, 0.3f, 1.0f)); |
| CColorArray bufferTest(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.0f)); |
| |
| DIResult result; |
| ReadPixelsFloat<api>(0, 0, getWindowWidth(), getWindowHeight() / 2, &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight() / 2, bufferRef2, |
| getWindowWidth(), getWindowHeight() / 2)); |
| |
| ReadPixelsFloat<api>(0, (getWindowHeight() + 1) / 2, getWindowWidth(), getWindowHeight() / 2, &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight() / 2, bufferRef1, |
| getWindowWidth(), getWindowHeight() / 2)); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glUseProgram(0); |
| glDeleteProgram(_program); |
| glDeleteVertexArrays(1, &_vao); |
| glDeleteBuffers(1, &_buffer); |
| glDeleteBuffers(1, &_ebo); |
| glDeleteBuffers(1, &_bufferIndirect); |
| return NO_ERROR; |
| } |
| |
| private: |
| GLuint _program; |
| GLuint _vao, _buffer, _ebo, _bufferIndirect; |
| }; |
| |
| class CPrimitiveMode : public DrawIndirectBase |
| { |
| public: |
| template <typename api> |
| bool IsGeometryShaderSupported() |
| { |
| if (api::isES()) |
| { |
| const glu::ContextInfo& info = m_context.getContextInfo(); |
| const glu::ContextType& type = m_context.getRenderContext().getType(); |
| |
| /* ES 3.2+ included geometry shaders into the core */ |
| if (glu::contextSupports(type, glu::ApiType(3, 2, glu::PROFILE_ES))) |
| { |
| return true; |
| } |
| /* ES 3.1 may be able to support geometry shaders via extensions */ |
| else if ((glu::contextSupports(type, glu::ApiType(3, 1, glu::PROFILE_ES))) && |
| ((true == info.isExtensionSupported("GL_EXT_geometry_shader")) || |
| (true == info.isExtensionSupported("GL_OES_geometry_shader")))) |
| { |
| return true; |
| } |
| else |
| { |
| OutputNotSupported("Geometry shader is not supported\n"); |
| return false; |
| } |
| } |
| else |
| { |
| return true; |
| } |
| } |
| virtual long Setup() |
| { |
| _sizeX = getWindowWidth(); |
| _sizeY = getWindowHeight(); |
| if (_primitiveType != GL_TRIANGLE_STRIP && _primitiveType != GL_TRIANGLE_STRIP_ADJACENCY && |
| _primitiveType != GL_TRIANGLES && _primitiveType != GL_TRIANGLES_ADJACENCY && |
| _primitiveType != GL_TRIANGLE_FAN) |
| { |
| _sizeX &= (-4); |
| _sizeY &= (-4); |
| } |
| if ((int)_drawSizeX < 0 || (int)_drawSizeY < 0) |
| { |
| //no PrimitiveGen dimensions given. assume same dimensions as rendered image^ |
| _drawSizeX = _sizeX; |
| _drawSizeY = _sizeY; |
| if (_primitiveType == GL_POINTS) |
| { |
| //clamp vertex number (and rendering size) for points to max. 10000 |
| _sizeX = _drawSizeX = std::min(_drawSizeX, 100u); |
| _sizeY = _drawSizeY = std::min(_drawSizeY, 100u); |
| } |
| } |
| |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| template <typename api> |
| long Run(bool pointMode = false) |
| { |
| |
| glClear(GL_COLOR_BUFFER_BIT); |
| |
| _program = CreateProgram(pointMode ? shaders::vshSimple_point<api>() : shaders::vshSimple<api>(), "", |
| shaders::fshSimple<api>(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| CColorArray coords; |
| PrimitiveGen(_primitiveType, _drawSizeX, _drawSizeY, coords); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, _buffer); |
| |
| CColorArray padding(10, tcu::Vec4(0.0f)); |
| |
| glBufferData(GL_ARRAY_BUFFER, |
| (GLsizeiptr)(coords.size() * (sizeof(coords[0])) + padding.size() * (sizeof(padding[0]))), NULL, |
| GL_STREAM_DRAW); |
| glBufferSubData(GL_ARRAY_BUFFER, 0, (GLsizeiptr)(padding.size() * (sizeof(padding[0]))), &padding[0]); |
| glBufferSubData(GL_ARRAY_BUFFER, (GLintptr)(padding.size() * (sizeof(padding[0]))), |
| (GLsizeiptr)(coords.size() * (sizeof(coords[0]))), &coords[0]); |
| |
| glVertexAttribPointer(0, sizeof(coords[0]) / sizeof(float), GL_FLOAT, GL_FALSE, sizeof(coords[0]), 0); |
| glEnableVertexAttribArray(0); |
| |
| DrawElementsIndirectCommand indirectElements = { 0, 0, 0, 0, 0 }; |
| DrawArraysIndirectCommand indirectArrays = { 0, 0, 0, 0 }; |
| |
| CElementArray elements(coords.size(), 0); |
| for (size_t i = 0; i < elements.size(); ++i) |
| { |
| elements[i] = static_cast<GLuint>(i); |
| } |
| |
| glGenBuffers(1, &_bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| |
| switch (_drawFunc) |
| { |
| case DRAW_ARRAYS: |
| { |
| indirectArrays.count = static_cast<GLuint>(coords.size()) / 2; |
| indirectArrays.primCount = 1; |
| indirectArrays.first = 10; |
| indirectArrays.reservedMustBeZero = 0; |
| |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawArraysIndirectCommand), NULL, GL_STATIC_DRAW); |
| glBufferSubData(GL_DRAW_INDIRECT_BUFFER, 0, sizeof(DrawArraysIndirectCommand), &indirectArrays); |
| |
| glDrawArraysIndirect(_primitiveType, 0); |
| } |
| break; |
| case DRAW_ELEMENTS: |
| { |
| indirectElements.count = static_cast<GLuint>(coords.size()) / 2; |
| indirectElements.primCount = 1; |
| indirectElements.baseVertex = 7; |
| indirectElements.firstIndex = 3; |
| indirectElements.reservedMustBeZero = 0; |
| |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawElementsIndirectCommand), NULL, GL_STATIC_DRAW); |
| glBufferSubData(GL_DRAW_INDIRECT_BUFFER, 0, sizeof(DrawElementsIndirectCommand), &indirectElements); |
| |
| glGenBuffers(1, &_ebo); |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ebo); |
| glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)(elements.size() * sizeof(elements[0])), &elements[0], |
| GL_STATIC_DRAW); |
| |
| glDrawElementsIndirect(_primitiveType, GL_UNSIGNED_INT, 0); |
| } |
| break; |
| default: |
| throw std::runtime_error("Unknown draw function!"); |
| break; |
| } |
| |
| CColorArray bufferRef1(_sizeX * _sizeY / 2, tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f)); |
| CColorArray bufferRef2(_sizeX * _sizeY / 2, tcu::Vec4(0.1f, 0.2f, 0.3f, 1.0f)); |
| CColorArray bufferTest(_sizeX * _sizeY, tcu::Vec4(0.0f)); |
| |
| DIResult result; |
| ReadPixelsFloat<api>(0, (_sizeY + 1) / 2, _sizeX, _sizeY / 2, &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, _sizeX, _sizeY / 2, bufferRef1, _sizeX, _sizeY / 2)); |
| |
| switch (_primitiveType) |
| { |
| case GL_TRIANGLES_ADJACENCY: |
| case GL_TRIANGLE_STRIP_ADJACENCY: |
| { |
| CColorArray bufferRef3(_sizeX * _sizeY / 16, tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f)); |
| CColorArray bufferRef4(_sizeX * _sizeY / 8, tcu::Vec4(0.1f, 0.2f, 0.3f, 1.0f)); |
| CColorArray bufferRef5(_sizeX * _sizeY / 4, tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f)); |
| |
| CColorArray bufferTest3(_sizeX * _sizeY / 16, tcu::Vec4(0.0f)); |
| CColorArray bufferTest4(_sizeX * _sizeY / 8, tcu::Vec4(0.0f)); |
| CColorArray bufferTest5(_sizeX * _sizeY / 4, tcu::Vec4(0.0f)); |
| |
| ReadPixelsFloat<api>(0, (_sizeY + 3) / 4, _sizeX / 4, _sizeY / 4, &bufferTest3[0]); |
| result.sub_result(BuffersCompare(bufferTest3, _sizeX / 4, _sizeY / 4, bufferRef3, _sizeX / 4, _sizeY / 4)); |
| |
| ReadPixelsFloat<api>((_sizeX + 3) / 4, (_sizeY + 3) / 4, _sizeX / 2, _sizeY / 4, &bufferTest4[0]); |
| result.sub_result(BuffersCompare(bufferTest4, _sizeX / 2, _sizeY / 4, bufferRef4, _sizeX / 2, _sizeY / 4)); |
| |
| ReadPixelsFloat<api>((_sizeX * 3 + 3) / 4, (_sizeY + 3) / 4, _sizeX / 4, _sizeY / 4, &bufferTest3[0]); |
| result.sub_result(BuffersCompare(bufferTest3, _sizeX / 4, _sizeY / 4, bufferRef3, _sizeX / 4, _sizeY / 4)); |
| |
| ReadPixelsFloat<api>(0, 0, _sizeX, _sizeY / 4, &bufferTest5[0]); |
| result.sub_result(BuffersCompare(bufferTest5, _sizeX, _sizeY / 4, bufferRef5, _sizeX, _sizeY / 4)); |
| } |
| break; |
| default: |
| { |
| ReadPixelsFloat<api>(0, 0, _sizeX, _sizeY / 2, &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, _sizeX, _sizeY / 2, bufferRef2, _sizeX, _sizeY / 2)); |
| } |
| break; |
| } |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glUseProgram(0); |
| glDeleteProgram(_program); |
| glDeleteVertexArrays(1, &_vao); |
| glDeleteBuffers(1, &_buffer); |
| glDeleteBuffers(1, &_ebo); |
| glDeleteBuffers(1, &_bufferIndirect); |
| return NO_ERROR; |
| } |
| |
| CPrimitiveMode(TDrawFunction drawFunc, GLenum primitiveType, unsigned int sizeX = -1, unsigned sizeY = -1) |
| : _drawFunc(drawFunc) |
| , _primitiveType(primitiveType) |
| , _drawSizeX(sizeX) |
| , _drawSizeY(sizeY) |
| , _sizeX(0) |
| , _sizeY(0) |
| , _program(0) |
| , _vao(0) |
| , _buffer(0) |
| , _ebo(0) |
| , _bufferIndirect(0) |
| { |
| } |
| |
| private: |
| TDrawFunction _drawFunc; |
| GLenum _primitiveType; |
| unsigned int _drawSizeX, _drawSizeY; //dims for primitive generator |
| unsigned int _sizeX, _sizeY; //rendering size |
| GLuint _program; |
| GLuint _vao, _buffer, _ebo, _bufferIndirect; |
| |
| CPrimitiveMode(); |
| }; |
| |
| template <typename api> |
| class CModeDrawArraysPoints : public CPrimitiveMode |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "glDrawArraysIndirect mode: GL_POINTS"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that glDrawArraysIndirect with GL_POINTS works correctly"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and fill VBO" NL "2. Create indirect buffer" NL |
| "3. Draw primitives using glDrawArraysIndirect" NL "4. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CModeDrawArraysPoints() : CPrimitiveMode(DRAW_ARRAYS, GL_POINTS) |
| { |
| } |
| |
| virtual long Run() |
| { |
| return CPrimitiveMode::Run<api>(true); |
| } |
| }; |
| |
| template <typename api> |
| class CModeDrawArraysLines : public CPrimitiveMode |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "glDrawArraysIndirect mode: GL_LINES"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that glDrawArraysIndirect with GL_LINES works correctly"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and fill VBO" NL "2. Create indirect buffer" NL |
| "3. Draw primitives using glDrawArraysIndirect" NL "4. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CModeDrawArraysLines() : CPrimitiveMode(DRAW_ARRAYS, GL_LINES) |
| { |
| } |
| |
| virtual long Run() |
| { |
| return CPrimitiveMode::Run<api>(); |
| } |
| }; |
| |
| template <typename api> |
| class CModeDrawArraysLineStrip : public CPrimitiveMode |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "glDrawArraysIndirect mode: GL_LINE_STRIP"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that glDrawArraysIndirect with GL_LINE_STRIP works correctly"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and fill VBO" NL "2. Create indirect buffer" NL |
| "3. Draw primitives using glDrawArraysIndirect" NL "4. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CModeDrawArraysLineStrip() : CPrimitiveMode(DRAW_ARRAYS, GL_LINE_STRIP) |
| { |
| } |
| virtual long Run() |
| { |
| return CPrimitiveMode::Run<api>(); |
| } |
| }; |
| |
| template <typename api> |
| class CModeDrawArraysLineLoop : public CPrimitiveMode |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "glDrawArraysIndirect mode: GL_LINE_LOOP"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that glDrawArraysIndirect with GL_LINE_LOOP works correctly"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and fill VBO" NL "2. Create indirect buffer" NL |
| "3. Draw primitives using glDrawArraysIndirect" NL "4. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CModeDrawArraysLineLoop() : CPrimitiveMode(DRAW_ARRAYS, GL_LINE_LOOP) |
| { |
| } |
| |
| virtual long Run() |
| { |
| return CPrimitiveMode::Run<api>(); |
| } |
| }; |
| |
| template <typename api> |
| class CModeDrawArraysTriangleStrip : public CPrimitiveMode |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "glDrawArraysIndirect mode: GL_TRIANGLE_STRIP"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that glDrawArraysIndirect with GL_TRIANGLE_STRIP works correctly"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and fill VBO" NL "2. Create indirect buffer" NL |
| "3. Draw primitives using glDrawArraysIndirect" NL "4. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CModeDrawArraysTriangleStrip() : CPrimitiveMode(DRAW_ARRAYS, GL_TRIANGLE_STRIP, 2, 2) |
| { |
| } |
| |
| virtual long Run() |
| { |
| return CPrimitiveMode::Run<api>(); |
| } |
| }; |
| |
| template <typename api> |
| class CModeDrawArraysTriangleFan : public CPrimitiveMode |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "glDrawArraysIndirect mode: GL_TRIANGLE_FAN"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that glDrawArraysIndirect with GL_TRIANGLE_FAN works correctly"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and fill VBO" NL "2. Create indirect buffer" NL |
| "3. Draw primitives using glDrawArraysIndirect" NL "4. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CModeDrawArraysTriangleFan() : CPrimitiveMode(DRAW_ARRAYS, GL_TRIANGLE_FAN, 2, 2) |
| { |
| } |
| |
| virtual long Run() |
| { |
| return CPrimitiveMode::Run<api>(); |
| } |
| }; |
| |
| template <typename api> |
| class CModeDrawArraysLinesAdjacency : public CPrimitiveMode |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "glDrawArraysIndirect mode: GL_LINES_ADJACENCY"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that glDrawArraysIndirect with GL_LINES_ADJACENCY works correctly"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and fill VBO" NL "2. Create indirect buffer" NL |
| "3. Draw primitives using glDrawArraysIndirect" NL "4. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CModeDrawArraysLinesAdjacency() : CPrimitiveMode(DRAW_ARRAYS, GL_LINES_ADJACENCY) |
| { |
| } |
| |
| virtual long Run() |
| { |
| if (!IsGeometryShaderSupported<api>()) |
| return NOT_SUPPORTED; |
| return CPrimitiveMode::Run<api>(); |
| } |
| }; |
| |
| template <typename api> |
| class CModeDrawArraysLineStripAdjacency : public CPrimitiveMode |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "glDrawArraysIndirect mode: GL_LINE_STRIP_ADJACENCY"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that glDrawArraysIndirect with GL_LINE_STRIP_ADJACENCY works correctly"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and fill VBO" NL "2. Create indirect buffer" NL |
| "3. Draw primitives using glDrawArraysIndirect" NL "4. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CModeDrawArraysLineStripAdjacency() : CPrimitiveMode(DRAW_ARRAYS, GL_LINE_STRIP_ADJACENCY) |
| { |
| } |
| |
| virtual long Run() |
| { |
| if (!IsGeometryShaderSupported<api>()) |
| return NOT_SUPPORTED; |
| return CPrimitiveMode::Run<api>(); |
| } |
| }; |
| |
| template <typename api> |
| class CModeDrawArraysTrianglesAdjacency : public CPrimitiveMode |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "glDrawArraysIndirect mode: GL_TRIANGLES_ADJACENCY"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that glDrawArraysIndirect with GL_TRIANGLES_ADJACENCY works correctly"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and fill VBO" NL "2. Create indirect buffer" NL |
| "3. Draw primitives using glDrawArraysIndirect" NL "4. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CModeDrawArraysTrianglesAdjacency() : CPrimitiveMode(DRAW_ARRAYS, GL_TRIANGLES_ADJACENCY, 4, 4) |
| { |
| } |
| |
| virtual long Run() |
| { |
| if (!IsGeometryShaderSupported<api>()) |
| return NOT_SUPPORTED; |
| return CPrimitiveMode::Run<api>(); |
| } |
| }; |
| |
| template <typename api> |
| class CModeDrawArraysTriangleStripAdjacency : public CPrimitiveMode |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "glDrawArraysIndirect mode: GL_TRIANGLE_STRIP_ADJACENCY"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that glDrawArraysIndirect with GL_TRIANGLE_STRIP_ADJACENCY works correctly"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and fill VBO" NL "2. Create indirect buffer" NL |
| "3. Draw primitives using glDrawArraysIndirect" NL "4. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CModeDrawArraysTriangleStripAdjacency() : CPrimitiveMode(DRAW_ARRAYS, GL_TRIANGLE_STRIP_ADJACENCY, 4, 4) |
| { |
| } |
| virtual long Run() |
| { |
| if (!IsGeometryShaderSupported<api>()) |
| return NOT_SUPPORTED; |
| return CPrimitiveMode::Run<api>(); |
| } |
| }; |
| |
| template <typename api> |
| class CModeDrawElementsPoints : public CPrimitiveMode |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "glDrawElementsIndirect mode: GL_POINTS"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that glDrawElementsIndirect with GL_POINTS works correctly"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and fill VBO" NL "2. Create indirect buffer" NL |
| "3. Draw primitives using glDrawElementsIndirect" NL "4. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CModeDrawElementsPoints() : CPrimitiveMode(DRAW_ELEMENTS, GL_POINTS) |
| { |
| } |
| |
| virtual long Run() |
| { |
| return CPrimitiveMode::Run<api>(true); |
| } |
| }; |
| |
| template <typename api> |
| class CModeDrawElementsLines : public CPrimitiveMode |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "glDrawElementsIndirect mode: GL_LINES"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that glDrawElementsIndirect with GL_LINES works correctly"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and fill VBO" NL "2. Create indirect buffer" NL |
| "3. Draw primitives using glDrawElementsIndirect" NL "4. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CModeDrawElementsLines() : CPrimitiveMode(DRAW_ELEMENTS, GL_LINES) |
| { |
| } |
| virtual long Run() |
| { |
| return CPrimitiveMode::Run<api>(); |
| } |
| }; |
| |
| template <typename api> |
| class CModeDrawElementsLineStrip : public CPrimitiveMode |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "glDrawElementsIndirect mode: GL_LINE_STRIP"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that glDrawElementsIndirect with GL_LINE_STRIP works correctly"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and fill VBO" NL "2. Create indirect buffer" NL |
| "3. Draw primitives using glDrawElementsIndirect" NL "4. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CModeDrawElementsLineStrip() : CPrimitiveMode(DRAW_ELEMENTS, GL_LINE_STRIP) |
| { |
| } |
| virtual long Run() |
| { |
| return CPrimitiveMode::Run<api>(); |
| } |
| }; |
| |
| template <typename api> |
| class CModeDrawElementsLineLoop : public CPrimitiveMode |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "glDrawElementsIndirect mode: GL_LINE_LOOP"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that glDrawElementsIndirect with GL_LINE_LOOP works correctly"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and fill VBO" NL "2. Create indirect buffer" NL |
| "3. Draw primitives using glDrawElementsIndirect" NL "4. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CModeDrawElementsLineLoop() : CPrimitiveMode(DRAW_ELEMENTS, GL_LINE_LOOP) |
| { |
| } |
| virtual long Run() |
| { |
| return CPrimitiveMode::Run<api>(); |
| } |
| }; |
| |
| template <typename api> |
| class CModeDrawElementsTriangleStrip : public CPrimitiveMode |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "glDrawElementsIndirect mode: GL_TRIANGLE_STRIP"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that glDrawElementsIndirect with GL_TRIANGLE_STRIP works correctly"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and fill VBO" NL "2. Create indirect buffer" NL |
| "3. Draw primitives using glDrawElementsIndirect" NL "4. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CModeDrawElementsTriangleStrip() : CPrimitiveMode(DRAW_ELEMENTS, GL_TRIANGLE_STRIP, 2, 2) |
| { |
| } |
| virtual long Run() |
| { |
| return CPrimitiveMode::Run<api>(); |
| } |
| }; |
| |
| template <typename api> |
| class CModeDrawElementsTriangleFan : public CPrimitiveMode |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "glDrawElementsIndirect mode: GL_TRIANGLE_FAN"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that glDrawElementsIndirect with GL_TRIANGLE_FAN works correctly"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and fill VBO" NL "2. Create indirect buffer" NL |
| "3. Draw primitives using glDrawElementsIndirect" NL "4. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CModeDrawElementsTriangleFan() : CPrimitiveMode(DRAW_ELEMENTS, GL_TRIANGLE_FAN, 2, 2) |
| { |
| } |
| virtual long Run() |
| { |
| return CPrimitiveMode::Run<api>(); |
| } |
| }; |
| |
| template <typename api> |
| class CModeDrawElementsLinesAdjacency : public CPrimitiveMode |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "glDrawElementsIndirect mode: GL_LINES_ADJACENCY"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that glDrawElementsIndirect with GL_LINES_ADJACENCY works correctly"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and fill VBO" NL "2. Create indirect buffer" NL |
| "3. Draw primitives using glDrawElementsIndirect" NL "4. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CModeDrawElementsLinesAdjacency() : CPrimitiveMode(DRAW_ELEMENTS, GL_LINES_ADJACENCY) |
| { |
| } |
| virtual long Run() |
| { |
| if (!IsGeometryShaderSupported<api>()) |
| return NOT_SUPPORTED; |
| return CPrimitiveMode::Run<api>(); |
| } |
| }; |
| |
| template <typename api> |
| class CModeDrawElementsLineStripAdjacency : public CPrimitiveMode |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "glDrawElementsIndirect mode: GL_LINE_STRIP_ADJACENCY"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that glDrawElementsIndirect with GL_LINE_STRIP_ADJACENCY works correctly"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and fill VBO" NL "2. Create indirect buffer" NL |
| "3. Draw primitives using glDrawElementsIndirect" NL "4. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CModeDrawElementsLineStripAdjacency() : CPrimitiveMode(DRAW_ELEMENTS, GL_LINE_STRIP_ADJACENCY) |
| { |
| } |
| virtual long Run() |
| { |
| if (!IsGeometryShaderSupported<api>()) |
| return NOT_SUPPORTED; |
| return CPrimitiveMode::Run<api>(); |
| } |
| }; |
| |
| template <typename api> |
| class CModeDrawElementsTrianglesAdjacency : public CPrimitiveMode |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "glDrawElementsIndirect mode: GL_TRIANGLES_ADJACENCY"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that glDrawElementsIndirect with GL_TRIANGLES_ADJACENCY works correctly"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and fill VBO" NL "2. Create indirect buffer" NL |
| "3. Draw primitives using glDrawElementsIndirect" NL "4. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CModeDrawElementsTrianglesAdjacency() : CPrimitiveMode(DRAW_ELEMENTS, GL_TRIANGLES_ADJACENCY, 4, 4) |
| { |
| } |
| virtual long Run() |
| { |
| if (!IsGeometryShaderSupported<api>()) |
| return NOT_SUPPORTED; |
| return CPrimitiveMode::Run<api>(); |
| } |
| }; |
| |
| template <typename api> |
| class CModeDrawElementsTriangleStripAdjacency : public CPrimitiveMode |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "glDrawElementsIndirect mode: GL_TRIANGLE_STRIP_ADJACENCY"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that glDrawElementsIndirect with GL_TRIANGLE_STRIP_ADJACENCY works correctly"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and fill VBO" NL "2. Create indirect buffer" NL |
| "3. Draw primitives using glDrawElementsIndirect" NL "4. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CModeDrawElementsTriangleStripAdjacency() : CPrimitiveMode(DRAW_ELEMENTS, GL_TRIANGLE_STRIP_ADJACENCY, 4, 4) |
| { |
| } |
| virtual long Run() |
| { |
| if (!IsGeometryShaderSupported<api>()) |
| return NOT_SUPPORTED; |
| return CPrimitiveMode::Run<api>(); |
| } |
| }; |
| |
| class CTransformFeedback : public DrawIndirectBase |
| { |
| public: |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| template <typename api> |
| long Run() |
| { |
| CColorArray coords; |
| PrimitiveGen(GL_TRIANGLE_STRIP, 8, 8, coords); |
| |
| glClear(GL_COLOR_BUFFER_BIT); |
| |
| _program = CreateProgram(Vsh<api>(), "", shaders::fshSimple<api>(), false); |
| const GLchar* varyings[] = { "dataOut" }; |
| glTransformFeedbackVaryings(_program, 1, varyings, GL_INTERLEAVED_ATTRIBS); |
| glLinkProgram(_program); |
| if (!CheckProgram(_program)) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| glGenBuffers(1, &_vbo); |
| glBindBuffer(GL_ARRAY_BUFFER, _vbo); |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords.size() * sizeof(coords[0])), &coords[0], GL_STATIC_DRAW); |
| |
| glGenBuffers(1, &_ubo); |
| glBindBuffer(GL_UNIFORM_BUFFER, _ubo); |
| glBufferData(GL_UNIFORM_BUFFER, 4 * 5 * sizeof(GLuint), NULL, GL_STATIC_DRAW); |
| glBindBufferBase(GL_UNIFORM_BUFFER, glGetUniformBlockIndex(_program, "BLOCK"), _ubo); |
| std::vector<GLuint> uboData; |
| |
| switch (_drawFunc) |
| { |
| case DRAW_ARRAYS: |
| { |
| uboData.resize(4 * 4, 0); |
| |
| uboData[0] = static_cast<GLuint>(coords.size()); //count |
| uboData[4] = 1; //primcount |
| uboData[8] = 0; //first |
| uboData[12] = 0; //mbz |
| } |
| break; |
| case DRAW_ELEMENTS: |
| { |
| uboData.resize(4 * 5, 0); |
| uboData[0] = static_cast<GLuint>(coords.size()); //count |
| uboData[4] = 1; //primcount |
| uboData[8] = 0; //firstindex |
| uboData[12] = 0; //basevertex |
| uboData[16] = 0; //mbz |
| } |
| break; |
| default: |
| throw std::runtime_error("Unknown draw function!"); |
| break; |
| } |
| glBufferSubData(GL_UNIFORM_BUFFER, 0, (GLsizeiptr)(uboData.size() * sizeof(uboData[0])), &uboData[0]); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(coords[0]), 0); |
| glEnableVertexAttribArray(0); |
| |
| CElementArray elements(coords.size(), 0); |
| for (size_t i = 0; i < elements.size(); ++i) |
| { |
| elements[i] = static_cast<GLuint>(i); |
| } |
| |
| glGenBuffers(1, &_ebo); |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ebo); |
| glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)(elements.size() * sizeof(elements[0])), &elements[0], |
| GL_STATIC_DRAW); |
| |
| glGenBuffers(1, &_bufferIndirect); |
| |
| glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, _bufferIndirect); |
| GLuint zeroes[] = { 0, 0, 0, 0, 0 }; |
| glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, sizeof(zeroes), zeroes, GL_DYNAMIC_DRAW); |
| glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, _bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| |
| glEnable(GL_RASTERIZER_DISCARD); |
| glBeginTransformFeedback(GL_POINTS); |
| glDrawArrays(GL_POINTS, 0, 5); |
| glEndTransformFeedback(); |
| glDisable(GL_RASTERIZER_DISCARD); |
| |
| switch (_drawFunc) |
| { |
| case DRAW_ARRAYS: |
| glDrawArraysIndirect(GL_TRIANGLES, 0); |
| break; |
| case DRAW_ELEMENTS: |
| glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_INT, 0); |
| |
| break; |
| default: |
| throw std::runtime_error("Unknown draw function!"); |
| break; |
| } |
| |
| CColorArray bufferRef(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.1f, 0.2f, 0.3f, 1.0f)); |
| CColorArray bufferTest(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.0f)); |
| ReadPixelsFloat<api>(0, 0, getWindowWidth(), getWindowHeight(), &bufferTest[0]); |
| |
| DIResult result; |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight(), bufferRef, getWindowWidth(), |
| getWindowHeight())); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glBindBuffer(GL_ARRAY_BUFFER, 0); |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); |
| glBindVertexArray(0); |
| glUseProgram(0); |
| |
| if (_vao) |
| { |
| glDeleteVertexArrays(1, &_vao); |
| } |
| if (_vbo) |
| { |
| glDeleteBuffers(1, &_vbo); |
| } |
| if (_ebo) |
| { |
| glDeleteBuffers(1, &_ebo); |
| } |
| if (_ubo) |
| { |
| glDeleteBuffers(1, &_ubo); |
| } |
| if (_bufferIndirect) |
| { |
| glDeleteBuffers(1, &_bufferIndirect); |
| } |
| if (_program) |
| { |
| glDeleteProgram(_program); |
| } |
| return NO_ERROR; |
| } |
| |
| CTransformFeedback(TDrawFunction drawFunc) |
| : _drawFunc(drawFunc), _program(0), _vao(0), _vbo(0), _ebo(0), _ubo(0), _bufferIndirect(0) |
| { |
| } |
| |
| private: |
| TDrawFunction _drawFunc; |
| GLuint _program; |
| GLuint _vao, _vbo, _ebo, _ubo, _bufferIndirect; |
| |
| CTransformFeedback(); |
| |
| template <typename api> |
| std::string Vsh() |
| { |
| return api::glslVer() + NL "flat out highp uint dataOut;" NL "in vec4 i_vertex;" NL |
| "layout(std140) uniform BLOCK {" NL " uint m[5];" NL "} b;" NL "void main() {" NL |
| " dataOut = b.m[min(4, gl_VertexID)];" NL " gl_Position = i_vertex;" NL "}"; |
| } |
| }; |
| |
| template <typename api> |
| struct CTransformFeedbackArray : public CTransformFeedback |
| { |
| virtual std::string Title() |
| { |
| return "Transform feedback: glDrawArrayIndirect"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that transform feedback works correctly with glDrawArrayIndirect"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create data" NL "2. Use data as input to glDrawArrayIndirect" NL "3. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CTransformFeedbackArray() : CTransformFeedback(DRAW_ARRAYS) |
| { |
| } |
| |
| virtual long Run() |
| { |
| return CTransformFeedback::Run<api>(); |
| } |
| }; |
| |
| template <typename api> |
| struct CTransformFeedbackElements : public CTransformFeedback |
| { |
| virtual std::string Title() |
| { |
| return "Transform feedback: glDrawElementsIndirect"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that transform feedback works correctly with glDrawElementsIndirect"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create data" NL "2. Use data as input to glDrawElementsIndirect" NL "3. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CTransformFeedbackElements() : CTransformFeedback(DRAW_ELEMENTS) |
| { |
| } |
| |
| virtual long Run() |
| { |
| return CTransformFeedback::Run<api>(); |
| } |
| }; |
| |
| class CComputeBase : public DrawIndirectBase |
| { |
| public: |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| template <typename api> |
| long Run() |
| { |
| |
| int width, height; |
| glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_SIZE, 0, &width); |
| glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_SIZE, 1, &height); |
| |
| width = std::min(width, getWindowWidth()); |
| height = std::min(height, getWindowHeight()); |
| |
| glViewport(0, 0, width, height); |
| |
| CColorArray coords(width * height, tcu::Vec4(0)); |
| CColorArray colors(width * height, tcu::Vec4(0)); |
| |
| _program = CreateProgram(Vsh<api>(), "", Fsh<api>(), false); |
| glBindAttribLocation(_program, 0, "in_coords"); |
| glBindAttribLocation(_program, 1, "in_colors"); |
| glLinkProgram(_program); |
| if (!CheckProgram(_program)) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| |
| glGenBuffers(1, &_bufferCoords); |
| glBindBuffer(GL_ARRAY_BUFFER, _bufferCoords); |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords.size() * sizeof(coords[0])), 0, GL_STREAM_DRAW); |
| |
| glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(tcu::Vec4), 0); |
| glEnableVertexAttribArray(0); |
| |
| glGenBuffers(1, &_bufferColors); |
| glBindBuffer(GL_ARRAY_BUFFER, _bufferColors); |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(colors.size() * sizeof(colors[0])), 0, GL_STREAM_DRAW); |
| |
| glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, sizeof(tcu::Vec4), 0); |
| glEnableVertexAttribArray(1); |
| |
| DrawElementsIndirectCommand indirectElements = { 0, 0, 0, 0, 0 }; |
| DrawArraysIndirectCommand indirectArrays = { 0, 0, 0, 0 }; |
| |
| CElementArray elements(width * height, 0); |
| for (size_t i = 0; i < elements.size(); ++i) |
| { |
| elements[i] = static_cast<GLuint>(i); |
| } |
| |
| glGenBuffers(1, &_bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| switch (_drawFunc) |
| { |
| case DRAW_ARRAYS: |
| { |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawArraysIndirectCommand), &indirectArrays, GL_STATIC_DRAW); |
| } |
| break; |
| case DRAW_ELEMENTS: |
| { |
| glGenBuffers(1, &_ebo); |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ebo); |
| glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)(elements.size() * sizeof(elements[0])), &elements[0], |
| GL_STATIC_DRAW); |
| |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawElementsIndirectCommand), &indirectElements, |
| GL_STATIC_DRAW); |
| } |
| break; |
| default: |
| throw std::runtime_error("Unknown draw function!"); |
| break; |
| } |
| |
| _programCompute = CreateComputeProgram(Csh<api>(), false); |
| glLinkProgram(_programCompute); |
| if (!CheckProgram(_programCompute)) |
| { |
| return ERROR; |
| } |
| glUseProgram(_programCompute); |
| glUniform1ui(glGetUniformLocation(_programCompute, "width"), width); |
| glUniform1ui(glGetUniformLocation(_programCompute, "height"), height); |
| glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, _bufferCoords); |
| glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, _bufferColors); |
| glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, _bufferIndirect); |
| |
| glDispatchCompute(width, height, 1); |
| glMemoryBarrier(GL_COMMAND_BARRIER_BIT | GL_SHADER_STORAGE_BARRIER_BIT); |
| |
| glUseProgram(_program); |
| |
| switch (_drawFunc) |
| { |
| case DRAW_ARRAYS: |
| { |
| glDrawArraysIndirect(GL_POINTS, 0); |
| } |
| break; |
| case DRAW_ELEMENTS: |
| { |
| glDrawElementsIndirect(GL_POINTS, GL_UNSIGNED_INT, 0); |
| } |
| break; |
| default: |
| throw std::runtime_error("Unknown draw function!"); |
| break; |
| } |
| |
| CColorArray bufferRef1(width * height / 4, tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f)); |
| CColorArray bufferRef2(width * height / 4, tcu::Vec4(0.5f, 0.0f, 0.0f, 1.0f)); |
| CColorArray bufferRef3(width * height / 4, tcu::Vec4(0.0f, 0.5f, 0.0f, 1.0f)); |
| CColorArray bufferRef4(width * height / 4, tcu::Vec4(0.5f, 0.5f, 0.0f, 1.0f)); |
| CColorArray bufferTest(width * height / 4, tcu::Vec4(0.0f)); |
| |
| DIResult result; |
| ReadPixelsFloat<api>(0, 0, width / 2, height / 2, &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, width / 2, height / 2, bufferRef1, width / 2, height / 2)) |
| << "Region 0 verification failed"; |
| |
| ReadPixelsFloat<api>((width + 1) / 2, 0, width / 2, height / 2, &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, width / 2, height / 2, bufferRef2, width / 2, height / 2)) |
| << "Region 1 verification failed"; |
| |
| ReadPixelsFloat<api>(0, (height + 1) / 2, width / 2, height / 2, &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, width / 2, height / 2, bufferRef3, width / 2, height / 2)) |
| << "Region 2 verification failed"; |
| |
| ReadPixelsFloat<api>((width + 1) / 2, (height + 1) / 2, width / 2, height / 2, &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, width / 2, height / 2, bufferRef4, width / 2, height / 2)) |
| << "Region 3 verification failed"; |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(1); |
| glDisableVertexAttribArray(0); |
| glDeleteProgram(_program); |
| glDeleteProgram(_programCompute); |
| glDeleteVertexArrays(1, &_vao); |
| if (_ebo) |
| glDeleteBuffers(1, &_ebo); |
| glDeleteBuffers(1, &_bufferCoords); |
| glDeleteBuffers(1, &_bufferColors); |
| glDeleteBuffers(1, &_bufferIndirect); |
| glViewport(0, 0, getWindowWidth(), getWindowHeight()); |
| return NO_ERROR; |
| } |
| CComputeBase(TDrawFunction drawFunc) |
| : _drawFunc(drawFunc) |
| , _program(0) |
| , _programCompute(0) |
| , _vao(0) |
| , _ebo(0) |
| , _bufferCoords(0) |
| , _bufferColors(0) |
| , _bufferIndirect(0) |
| { |
| } |
| |
| private: |
| CComputeBase(); |
| TDrawFunction _drawFunc; |
| |
| template <typename api> |
| std::string Vsh() |
| { |
| return api::glslVer() + NL "in vec4 in_coords;" NL "in vec4 in_colors;" NL "out vec4 colors;" NL |
| "void main() {" NL " colors = in_colors;" NL " gl_Position = in_coords;" NL |
| "#if defined(GL_ES)" NL " gl_PointSize = 1.0;" NL "#endif" NL "}"; |
| } |
| |
| template <typename api> |
| std::string Fsh() |
| { |
| return api::glslVer() + NL "precision highp float;" NL "in vec4 colors;" NL "out vec4 outColor;" NL |
| "void main() {" NL " outColor = colors;" NL "}"; |
| } |
| |
| template <typename api> |
| std::string Csh() |
| { |
| return api::glslVer(true) + NL "precision highp int; " NL |
| "precision highp float; " NL |
| " " NL |
| "layout(local_size_x = 1) in; " NL |
| "layout(std430, binding = 0) buffer Vertices { " NL |
| " vec4 vertices[]; " NL |
| "}; " NL |
| "layout(std430, binding = 1) buffer Colors { " NL |
| " vec4 colors[]; " NL |
| "}; " NL |
| "layout(std430, binding = 2) buffer Indirect { " NL |
| " uint indirect[4]; " NL |
| "}; " NL |
| " " NL |
| "uniform uint height; " NL |
| "uniform uint width; " NL |
| " " NL |
| "void main() { " NL |
| " uint w = gl_GlobalInvocationID.x; " NL |
| " uint h = gl_GlobalInvocationID.y; " NL |
| " float stepX = 2.0 / float(width); " NL |
| " float stepY = 2.0 / float(height); " NL |
| " float offsetX = -1.0 + stepX * float(w) + stepX / 2.0; " NL |
| " float offsetY = -1.0 + stepY * float(h) + stepY / 2.0; " NL |
| " uint arrayOffset = h * width + w; " NL |
| " vertices[ arrayOffset ] = vec4(offsetX, offsetY, 0.0, 1.0);" NL |
| " vec4 color = vec4(0.0, 0.0, 0.0, 1.0); " NL |
| " if(w > (width / 2u - 1u)) { " NL |
| " color = color + vec4(0.5, 0.0, 0.0, 0.0); " NL |
| " } " NL |
| " if(h > (height / 2u - 1u)) { " NL |
| " color = color + vec4(0.0, 0.5, 0.0, 0.0); " NL |
| " } " NL |
| " colors[ arrayOffset ] = color; " NL |
| " if(w == 0u && h == 0u) { " NL |
| " indirect[0] = width * height; " NL |
| " indirect[1] = 1u; " NL |
| " } " NL |
| "} "; |
| } |
| |
| GLuint _program, _programCompute; |
| GLuint _vao; |
| GLuint _ebo; |
| GLuint _bufferCoords; |
| GLuint _bufferColors; |
| GLuint _bufferIndirect; |
| }; |
| |
| template <typename api> |
| struct CComputeShaderArray : public CComputeBase |
| { |
| virtual std::string Title() |
| { |
| return "Compute Shader: glDrawArrayIndirect"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that data created by Compute Shader can be used as an input to glDrawArrayIndirect"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create data by Compute Shader" NL "2. Use data as input to glDrawArrayIndirect" NL |
| "3. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CComputeShaderArray() : CComputeBase(DRAW_ARRAYS) |
| { |
| } |
| |
| virtual long Run() |
| { |
| return CComputeBase::Run<api>(); |
| } |
| }; |
| |
| template <typename api> |
| struct CComputeShaderElements : public CComputeBase |
| { |
| virtual std::string Title() |
| { |
| return "Compute Shader: glDrawElementsIndirect"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that data created by Compute Shader can be used as an input to glDrawElementsIndirect"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create data by Compute Shader" NL "2. Use data as input to glDrawElementsIndirect" NL |
| "3. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| CComputeShaderElements() : CComputeBase(DRAW_ELEMENTS) |
| { |
| } |
| |
| virtual long Run() |
| { |
| return CComputeBase::Run<api>(); |
| } |
| }; |
| |
| template <typename api> |
| class CPrimitiveRestartElements : public DrawIndirectBase |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "Primitive restart - glDrawElementsIndirect"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that primitive restart works correctly with glDrawElementsIndirect"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Define primitives using VBO" NL "2. Draw primitives using glDrawElementsIndirect" NL |
| "3. Verify results"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if no OpenGL errors reported"; |
| } |
| |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| int PrimitiveRestartIndex(); |
| |
| void EnablePrimitiveRestart(); |
| |
| void DisablePrimitiveRestart(); |
| |
| virtual long Run() |
| { |
| _program = CreateProgram(shaders::vshSimple<api>(), "", shaders::fshSimple<api>(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| CColorArray coords1; |
| TriangleStipGen(coords1, -1.0f, 1.0f, -1.0, -0.5, 2); |
| |
| CColorArray coords2; |
| TriangleStipGen(coords2, -1.0f, 1.0f, 0.5, 1.0, 4); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, _buffer); |
| |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords1.size() + coords2.size()) * sizeof(coords1[0]), NULL, |
| GL_STREAM_DRAW); |
| glBufferSubData(GL_ARRAY_BUFFER, 0, (GLsizeiptr)(coords1.size() * sizeof(coords1[0])), &coords1[0]); |
| glBufferSubData(GL_ARRAY_BUFFER, (GLintptr)(coords1.size() * sizeof(coords1[0])), |
| (GLsizeiptr)(coords2.size() * sizeof(coords2[0])), &coords2[0]); |
| glVertexAttribPointer(0, sizeof(coords1[0]) / sizeof(float), GL_FLOAT, GL_FALSE, sizeof(coords1[0]), 0); |
| glEnableVertexAttribArray(0); |
| |
| DrawElementsIndirectCommand indirectElements = { 0, 0, 0, 0, 0 }; |
| indirectElements.count = static_cast<GLuint>(coords1.size() + coords2.size() + 1); |
| indirectElements.primCount = static_cast<GLuint>((coords1.size() + coords2.size()) / 2); |
| |
| CElementArray elements; |
| for (size_t i = 0; i < coords1.size(); ++i) |
| { |
| elements.push_back(static_cast<GLuint>(i)); |
| } |
| |
| elements.push_back(PrimitiveRestartIndex()); |
| for (size_t i = 0; i < coords2.size(); ++i) |
| { |
| elements.push_back(static_cast<GLuint>(coords1.size() + i)); |
| } |
| |
| glGenBuffers(1, &_bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawElementsIndirectCommand), &indirectElements, GL_STATIC_DRAW); |
| |
| glGenBuffers(1, &_ebo); |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ebo); |
| glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)(elements.size() * sizeof(elements[0])), &elements[0], |
| GL_STATIC_DRAW); |
| |
| EnablePrimitiveRestart(); |
| |
| glDrawElementsIndirect(GL_TRIANGLE_STRIP, GL_UNSIGNED_INT, 0); |
| |
| CColorArray bufferRef1(getWindowWidth() * getWindowHeight() / 4, tcu::Vec4(0.1f, 0.2f, 0.3f, 1.0f)); |
| CColorArray bufferRef2(getWindowWidth() * getWindowHeight() / 2, tcu::Vec4(0.0f)); |
| CColorArray bufferTest1(getWindowWidth() * getWindowHeight() / 4, tcu::Vec4(0.0f)); |
| CColorArray bufferTest2(getWindowWidth() * getWindowHeight() / 2, tcu::Vec4(0.0f)); |
| |
| DIResult result; |
| ReadPixelsFloat<api>(0, 0, getWindowWidth(), getWindowHeight() / 4, &bufferTest1[0]); |
| result.sub_result(BuffersCompare(bufferTest1, getWindowWidth(), getWindowHeight() / 4, bufferRef1, |
| getWindowWidth(), getWindowHeight() / 4)); |
| // height = 2 * (getWindowHeight() / 4) to avoid border pixels |
| // in case the height is not a multiple of 4. |
| ReadPixelsFloat<api>(0, (getWindowHeight() + 3) / 4, getWindowWidth(), 2 * (getWindowHeight() / 4), &bufferTest2[0]); |
| result.sub_result(BuffersCompare(bufferTest2, getWindowWidth(), getWindowHeight() / 2, bufferRef2, |
| getWindowWidth(), 2 *(getWindowHeight() / 4))); |
| |
| ReadPixelsFloat<api>(0, (getWindowHeight() * 3 + 3) / 4, getWindowWidth(), getWindowHeight() / 4, |
| &bufferTest1[0]); |
| result.sub_result(BuffersCompare(bufferTest1, getWindowWidth(), getWindowHeight() / 4, bufferRef1, |
| getWindowWidth(), getWindowHeight() / 4)); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| |
| DisablePrimitiveRestart(); |
| glDisableVertexAttribArray(0); |
| glUseProgram(0); |
| glDeleteProgram(_program); |
| glDeleteVertexArrays(1, &_vao); |
| glDeleteBuffers(1, &_buffer); |
| glDeleteBuffers(1, &_ebo); |
| glDeleteBuffers(1, &_bufferIndirect); |
| return NO_ERROR; |
| } |
| |
| private: |
| void TriangleStipGen(CColorArray& coords, float widthStart, float widthEnd, float heightStart, float heightEnd, |
| unsigned int primNum) |
| { |
| float widthStep = (widthEnd - widthStart) / static_cast<float>(primNum); |
| float heightStep = (heightEnd - heightStart) / static_cast<float>(primNum); |
| for (unsigned int i = 0; i < primNum; ++i) |
| { |
| float heightOffset = heightStart + heightStep * static_cast<float>(i); |
| for (unsigned int j = 0; j < primNum; ++j) |
| { |
| float widthOffset = widthStart + widthStep * static_cast<float>(j); |
| |
| coords.push_back(tcu::Vec4(widthOffset, heightOffset, 0.0f, 1.0f)); |
| coords.push_back(tcu::Vec4(widthOffset, heightOffset + heightStep, 0.0f, 1.0f)); |
| coords.push_back(tcu::Vec4(widthOffset + widthStep, heightOffset, 0.0f, 1.0f)); |
| coords.push_back(tcu::Vec4(widthOffset + widthStep, heightOffset + heightStep, 0.0f, 1.0f)); |
| } |
| } |
| } |
| GLuint _program; |
| GLuint _vao, _buffer, _ebo, _bufferIndirect; |
| }; |
| |
| template <> |
| int CPrimitiveRestartElements<test_api::ES3>::PrimitiveRestartIndex() |
| { |
| return 0xffffffff; |
| } |
| |
| template <> |
| int CPrimitiveRestartElements<test_api::GL>::PrimitiveRestartIndex() |
| { |
| return 3432432; |
| } |
| |
| template <> |
| void CPrimitiveRestartElements<test_api::ES3>::DisablePrimitiveRestart() |
| { |
| glDisable(GL_PRIMITIVE_RESTART_FIXED_INDEX); |
| } |
| |
| template <> |
| void CPrimitiveRestartElements<test_api::GL>::DisablePrimitiveRestart() |
| { |
| glDisable(GL_PRIMITIVE_RESTART); |
| } |
| |
| template <> |
| void CPrimitiveRestartElements<test_api::ES3>::EnablePrimitiveRestart() |
| { |
| glEnable(GL_PRIMITIVE_RESTART_FIXED_INDEX); |
| } |
| |
| template <> |
| void CPrimitiveRestartElements<test_api::GL>::EnablePrimitiveRestart() |
| { |
| glPrimitiveRestartIndex(PrimitiveRestartIndex()); |
| glEnable(GL_PRIMITIVE_RESTART); |
| } |
| |
| template <typename api> |
| struct CNegativeZeroBufferArray : public DrawIndirectBase |
| { |
| virtual std::string Title() |
| { |
| return "Negative: no indirect buffer/parameter - glDrawArrayIndirect"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that a driver sets error and no driver crash occurred"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "Call glDrawArrayIndirect"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if OpenGL errors reported and no driver crash occurred"; |
| } |
| |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| virtual long Run() |
| { |
| _program = CreateProgram(shaders::vshSimple<api>(), "", shaders::fshSimple<api>(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| CColorArray coords; |
| PrimitiveGen(GL_TRIANGLES, 8, 8, coords); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, _buffer); |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords.size() * sizeof(coords[0])), &coords[0], GL_STREAM_DRAW); |
| |
| glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(coords[0]), 0); |
| glEnableVertexAttribArray(0); |
| |
| glDrawArraysIndirect(GL_TRIANGLES, 0); |
| DIResult result; |
| if (glGetError() != GL_INVALID_OPERATION) |
| { |
| result.error() << "Invalid error code returned by a driver"; |
| } |
| |
| CColorArray bufferRef(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.0f)); |
| CColorArray bufferTest(getWindowWidth() * getWindowHeight(), tcu::Vec4(1.0f)); |
| |
| ReadPixelsFloat<api>(0, 0, getWindowWidth(), getWindowHeight(), &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight(), bufferRef, getWindowWidth(), |
| getWindowHeight())); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glUseProgram(0); |
| glDeleteProgram(_program); |
| glDeleteVertexArrays(1, &_vao); |
| glDeleteBuffers(1, &_buffer); |
| return NO_ERROR; |
| } |
| |
| private: |
| GLuint _program; |
| GLuint _vao, _buffer; |
| }; |
| |
| template <typename api> |
| struct CNegativeZeroBufferElements : public DrawIndirectBase |
| { |
| virtual std::string Title() |
| { |
| return "Negative: no indirect buffer/parameter - glDrawElementsIndirect"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that a driver sets error and no driver crash occurred"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "Call glDrawElementsIndirect"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if OpenGL errors reported and no driver crash occurred"; |
| } |
| |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| virtual long Run() |
| { |
| _program = CreateProgram(shaders::vshSimple<api>(), "", shaders::fshSimple<api>(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| CColorArray coords; |
| PrimitiveGen(GL_TRIANGLES, 8, 8, coords); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, _buffer); |
| |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords.size() * sizeof(coords[0])), &coords[0], GL_STREAM_DRAW); |
| glVertexAttribPointer(0, sizeof(coords[0]) / sizeof(float), GL_FLOAT, GL_FALSE, sizeof(coords[0]), 0); |
| glEnableVertexAttribArray(0); |
| |
| CElementArray elements(coords.size(), 0); |
| for (size_t i = 0; i < elements.size(); ++i) |
| { |
| elements[i] = static_cast<GLuint>(i); |
| } |
| |
| glGenBuffers(1, &_ebo); |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ebo); |
| glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)(elements.size() * sizeof(elements[0])), &elements[0], |
| GL_STATIC_DRAW); |
| |
| glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_INT, 0); |
| |
| DIResult result; |
| if (glGetError() != GL_INVALID_OPERATION) |
| { |
| result.error() << "Invalid error code returned by a driver"; |
| } |
| |
| CColorArray bufferRef(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.0f)); |
| CColorArray bufferTest(getWindowWidth() * getWindowHeight(), tcu::Vec4(1.0f)); |
| |
| ReadPixelsFloat<api>(0, 0, getWindowWidth(), getWindowHeight(), &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight(), bufferRef, getWindowWidth(), |
| getWindowHeight())); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glUseProgram(0); |
| glDeleteProgram(_program); |
| glDeleteVertexArrays(1, &_vao); |
| glDeleteBuffers(1, &_buffer); |
| glDeleteBuffers(1, &_ebo); |
| return NO_ERROR; |
| } |
| |
| private: |
| GLuint _program; |
| GLuint _vao, _buffer, _ebo; |
| }; |
| |
| template <typename api> |
| struct CNegativeInvalidModeArray : public DrawIndirectBase |
| { |
| virtual std::string Title() |
| { |
| return "Negative: invalid mode - glDrawArrayIndirect"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that a driver sets error and no driver crash occurred"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "Set invalid mode to glDrawArrayIndirect"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if OpenGL errors reported and no driver crash occurred"; |
| } |
| |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| virtual long Run() |
| { |
| _program = CreateProgram(shaders::vshSimple<api>(), "", shaders::fshSimple<api>(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| CColorArray coords; |
| PrimitiveGen(GL_TRIANGLES, 8, 8, coords); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, _buffer); |
| |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords.size() * sizeof(coords[0])), &coords[0], GL_STREAM_DRAW); |
| glVertexAttribPointer(0, sizeof(coords[0]) / sizeof(float), GL_FLOAT, GL_FALSE, sizeof(coords[0]), 0); |
| glEnableVertexAttribArray(0); |
| |
| DrawArraysIndirectCommand indirectArrays = { 0, 0, 0, 0 }; |
| indirectArrays.count = static_cast<GLuint>(coords.size()); |
| indirectArrays.primCount = 1; |
| |
| glGenBuffers(1, &_bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawArraysIndirectCommand), &indirectArrays, GL_STATIC_DRAW); |
| |
| glDrawArraysIndirect(GL_FLOAT, 0); |
| |
| DIResult result; |
| if (glGetError() != GL_INVALID_ENUM) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_FLOAT as mode"; |
| } |
| |
| glDrawArraysIndirect(GL_STATIC_DRAW, 0); |
| if (glGetError() != GL_INVALID_ENUM) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_STATIC_DRAW as mode"; |
| } |
| |
| glDrawArraysIndirect(GL_DRAW_INDIRECT_BUFFER, 0); |
| if (glGetError() != GL_INVALID_ENUM) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_DRAW_INDIRECT_BUFFER as mode"; |
| } |
| |
| glDrawArraysIndirect(GL_INVALID_ENUM, 0); |
| if (glGetError() != GL_INVALID_ENUM) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_INVALID_ENUM as mode"; |
| } |
| |
| glDrawArraysIndirect(GL_COLOR_BUFFER_BIT, 0); |
| if (glGetError() != GL_INVALID_ENUM) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_COLOR_BUFFER_BIT as mode"; |
| } |
| |
| glDrawArraysIndirect(GL_ARRAY_BUFFER, 0); |
| if (glGetError() != GL_INVALID_ENUM) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_ARRAY_BUFFER as mode"; |
| } |
| |
| CColorArray bufferRef(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.0f)); |
| CColorArray bufferTest(getWindowWidth() * getWindowHeight(), tcu::Vec4(1.0f)); |
| |
| ReadPixelsFloat<api>(0, 0, getWindowWidth(), getWindowHeight(), &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight(), bufferRef, getWindowWidth(), |
| getWindowHeight())); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glUseProgram(0); |
| glDeleteProgram(_program); |
| glDeleteVertexArrays(1, &_vao); |
| glDeleteBuffers(1, &_buffer); |
| glDeleteBuffers(1, &_bufferIndirect); |
| return NO_ERROR; |
| } |
| |
| private: |
| GLuint _program; |
| GLuint _vao, _buffer, _bufferIndirect; |
| }; |
| |
| template <typename api> |
| struct CNegativeInvalidModeElements : public DrawIndirectBase |
| { |
| virtual std::string Title() |
| { |
| return "Negative: invalid mode - glDrawElementsIndirect"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that a driver sets error and no driver crash occurred"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "Set invalid mode to glDrawElemenetsIndirect"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if OpenGL errors reported and no driver crash occurred"; |
| } |
| |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| virtual long Run() |
| { |
| _program = CreateProgram(shaders::vshSimple<api>(), "", shaders::fshSimple<api>(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| CColorArray coords; |
| PrimitiveGen(GL_TRIANGLES, 8, 8, coords); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, _buffer); |
| |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords.size() * sizeof(coords[0])), &coords[0], GL_STREAM_DRAW); |
| glVertexAttribPointer(0, sizeof(coords[0]) / sizeof(float), GL_FLOAT, GL_FALSE, sizeof(coords[0]), 0); |
| glEnableVertexAttribArray(0); |
| |
| DrawElementsIndirectCommand indirectElements = { 0, 0, 0, 0, 0 }; |
| indirectElements.count = static_cast<GLuint>(coords.size()); |
| indirectElements.primCount = 1; |
| |
| CElementArray elements(coords.size(), 0); |
| for (size_t i = 0; i < elements.size(); ++i) |
| { |
| elements[i] = static_cast<GLuint>(i); |
| } |
| |
| glGenBuffers(1, &_bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawElementsIndirectCommand), &indirectElements, GL_STATIC_DRAW); |
| |
| glGenBuffers(1, &_ebo); |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ebo); |
| glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)(elements.size() * sizeof(elements[0])), &elements[0], |
| GL_STATIC_DRAW); |
| |
| DIResult result; |
| glDrawElementsIndirect(GL_INVALID_ENUM, GL_UNSIGNED_INT, 0); |
| if (glGetError() != GL_INVALID_ENUM) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_FLOAT as mode"; |
| } |
| |
| glDrawElementsIndirect(GL_UNSIGNED_INT, GL_UNSIGNED_INT, 0); |
| if (glGetError() != GL_INVALID_ENUM) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_UNSIGNED_INT as mode"; |
| } |
| |
| glDrawElementsIndirect(GL_ELEMENT_ARRAY_BUFFER, GL_UNSIGNED_INT, 0); |
| if (glGetError() != GL_INVALID_ENUM) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_ELEMENT_ARRAY_BUFFER as mode"; |
| } |
| |
| glDrawElementsIndirect(GL_FASTEST, GL_UNSIGNED_INT, 0); |
| if (glGetError() != GL_INVALID_ENUM) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_FASTEST as mode"; |
| } |
| |
| glDrawElementsIndirect(GL_PACK_ALIGNMENT, GL_UNSIGNED_INT, 0); |
| if (glGetError() != GL_INVALID_ENUM) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_PACK_ALIGNMENT as mode"; |
| } |
| |
| CColorArray bufferRef(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.0f)); |
| CColorArray bufferTest(getWindowWidth() * getWindowHeight(), tcu::Vec4(1.0f)); |
| |
| ReadPixelsFloat<api>(0, 0, getWindowWidth(), getWindowHeight(), &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight(), bufferRef, getWindowWidth(), |
| getWindowHeight())); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glUseProgram(0); |
| glDeleteProgram(_program); |
| glDeleteVertexArrays(1, &_vao); |
| glDeleteBuffers(1, &_buffer); |
| glDeleteBuffers(1, &_ebo); |
| glDeleteBuffers(1, &_bufferIndirect); |
| return NO_ERROR; |
| } |
| |
| private: |
| GLuint _program; |
| GLuint _vao, _buffer, _ebo, _bufferIndirect; |
| }; |
| |
| template <typename api> |
| struct CNegativeNoVAOArrays : public DrawIndirectBase |
| { |
| virtual std::string Title() |
| { |
| return "Negative: no VAO - glDrawArraysIndirect"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that a driver sets error and no driver crash occurred"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "Use glDrawArraysIndirect with default VAO"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if OpenGL errors reported and no driver crash occurred"; |
| } |
| |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| virtual long Run() |
| { |
| _program = CreateProgram(shaders::vshSimple<api>(), "", shaders::fshSimple<api>(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| CColorArray coords; |
| PrimitiveGen(GL_TRIANGLES, 8, 8, coords); |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, _buffer); |
| |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords.size() * sizeof(coords[0])), &coords[0], GL_STREAM_DRAW); |
| glVertexAttribPointer(0, sizeof(coords[0]) / sizeof(float), GL_FLOAT, GL_FALSE, sizeof(coords[0]), 0); |
| glEnableVertexAttribArray(0); |
| |
| DrawArraysIndirectCommand indirectArrays = { 0, 0, 0, 0 }; |
| indirectArrays.count = static_cast<GLuint>(coords.size()); |
| indirectArrays.primCount = 1; |
| |
| glGenBuffers(1, &_bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawElementsIndirectCommand), &indirectArrays, GL_STATIC_DRAW); |
| |
| DIResult result; |
| glDrawArraysIndirect(GL_TRIANGLES, 0); |
| if (glGetError() != GL_INVALID_OPERATION) |
| { |
| result.error() << "Invalid error code returned by a driver"; |
| } |
| |
| if (glu::isContextTypeES(m_context.getRenderContext().getType())) |
| glDisableVertexAttribArray(0); |
| |
| CColorArray bufferRef(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.0f)); |
| CColorArray bufferTest(getWindowWidth() * getWindowHeight(), tcu::Vec4(1.0f)); |
| |
| ReadPixelsFloat<api>(0, 0, getWindowWidth(), getWindowHeight(), &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight(), bufferRef, getWindowWidth(), |
| getWindowHeight())); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| |
| if (glu::isContextTypeES(m_context.getRenderContext().getType())) |
| glDisableVertexAttribArray(0); |
| |
| glUseProgram(0); |
| glDeleteProgram(_program); |
| glDeleteBuffers(1, &_buffer); |
| glDeleteBuffers(1, &_bufferIndirect); |
| return NO_ERROR; |
| } |
| |
| private: |
| GLuint _program; |
| GLuint _buffer, _ebo, _bufferIndirect; |
| }; |
| |
| template <typename api> |
| struct CNegativeNoVAOElements : public DrawIndirectBase |
| { |
| virtual std::string Title() |
| { |
| return "Negative: no VAO - glDrawElementsIndirect"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that a driver sets error and no driver crash occurred"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "Use glDrawElemenetsIndirect with default VAO"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if OpenGL errors reported and no driver crash occurred"; |
| } |
| |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| virtual long Run() |
| { |
| _program = CreateProgram(shaders::vshSimple<api>(), "", shaders::fshSimple<api>(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| CColorArray coords; |
| PrimitiveGen(GL_TRIANGLES, 8, 8, coords); |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, _buffer); |
| |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords.size() * sizeof(coords[0])), &coords[0], GL_STREAM_DRAW); |
| glVertexAttribPointer(0, sizeof(coords[0]) / sizeof(float), GL_FLOAT, GL_FALSE, sizeof(coords[0]), 0); |
| glEnableVertexAttribArray(0); |
| |
| DrawElementsIndirectCommand indirectElements = { 0, 0, 0, 0, 0 }; |
| indirectElements.count = static_cast<GLuint>(coords.size()); |
| indirectElements.primCount = 1; |
| |
| CElementArray elements(coords.size(), 0); |
| for (size_t i = 0; i < elements.size(); ++i) |
| { |
| elements[i] = static_cast<GLuint>(i); |
| } |
| |
| glGenBuffers(1, &_bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawElementsIndirectCommand), &indirectElements, GL_STATIC_DRAW); |
| |
| glGenBuffers(1, &_ebo); |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ebo); |
| glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)(elements.size() * sizeof(elements[0])), &elements[0], |
| GL_STATIC_DRAW); |
| |
| DIResult result; |
| glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_INT, 0); |
| if (glGetError() != GL_INVALID_OPERATION) |
| { |
| result.error() << "Invalid error code returned by a driver"; |
| } |
| |
| if (glu::isContextTypeES(m_context.getRenderContext().getType())) |
| glDisableVertexAttribArray(0); |
| |
| CColorArray bufferRef(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.0f)); |
| CColorArray bufferTest(getWindowWidth() * getWindowHeight(), tcu::Vec4(1.0f)); |
| |
| ReadPixelsFloat<api>(0, 0, getWindowWidth(), getWindowHeight(), &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight(), bufferRef, getWindowWidth(), |
| getWindowHeight())); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glUseProgram(0); |
| glDeleteProgram(_program); |
| glDeleteBuffers(1, &_buffer); |
| glDeleteBuffers(1, &_ebo); |
| glDeleteBuffers(1, &_bufferIndirect); |
| return NO_ERROR; |
| } |
| |
| private: |
| GLuint _program; |
| GLuint _buffer, _ebo, _bufferIndirect; |
| }; |
| |
| template <typename api> |
| struct CNegativeNoVBOArrays : public DrawIndirectBase |
| { |
| virtual std::string Title() |
| { |
| return "Negative: no VBO - glDrawArraysIndirect"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that a driver sets error and no driver crash occurred"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "Use glDrawArraysIndirect with enabled vertex array, that has no VBO bound"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if OpenGL errors reported and no driver crash occurred"; |
| } |
| |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| virtual long Run() |
| { |
| _program = CreateProgram(shaders::vshSimple<api>(), "", shaders::fshSimple<api>(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| CColorArray coords; |
| PrimitiveGen(GL_TRIANGLES, 8, 8, coords); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| glEnableVertexAttribArray(0); |
| |
| DrawArraysIndirectCommand indirectArrays = { 0, 0, 0, 0 }; |
| indirectArrays.count = static_cast<GLuint>(coords.size()); |
| indirectArrays.primCount = 1; |
| |
| glGenBuffers(1, &_bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawElementsIndirectCommand), &indirectArrays, GL_STATIC_DRAW); |
| |
| DIResult result; |
| glDrawArraysIndirect(GL_TRIANGLES, 0); |
| if (glGetError() != GL_INVALID_OPERATION) |
| { |
| result.error() << "Invalid error code returned by a driver"; |
| } |
| |
| glDisableVertexAttribArray(0); |
| |
| CColorArray bufferRef(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.0f)); |
| CColorArray bufferTest(getWindowWidth() * getWindowHeight(), tcu::Vec4(1.0f)); |
| |
| ReadPixelsFloat<api>(0, 0, getWindowWidth(), getWindowHeight(), &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight(), bufferRef, getWindowWidth(), |
| getWindowHeight())); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glUseProgram(0); |
| glDeleteProgram(_program); |
| glDeleteVertexArrays(1, &_vao); |
| glDeleteBuffers(1, &_bufferIndirect); |
| return NO_ERROR; |
| } |
| |
| private: |
| GLuint _program; |
| GLuint _vao, _ebo, _bufferIndirect; |
| }; |
| |
| template <typename api> |
| struct CNegativeNoVBOElements : public DrawIndirectBase |
| { |
| virtual std::string Title() |
| { |
| return "Negative: no VBO - glDrawElementsIndirect"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that a driver sets error and no driver crash occurred"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "Use glDrawElementsIndirect with enabled vertex array, that has no VBO bound"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if OpenGL errors reported and no driver crash occurred"; |
| } |
| |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| virtual long Run() |
| { |
| |
| api::ES_Only(); |
| |
| _program = CreateProgram(shaders::vshSimple<api>(), "", shaders::fshSimple<api>(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| CColorArray coords; |
| PrimitiveGen(GL_TRIANGLES, 8, 8, coords); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| glEnableVertexAttribArray(0); |
| glEnableVertexAttribArray(0); |
| |
| DrawElementsIndirectCommand indirectElements = { 0, 0, 0, 0, 0 }; |
| indirectElements.count = static_cast<GLuint>(coords.size()); |
| indirectElements.primCount = 1; |
| |
| CElementArray elements(coords.size(), 0); |
| for (size_t i = 0; i < elements.size(); ++i) |
| { |
| elements[i] = static_cast<GLuint>(i); |
| } |
| |
| glGenBuffers(1, &_bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawElementsIndirectCommand), &indirectElements, GL_STATIC_DRAW); |
| |
| glGenBuffers(1, &_ebo); |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ebo); |
| glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)(elements.size() * sizeof(elements[0])), &elements[0], |
| GL_STATIC_DRAW); |
| |
| DIResult result; |
| glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_INT, 0); |
| if (glGetError() != GL_INVALID_OPERATION) |
| { |
| result.error() << "Invalid error code returned by a driver"; |
| } |
| |
| glDisableVertexAttribArray(0); |
| |
| CColorArray bufferRef(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.0f)); |
| CColorArray bufferTest(getWindowWidth() * getWindowHeight(), tcu::Vec4(1.0f)); |
| |
| ReadPixelsFloat<api>(0, 0, getWindowWidth(), getWindowHeight(), &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight(), bufferRef, getWindowWidth(), |
| getWindowHeight())); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glUseProgram(0); |
| glDeleteProgram(_program); |
| glDeleteVertexArrays(1, &_vao); |
| glDeleteBuffers(1, &_ebo); |
| glDeleteBuffers(1, &_bufferIndirect); |
| return NO_ERROR; |
| } |
| |
| private: |
| GLuint _program; |
| GLuint _vao, _ebo, _bufferIndirect; |
| }; |
| |
| template <typename api> |
| struct CNegativeBufferMappedArray : public DrawIndirectBase |
| { |
| virtual std::string Title() |
| { |
| return "Negative: buffer mapped - glDrawArraysIndirect"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that a driver sets error and no driver crash occurred"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and bind buffer" NL "2. Map buffer" NL "3. Call glDrawArrayIndirect"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if OpenGL errors reported and no driver crash occurred"; |
| } |
| |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| virtual long Run() |
| { |
| _program = CreateProgram(shaders::vshSimple<api>(), "", shaders::fshSimple<api>(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| CColorArray coords; |
| PrimitiveGen(GL_TRIANGLES, 8, 8, coords); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, _buffer); |
| |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords.size() * sizeof(coords[0])), &coords[0], GL_STREAM_DRAW); |
| glVertexAttribPointer(0, sizeof(coords[0]) / sizeof(float), GL_FLOAT, GL_FALSE, sizeof(coords[0]), 0); |
| glEnableVertexAttribArray(0); |
| |
| DrawArraysIndirectCommand indirectArrays = { 0, 0, 0, 0 }; |
| indirectArrays.count = static_cast<GLuint>(coords.size()); |
| indirectArrays.primCount = 1; |
| |
| glGenBuffers(1, &_bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawArraysIndirectCommand), &indirectArrays, GL_STATIC_DRAW); |
| |
| DIResult result; |
| void* buf = glMapBufferRange(GL_DRAW_INDIRECT_BUFFER, 0, sizeof(DrawArraysIndirectCommand), GL_MAP_READ_BIT); |
| if (buf == 0) |
| { |
| result.error() << "glMapBuffer(GL_DRAW_INDIRECT_BUFFER, GL_MAP_READ_BIT) returned NULL"; |
| } |
| |
| glDrawArraysIndirect(GL_TRIANGLES, 0); |
| |
| GLenum error = glGetError(); |
| if (error == GL_INVALID_OPERATION) |
| { |
| //GL error: nothing is rendered |
| CColorArray bufferRef(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.0f)); |
| CColorArray bufferTest(getWindowWidth() * getWindowHeight(), tcu::Vec4(1.0f)); |
| |
| ReadPixelsFloat<api>(0, 0, getWindowWidth(), getWindowHeight(), &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight(), bufferRef, |
| getWindowWidth(), getWindowHeight())); |
| } |
| else if (error == GL_NO_ERROR) |
| { |
| //No GL error: undefined |
| } |
| else |
| { |
| result.error() << "Invalid error code returned by a driver"; |
| } |
| |
| if (buf) |
| { |
| if (glUnmapBuffer(GL_DRAW_INDIRECT_BUFFER) != GL_TRUE) |
| { |
| result.error() << "glUnmapBuffer(GL_DRAW_INDIRECT_BUFFER) returned GL_FALSE, expected GL_TRUE"; |
| } |
| buf = 0; |
| } |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glUseProgram(0); |
| glDeleteProgram(_program); |
| glDeleteVertexArrays(1, &_vao); |
| glDeleteBuffers(1, &_buffer); |
| glDeleteBuffers(1, &_bufferIndirect); |
| return NO_ERROR; |
| } |
| |
| private: |
| GLuint _program; |
| GLuint _vao, _buffer, _bufferIndirect; |
| }; |
| |
| template <typename api> |
| struct CNegativeBufferMappedElements : public DrawIndirectBase |
| { |
| virtual std::string Title() |
| { |
| return "Negative: buffer mapped - glDrawElementsIndirect"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that a driver sets error and no driver crash occurred"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Create and bind buffer" NL "2. Map buffer" NL "3. Call glDrawElementsIndirect"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if OpenGL errors reported and no driver crash occurred"; |
| } |
| |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| virtual long Run() |
| { |
| _program = CreateProgram(shaders::vshSimple<api>(), "", shaders::fshSimple<api>(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| CColorArray coords; |
| PrimitiveGen(GL_TRIANGLES, 8, 8, coords); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, _buffer); |
| |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords.size() * sizeof(coords[0])), &coords[0], GL_STREAM_DRAW); |
| glVertexAttribPointer(0, sizeof(coords[0]) / sizeof(float), GL_FLOAT, GL_FALSE, sizeof(coords[0]), 0); |
| glEnableVertexAttribArray(0); |
| |
| DrawElementsIndirectCommand indirectElements = { 0, 0, 0, 0, 0 }; |
| indirectElements.count = static_cast<GLuint>(coords.size()); |
| indirectElements.primCount = 1; |
| |
| CElementArray elements(coords.size(), 0); |
| for (size_t i = 0; i < elements.size(); ++i) |
| { |
| elements[i] = static_cast<GLuint>(i); |
| } |
| |
| glGenBuffers(1, &_bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawElementsIndirectCommand), &indirectElements, GL_STATIC_DRAW); |
| |
| glGenBuffers(1, &_ebo); |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ebo); |
| glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)(elements.size() * sizeof(elements[0])), &elements[0], |
| GL_STATIC_DRAW); |
| |
| DIResult result; |
| void* buf = glMapBufferRange(GL_DRAW_INDIRECT_BUFFER, 0, sizeof(DrawElementsIndirectCommand), GL_MAP_WRITE_BIT); |
| if (buf == 0) |
| { |
| result.error() << "glMapBuffer(GL_DRAW_INDIRECT_BUFFER, GL_MAP_WRITE_BIT) returned NULL"; |
| } |
| |
| glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_INT, 0); |
| |
| GLenum error = glGetError(); |
| if (error == GL_INVALID_OPERATION) |
| { |
| //GL error: nothing is rendered |
| CColorArray bufferRef(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.0f)); |
| CColorArray bufferTest(getWindowWidth() * getWindowHeight(), tcu::Vec4(1.0f)); |
| |
| ReadPixelsFloat<api>(0, 0, getWindowWidth(), getWindowHeight(), &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight(), bufferRef, |
| getWindowWidth(), getWindowHeight())); |
| } |
| else if (error == GL_NO_ERROR) |
| { |
| //No GL error: undefined |
| } |
| else |
| { |
| result.error() << "Invalid error code returned by a driver"; |
| } |
| |
| if (buf) |
| { |
| if (glUnmapBuffer(GL_DRAW_INDIRECT_BUFFER) != GL_TRUE) |
| { |
| result.error() << "glUnmapBuffer(GL_DRAW_INDIRECT_BUFFER) returned GL_FALSE, expected GL_TRUE"; |
| } |
| buf = 0; |
| } |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glUseProgram(0); |
| glDeleteProgram(_program); |
| glDeleteVertexArrays(1, &_vao); |
| glDeleteBuffers(1, &_buffer); |
| glDeleteBuffers(1, &_ebo); |
| glDeleteBuffers(1, &_bufferIndirect); |
| return NO_ERROR; |
| } |
| |
| private: |
| GLuint _program; |
| GLuint _vao, _buffer, _ebo, _bufferIndirect; |
| }; |
| |
| template <typename api> |
| struct CNegativeDataWrongElements : public DrawIndirectBase |
| { |
| virtual std::string Title() |
| { |
| return "Negative: invalid type - glDrawElementsIndirect"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that a driver sets error and no driver crash occurred"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Bind non-zero buffer" NL "2. Call glDrawElementsIndirect with invalid type"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if OpenGL errors reported and no driver crash occurred"; |
| } |
| |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| virtual long Run() |
| { |
| _program = CreateProgram(shaders::vshSimple<api>(), "", shaders::fshSimple<api>(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| CColorArray coords; |
| PrimitiveGen(GL_TRIANGLES, 8, 8, coords); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, _buffer); |
| |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords.size() * sizeof(coords[0])), &coords[0], GL_STREAM_DRAW); |
| glVertexAttribPointer(0, sizeof(coords[0]) / sizeof(float), GL_FLOAT, GL_FALSE, sizeof(coords[0]), 0); |
| glEnableVertexAttribArray(0); |
| |
| DrawElementsIndirectCommand indirectElements = { 0, 0, 0, 0, 0 }; |
| indirectElements.count = static_cast<GLuint>(coords.size()); |
| indirectElements.primCount = 1; |
| |
| CElementArray elements(coords.size(), 0); |
| for (size_t i = 0; i < elements.size(); ++i) |
| { |
| elements[i] = static_cast<GLuint>(i); |
| } |
| |
| glGenBuffers(1, &_bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawElementsIndirectCommand), &indirectElements, GL_STATIC_DRAW); |
| |
| glGenBuffers(1, &_ebo); |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ebo); |
| glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)(elements.size() * sizeof(elements[0])), &elements[0], |
| GL_STATIC_DRAW); |
| |
| DIResult result; |
| |
| glDrawElementsIndirect(GL_TRIANGLES, GL_FLOAT, 0); |
| if (glGetError() != GL_INVALID_ENUM) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_FLOAT type"; |
| } |
| |
| glDrawElementsIndirect(GL_TRIANGLES, GL_INT, 0); |
| if (glGetError() != GL_INVALID_ENUM) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_INT type"; |
| } |
| |
| glDrawElementsIndirect(GL_TRIANGLES, GL_STATIC_DRAW, 0); |
| if (glGetError() != GL_INVALID_ENUM) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_STATIC_DRAW type"; |
| } |
| |
| glDrawElementsIndirect(GL_TRIANGLES, GL_SHORT, 0); |
| if (glGetError() != GL_INVALID_ENUM) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_SHORT type"; |
| } |
| |
| glDrawElementsIndirect(GL_TRIANGLES, GL_BYTE, 0); |
| if (glGetError() != GL_INVALID_ENUM) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_BYTE type"; |
| } |
| |
| glDrawElementsIndirect(GL_TRIANGLES, GL_DOUBLE, 0); |
| if (glGetError() != GL_INVALID_ENUM) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_DOUBLE type"; |
| } |
| |
| glDrawElementsIndirect(GL_TRIANGLES, GL_INVALID_ENUM, 0); |
| if (glGetError() != GL_INVALID_ENUM) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_INVALID_ENUM type"; |
| } |
| |
| CColorArray bufferRef(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.0f)); |
| CColorArray bufferTest(getWindowWidth() * getWindowHeight(), tcu::Vec4(1.0f)); |
| |
| ReadPixelsFloat<api>(0, 0, getWindowWidth(), getWindowHeight(), &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight(), bufferRef, getWindowWidth(), |
| getWindowHeight())); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glUseProgram(0); |
| glDeleteProgram(_program); |
| glDeleteVertexArrays(1, &_vao); |
| glDeleteBuffers(1, &_buffer); |
| glDeleteBuffers(1, &_ebo); |
| glDeleteBuffers(1, &_bufferIndirect); |
| return NO_ERROR; |
| } |
| |
| private: |
| GLuint _program; |
| GLuint _vao, _buffer, _ebo, _bufferIndirect; |
| }; |
| |
| template <typename api> |
| class CNegativeGshArray : public DrawIndirectBase |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "Negative: incompatible the input primitive type of gsh - glDrawArrayIndirect"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that a driver sets error and no driver crash occurred"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Bind non-zero buffer" NL "2. Set data" NL "3. Set wrong geometry shader" NL |
| "4. Call glDrawArrayIndirect"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if OpenGL errors reported and no driver crash occurred"; |
| } |
| |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| virtual long Run() |
| { |
| _program = CreateProgram(Vsh(), Gsh(), Fsh(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| CColorArray coords; |
| PrimitiveGen(GL_TRIANGLES, 8, 8, coords); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, _buffer); |
| |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords.size() * sizeof(coords[0])), &coords[0], GL_STREAM_DRAW); |
| glVertexAttribPointer(0, sizeof(coords[0]) / sizeof(float), GL_FLOAT, GL_FALSE, sizeof(coords[0]), 0); |
| glEnableVertexAttribArray(0); |
| |
| DrawArraysIndirectCommand indirectArrays = { 0, 0, 0, 0 }; |
| indirectArrays.count = static_cast<GLuint>(coords.size()); |
| indirectArrays.primCount = 1; |
| indirectArrays.first = 0; |
| indirectArrays.reservedMustBeZero = 0; |
| |
| glGenBuffers(1, &_bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawArraysIndirectCommand), &indirectArrays, GL_STATIC_DRAW); |
| |
| DIResult result; |
| |
| glDrawArraysIndirect(GL_POINTS, 0); |
| if (glGetError() != GL_INVALID_OPERATION) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_INVALID_OPERATION type"; |
| } |
| |
| CColorArray bufferRef(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.0f)); |
| CColorArray bufferTest(getWindowWidth() * getWindowHeight(), tcu::Vec4(1.0f)); |
| |
| ReadPixelsFloat<api>(0, 0, getWindowWidth(), getWindowHeight(), &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight(), bufferRef, getWindowWidth(), |
| getWindowHeight())); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glUseProgram(0); |
| glDeleteProgram(_program); |
| glDeleteVertexArrays(1, &_vao); |
| glDeleteBuffers(1, &_buffer); |
| glDeleteBuffers(1, &_bufferIndirect); |
| return NO_ERROR; |
| } |
| |
| private: |
| std::string Vsh() |
| { |
| return "#version 150" NL "in vec4 coords;" NL "void main() {" NL " gl_Position = coords;" NL "}"; |
| } |
| |
| std::string Gsh() |
| { |
| return "#version 150" NL "layout(triangles) in;" NL "layout(triangle_strip, max_vertices = 10) out;" NL |
| "void main() {" NL " for (int i=0; i<gl_in.length(); ++i) {" NL |
| " gl_Position = gl_in[i].gl_Position;" NL " EmitVertex();" NL " }" NL "}"; |
| } |
| |
| std::string Fsh() |
| { |
| return "#version 140" NL "out vec4 outColor;" NL "void main() {" NL |
| " outColor = vec4(0.1f, 0.2f, 0.3f, 1.0f);" NL "}"; |
| } |
| GLuint _program; |
| GLuint _vao, _buffer, _bufferIndirect; |
| }; |
| |
| template <typename api> |
| class CNegativeGshElements : public DrawIndirectBase |
| { |
| public: |
| virtual std::string Title() |
| { |
| return "Negative: incompatible the input primitive type of gsh - glDrawElementsIndirect"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that a driver sets error and no driver crash occurred"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "1. Bind non-zero buffer" NL "2. Set data" NL "3. Set wrong geometry shader" NL |
| "4. Call glDrawElementsIndirect"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if OpenGL errors reported and no driver crash occurred"; |
| } |
| |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| virtual long Run() |
| { |
| _program = CreateProgram(Vsh(), Gsh(), Fsh(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| CColorArray coords; |
| PrimitiveGen(GL_TRIANGLES, 8, 8, coords); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, _buffer); |
| |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords.size() * sizeof(coords[0])), &coords[0], GL_STREAM_DRAW); |
| glVertexAttribPointer(0, sizeof(coords[0]) / sizeof(float), GL_FLOAT, GL_FALSE, sizeof(coords[0]), 0); |
| glEnableVertexAttribArray(0); |
| |
| DrawElementsIndirectCommand indirectElements = { 0, 0, 0, 0, 0 }; |
| indirectElements.count = static_cast<GLuint>(coords.size()); |
| indirectElements.primCount = 1; |
| |
| CElementArray elements(coords.size(), 0); |
| for (size_t i = 0; i < elements.size(); ++i) |
| { |
| elements[i] = static_cast<GLuint>(i); |
| } |
| |
| glGenBuffers(1, &_bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawElementsIndirectCommand), &indirectElements, GL_STATIC_DRAW); |
| |
| glGenBuffers(1, &_ebo); |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ebo); |
| glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)(elements.size() * sizeof(elements[0])), &elements[0], |
| GL_STATIC_DRAW); |
| |
| DIResult result; |
| |
| glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_INT, 0); |
| if (glGetError() != GL_INVALID_OPERATION) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_INVALID_OPERATION type"; |
| } |
| |
| CColorArray bufferRef(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.0f)); |
| CColorArray bufferTest(getWindowWidth() * getWindowHeight(), tcu::Vec4(1.0f)); |
| |
| ReadPixelsFloat<api>(0, 0, getWindowWidth(), getWindowHeight(), &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight(), bufferRef, getWindowWidth(), |
| getWindowHeight())); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glUseProgram(0); |
| glDeleteProgram(_program); |
| glDeleteVertexArrays(1, &_vao); |
| glDeleteBuffers(1, &_buffer); |
| glDeleteBuffers(1, &_ebo); |
| glDeleteBuffers(1, &_bufferIndirect); |
| return NO_ERROR; |
| } |
| |
| private: |
| std::string Vsh() |
| { |
| return "#version 150" NL "in vec4 coords;" NL "void main() {" NL " gl_Position = coords;" NL "}"; |
| } |
| |
| std::string Gsh() |
| { |
| return "#version 150" NL "layout(lines) in;" NL "layout(line_strip, max_vertices = 10) out;" NL |
| "void main() {" NL " for (int i=0; i<gl_in.length(); ++i) {" NL |
| " gl_Position = gl_in[i].gl_Position;" NL " EmitVertex();" NL " }" NL "}"; |
| } |
| |
| std::string Fsh() |
| { |
| return "#version 140" NL "out vec4 outColor;" NL "void main() {" NL |
| " outColor = vec4(0.1f, 0.2f, 0.3f, 1.0f);" NL "}"; |
| } |
| int _program; |
| GLuint _vao, _buffer, _ebo, _bufferIndirect; |
| }; |
| |
| template <typename api> |
| struct CNegativeInvalidSizeArrays : public DrawIndirectBase |
| { |
| struct TWrongStructure1 |
| { |
| GLuint count; |
| GLuint primCount; |
| }; |
| |
| struct TWrongStructure2 |
| { |
| GLfloat count; |
| GLuint primCount; |
| }; |
| |
| virtual std::string Title() |
| { |
| return "Negative: wrong structure - glDrawArrayIndirect"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that a driver sets error and no driver crash occurred"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "Call glDrawArrayIndirect with wrong structure"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if OpenGL errors reported and no driver crash occurred"; |
| } |
| |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| virtual long Run() |
| { |
| _program = CreateProgram(shaders::vshSimple<api>(), "", shaders::fshSimple<api>(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| CColorArray coords; |
| PrimitiveGen(GL_TRIANGLES, 8, 8, coords); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, _buffer); |
| |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords.size() * sizeof(coords[0])), &coords[0], GL_STREAM_DRAW); |
| glVertexAttribPointer(0, sizeof(coords[0]) / sizeof(float), GL_FLOAT, GL_FALSE, sizeof(coords[0]), 0); |
| glEnableVertexAttribArray(0); |
| |
| TWrongStructure1 indirectArrays = { 0, 0 }; |
| indirectArrays.count = static_cast<GLuint>(coords.size()); |
| indirectArrays.primCount = 1; |
| |
| glGenBuffers(1, &_bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(TWrongStructure1), &indirectArrays, GL_STATIC_DRAW); |
| |
| DIResult result; |
| |
| glDrawArraysIndirect(GL_TRIANGLES, 0); |
| if (glGetError() != GL_INVALID_OPERATION) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_INVALID_OPERATION type"; |
| } |
| |
| glDeleteBuffers(1, &_bufferIndirect); |
| |
| TWrongStructure2 indirectArrays2 = { 0, 0 }; |
| indirectArrays2.count = static_cast<GLfloat>(coords.size()); |
| indirectArrays2.primCount = 1; |
| |
| glGenBuffers(1, &_bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(TWrongStructure2), &indirectArrays2, GL_STATIC_DRAW); |
| |
| glDrawArraysIndirect(GL_TRIANGLES, 0); |
| if (glGetError() != GL_INVALID_OPERATION) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_INVALID_OPERATION type"; |
| } |
| |
| CColorArray bufferRef(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.0f)); |
| CColorArray bufferTest(getWindowWidth() * getWindowHeight(), tcu::Vec4(1.0f)); |
| |
| ReadPixelsFloat<api>(0, 0, getWindowWidth(), getWindowHeight(), &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight(), bufferRef, getWindowWidth(), |
| getWindowHeight())); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glUseProgram(0); |
| glDeleteProgram(_program); |
| glDeleteVertexArrays(1, &_vao); |
| glDeleteBuffers(1, &_buffer); |
| glDeleteBuffers(1, &_bufferIndirect); |
| return NO_ERROR; |
| } |
| |
| private: |
| GLuint _program; |
| GLuint _vao, _buffer, _bufferIndirect; |
| }; |
| |
| template <typename api> |
| struct CNegativeInvalidSizeElements : public DrawIndirectBase |
| { |
| struct TWrongStructure |
| { |
| GLfloat count; |
| GLuint primCount; |
| }; |
| |
| virtual std::string Title() |
| { |
| return "Negative: wrong structure - glDrawElementsIndirect"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that a driver sets error and no driver crash occurred"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "Call glDrawElementsIndirect with wrong structure"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if OpenGL errors reported and no driver crash occurred"; |
| } |
| |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| virtual long Run() |
| { |
| _program = CreateProgram(shaders::vshSimple<api>(), "", shaders::fshSimple<api>(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| CColorArray coords; |
| PrimitiveGen(GL_TRIANGLES, 8, 8, coords); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, _buffer); |
| |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords.size() * sizeof(coords[0])), &coords[0], GL_STREAM_DRAW); |
| glVertexAttribPointer(0, sizeof(coords[0]) / sizeof(float), GL_FLOAT, GL_FALSE, sizeof(coords[0]), 0); |
| glEnableVertexAttribArray(0); |
| |
| DrawArraysIndirectCommand indirectElements = { 0, 0, 0, 0 }; |
| indirectElements.count = static_cast<GLuint>(coords.size()); |
| indirectElements.primCount = 1; |
| |
| CElementArray elements(coords.size(), 0); |
| for (size_t i = 0; i < elements.size(); ++i) |
| { |
| elements[i] = static_cast<GLuint>(i); |
| } |
| |
| glGenBuffers(1, &_bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawArraysIndirectCommand), &indirectElements, GL_STATIC_DRAW); |
| |
| glGenBuffers(1, &_ebo); |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ebo); |
| glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)(elements.size() * sizeof(elements[0])), &elements[0], |
| GL_STATIC_DRAW); |
| |
| DIResult result; |
| |
| glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_INT, 0); |
| if (glGetError() != GL_INVALID_OPERATION) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_INVALID_OPERATION type"; |
| } |
| |
| TWrongStructure indirectElements2 = { 0, 0 }; |
| indirectElements2.count = static_cast<GLfloat>(coords.size()); |
| indirectElements2.primCount = 1; |
| |
| glDeleteBuffers(1, &_bufferIndirect); |
| glGenBuffers(1, &_bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(TWrongStructure), &indirectElements2, GL_STATIC_DRAW); |
| |
| glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_INT, 0); |
| if (glGetError() != GL_INVALID_OPERATION) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_INVALID_OPERATION type"; |
| } |
| |
| CColorArray bufferRef(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.0f)); |
| CColorArray bufferTest(getWindowWidth() * getWindowHeight(), tcu::Vec4(1.0f)); |
| |
| ReadPixelsFloat<api>(0, 0, getWindowWidth(), getWindowHeight(), &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight(), bufferRef, getWindowWidth(), |
| getWindowHeight())); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glUseProgram(0); |
| glDeleteProgram(_program); |
| glDeleteVertexArrays(1, &_vao); |
| glDeleteBuffers(1, &_buffer); |
| glDeleteBuffers(1, &_ebo); |
| glDeleteBuffers(1, &_bufferIndirect); |
| return NO_ERROR; |
| } |
| |
| private: |
| GLuint _program; |
| GLuint _vao, _buffer, _ebo, _bufferIndirect; |
| }; |
| |
| template <typename api> |
| struct CNegativeStructureWrongOffsetArray : public DrawIndirectBase |
| { |
| virtual std::string Title() |
| { |
| return "Negative: wrong offset - glDrawArrayIndirect"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that a driver sets error and no driver crash occurred"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "Call glDrawArrayIndirect with wrong offset"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if OpenGL errors reported and no driver crash occurred"; |
| } |
| |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| virtual long Run() |
| { |
| _program = CreateProgram(shaders::vshSimple<api>(), "", shaders::fshSimple<api>(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| CColorArray coords; |
| PrimitiveGen(GL_TRIANGLES, 8, 8, coords); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, _buffer); |
| |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords.size() * sizeof(coords[0])), &coords[0], GL_STREAM_DRAW); |
| glVertexAttribPointer(0, sizeof(coords[0]) / sizeof(float), GL_FLOAT, GL_FALSE, sizeof(coords[0]), 0); |
| glEnableVertexAttribArray(0); |
| |
| DrawArraysIndirectCommand indirectArrays = { 0, 0, 0, 0 }; |
| indirectArrays.count = static_cast<GLuint>(coords.size()); |
| indirectArrays.primCount = 1; |
| |
| glGenBuffers(1, &_bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawArraysIndirectCommand), &indirectArrays, GL_STATIC_DRAW); |
| |
| DIResult result; |
| |
| glDrawArraysIndirect(GL_TRIANGLES, (void*)(sizeof(DrawArraysIndirectCommand) * 2)); |
| if (glGetError() != GL_INVALID_OPERATION) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_INVALID_OPERATION type"; |
| } |
| |
| glDrawArraysIndirect(GL_TRIANGLES, (void*)(sizeof(GLuint))); |
| if (glGetError() != GL_INVALID_OPERATION) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_INVALID_OPERATION type"; |
| } |
| |
| CColorArray bufferRef(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.0f)); |
| CColorArray bufferTest(getWindowWidth() * getWindowHeight(), tcu::Vec4(1.0f)); |
| |
| ReadPixelsFloat<api>(0, 0, getWindowWidth(), getWindowHeight(), &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight(), bufferRef, getWindowWidth(), |
| getWindowHeight())); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glUseProgram(0); |
| glDeleteProgram(_program); |
| glDeleteVertexArrays(1, &_vao); |
| glDeleteBuffers(1, &_buffer); |
| glDeleteBuffers(1, &_bufferIndirect); |
| return NO_ERROR; |
| } |
| |
| private: |
| GLuint _program; |
| GLuint _vao, _buffer, _bufferIndirect; |
| }; |
| |
| template <typename api> |
| struct CNegativeStructureWrongOffsetElements : public DrawIndirectBase |
| { |
| virtual std::string Title() |
| { |
| return "Negative: wrong offset - glDrawElementsIndirect"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that a driver sets error and no driver crash occurred"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "Call glDrawElementsIndirect with wrong structure"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if OpenGL errors reported and no driver crash occurred"; |
| } |
| |
| virtual long Setup() |
| { |
| glClear(GL_COLOR_BUFFER_BIT); |
| return NO_ERROR; |
| } |
| |
| virtual long Run() |
| { |
| _program = CreateProgram(shaders::vshSimple<api>(), "", shaders::fshSimple<api>(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| CColorArray coords; |
| PrimitiveGen(GL_TRIANGLES, 8, 8, coords); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, _buffer); |
| |
| glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords.size() * sizeof(coords[0])), &coords[0], GL_STREAM_DRAW); |
| glVertexAttribPointer(0, sizeof(coords[0]) / sizeof(float), GL_FLOAT, GL_FALSE, sizeof(coords[0]), 0); |
| glEnableVertexAttribArray(0); |
| |
| DrawElementsIndirectCommand indirectElements = { 0, 0, 0, 0, 0 }; |
| indirectElements.count = static_cast<GLuint>(coords.size()); |
| indirectElements.primCount = 1; |
| |
| CElementArray elements(coords.size(), 0); |
| for (size_t i = 0; i < elements.size(); ++i) |
| { |
| elements[i] = static_cast<GLuint>(i); |
| } |
| |
| glGenBuffers(1, &_bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawElementsIndirectCommand), &indirectElements, GL_STATIC_DRAW); |
| |
| glGenBuffers(1, &_ebo); |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ebo); |
| glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)(elements.size() * sizeof(elements[0])), &elements[0], |
| GL_STATIC_DRAW); |
| |
| DIResult result; |
| |
| glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_INT, (void*)(sizeof(DrawElementsIndirectCommand) * 2)); |
| if (glGetError() != GL_INVALID_OPERATION) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_INVALID_OPERATION type"; |
| } |
| |
| glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_INT, (void*)(sizeof(GLuint))); |
| if (glGetError() != GL_INVALID_OPERATION) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_INVALID_OPERATION type"; |
| } |
| |
| CColorArray bufferRef(getWindowWidth() * getWindowHeight(), tcu::Vec4(0.0f)); |
| CColorArray bufferTest(getWindowWidth() * getWindowHeight(), tcu::Vec4(1.0f)); |
| |
| ReadPixelsFloat<api>(0, 0, getWindowWidth(), getWindowHeight(), &bufferTest[0]); |
| result.sub_result(BuffersCompare(bufferTest, getWindowWidth(), getWindowHeight(), bufferRef, getWindowWidth(), |
| getWindowHeight())); |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glUseProgram(0); |
| glDeleteProgram(_program); |
| glDeleteVertexArrays(1, &_vao); |
| glDeleteBuffers(1, &_buffer); |
| glDeleteBuffers(1, &_ebo); |
| glDeleteBuffers(1, &_bufferIndirect); |
| return NO_ERROR; |
| } |
| |
| private: |
| GLuint _program; |
| GLuint _vao, _buffer, _ebo, _bufferIndirect; |
| }; |
| |
| template <typename api> |
| struct CNegativeUnalignedOffset : public DrawIndirectBase |
| { |
| virtual std::string Title() |
| { |
| return "Negative: unaligned offset - glDrawElementsIndirect and glDrawArraysIndirect"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that a driver sets error and no system/driver crash occurred"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "Call with unaligned offset (1, 3, 1023)"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if OpenGL errors reported and no driver crash occurred"; |
| } |
| |
| virtual long Run() |
| { |
| _program = CreateProgram(shaders::vshSimple<api>(), "", shaders::fshSimple<api>(), true); |
| if (!_program) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| |
| std::vector<GLuint> zarro(4096, 0); |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, _buffer); |
| glBufferData(GL_ARRAY_BUFFER, 4096, &zarro[0], GL_STREAM_DRAW); |
| glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0); |
| glEnableVertexAttribArray(0); |
| |
| glGenBuffers(1, &_bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, 4096, &zarro[0], GL_STATIC_DRAW); |
| |
| glGenBuffers(1, &_ebo); |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ebo); |
| glBufferData(GL_ELEMENT_ARRAY_BUFFER, 4096, &zarro[0], GL_STATIC_DRAW); |
| |
| DIResult result; |
| |
| int offsets[] = { 1, 3, 1023 }; |
| for (size_t i = 0; i < sizeof(offsets) / sizeof(offsets[0]); i++) |
| { |
| glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_INT, reinterpret_cast<void*>((deUintptr)offsets[i])); |
| if (glGetError() != GL_INVALID_VALUE) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_INVALID_VALUE type"; |
| } |
| glDrawArraysIndirect(GL_TRIANGLES, reinterpret_cast<void*>((deUintptr)offsets[i])); |
| if (glGetError() != GL_INVALID_VALUE) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_INVALID_VALUE type"; |
| } |
| } |
| |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glUseProgram(0); |
| glDeleteProgram(_program); |
| glDeleteVertexArrays(1, &_vao); |
| glDeleteBuffers(1, &_buffer); |
| glDeleteBuffers(1, &_ebo); |
| glDeleteBuffers(1, &_bufferIndirect); |
| return NO_ERROR; |
| } |
| |
| private: |
| GLuint _program; |
| GLuint _vao, _buffer, _ebo, _bufferIndirect; |
| }; |
| |
| template <typename api> |
| struct CNegativeXFB : public DrawIndirectBase |
| { |
| virtual std::string Title() |
| { |
| return "Negative: transform feedback active and not paused - glDrawElementsIndirect and glDrawArraysIndirect"; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return "Verify that a driver sets error and no system/driver crash occurred"; |
| } |
| |
| virtual std::string Method() |
| { |
| return "Call with transform feedback active"; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return "The test will pass if OpenGL errors reported and no driver crash occurred"; |
| } |
| |
| virtual long Run() |
| { |
| api::ES_Only(); |
| |
| bool drawWithXFBAllowed = m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader"); |
| |
| _program = CreateProgram(Vsh(), "", shaders::fshSimple<api>(), false); |
| const GLchar* varyings[] = { "dataOut" }; |
| glTransformFeedbackVaryings(_program, 1, varyings, GL_INTERLEAVED_ATTRIBS); |
| glLinkProgram(_program); |
| if (!CheckProgram(_program)) |
| { |
| return ERROR; |
| } |
| glUseProgram(_program); |
| |
| glGenVertexArrays(1, &_vao); |
| glBindVertexArray(_vao); |
| |
| std::vector<GLuint> zarro(4096, 0); |
| |
| glGenBuffers(1, &_buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, _buffer); |
| glBufferData(GL_ARRAY_BUFFER, 4096, &zarro[0], GL_STREAM_DRAW); |
| glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0); |
| glEnableVertexAttribArray(0); |
| |
| glGenBuffers(1, &_bufferIndirect); |
| glBindBuffer(GL_DRAW_INDIRECT_BUFFER, _bufferIndirect); |
| glBufferData(GL_DRAW_INDIRECT_BUFFER, 4096, &zarro[0], GL_STATIC_DRAW); |
| |
| glGenBuffers(1, &_ebo); |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ebo); |
| glBufferData(GL_ELEMENT_ARRAY_BUFFER, 4096, &zarro[0], GL_STATIC_DRAW); |
| |
| glGenBuffers(1, &_xfb); |
| glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, _xfb); |
| glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 4096, &zarro[0], GL_STATIC_DRAW); |
| glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, _xfb); |
| |
| DIResult result; |
| |
| //Without XFO |
| glBeginTransformFeedback(GL_POINTS); |
| |
| glDrawElementsIndirect(GL_POINTS, GL_UNSIGNED_INT, NULL); |
| if (!drawWithXFBAllowed && glGetError() != GL_INVALID_OPERATION) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_INVALID_OPERATION type"; |
| } |
| glDrawArraysIndirect(GL_POINTS, NULL); |
| if (!drawWithXFBAllowed && glGetError() != GL_INVALID_OPERATION) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_INVALID_OPERATION type"; |
| } |
| glEndTransformFeedback(); |
| |
| //With XFO |
| glGenTransformFeedbacks(1, &_xfo); |
| glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, _xfo); |
| glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, _xfb); |
| glBeginTransformFeedback(GL_POINTS); |
| glPauseTransformFeedback(); |
| glResumeTransformFeedback(); |
| |
| glDrawElementsIndirect(GL_POINTS, GL_UNSIGNED_INT, NULL); |
| if (!drawWithXFBAllowed && glGetError() != GL_INVALID_OPERATION) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_INVALID_OPERATION type"; |
| } |
| glDrawArraysIndirect(GL_POINTS, NULL); |
| if (!drawWithXFBAllowed && glGetError() != GL_INVALID_OPERATION) |
| { |
| result.error() << "Invalid error code returned by a driver for GL_INVALID_OPERATION type"; |
| } |
| glEndTransformFeedback(); |
| |
| glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0); |
| return result.code(); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDisableVertexAttribArray(0); |
| glUseProgram(0); |
| glDeleteProgram(_program); |
| glDeleteVertexArrays(1, &_vao); |
| glDeleteBuffers(1, &_buffer); |
| glDeleteBuffers(1, &_ebo); |
| glDeleteBuffers(1, &_bufferIndirect); |
| glDeleteBuffers(1, &_xfb); |
| glDeleteTransformFeedbacks(1, &_xfo); |
| return NO_ERROR; |
| } |
| |
| std::string Vsh() |
| { |
| return api::glslVer() + NL "out highp vec4 dataOut;" NL "in vec4 i_vertex;" NL "void main() {" NL |
| " dataOut = i_vertex;" NL " gl_Position = i_vertex;" NL "}"; |
| } |
| |
| private: |
| GLuint _program; |
| GLuint _vao, _buffer, _ebo, _bufferIndirect, _xfo, _xfb; |
| }; |
| |
| } // namespace |
| DrawIndirectTestsGL40::DrawIndirectTestsGL40(glcts::Context& context) : TestCaseGroup(context, "draw_indirect", "") |
| { |
| } |
| |
| DrawIndirectTestsGL40::~DrawIndirectTestsGL40(void) |
| { |
| } |
| |
| void DrawIndirectTestsGL40::init() |
| { |
| using namespace glcts; |
| |
| DILogger::setOutput(m_context.getTestContext().getLog()); |
| |
| addChild( |
| new TestSubcase(m_context, "basic-binding-default", TestSubcase::Create<CDefaultBindingPoint<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-binding-zero", TestSubcase::Create<CZeroBindingPoint<test_api::GL> >)); |
| addChild( |
| new TestSubcase(m_context, "basic-binding-single", TestSubcase::Create<CSingleBindingPoint<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-binding-multi", TestSubcase::Create<CMultiBindingPoint<test_api::GL> >)); |
| addChild( |
| new TestSubcase(m_context, "basic-binding-delete", TestSubcase::Create<CDeleteBindingPoint<test_api::GL> >)); |
| |
| addChild(new TestSubcase(m_context, "basic-buffer-data", TestSubcase::Create<CBufferData<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-buffer-subData", TestSubcase::Create<CBufferSubData<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-buffer-unMap", TestSubcase::Create<CBufferMap<test_api::GL> >)); |
| addChild( |
| new TestSubcase(m_context, "basic-buffer-getPointerv", TestSubcase::Create<CBufferGetPointerv<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-buffer-mapRange", TestSubcase::Create<CBufferMapRange<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-buffer-flushMappedRange", |
| TestSubcase::Create<CBufferFlushMappedRange<test_api::GL> >)); |
| addChild( |
| new TestSubcase(m_context, "basic-buffer-copySubData", TestSubcase::Create<CBufferCopySubData<test_api::GL> >)); |
| |
| addChild(new TestSubcase(m_context, "basic-drawArrays-singlePrimitive", |
| TestSubcase::Create<CVBODrawArraysSingle<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-drawArrays-manyPrimitives", |
| TestSubcase::Create<CVBODrawArraysMany<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-drawArrays-instancing", |
| TestSubcase::Create<CVBODrawArraysInstancing<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-drawArrays-xfbPaused", |
| TestSubcase::Create<CVBODrawArraysXFBPaused<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-drawElements-singlePrimitive", |
| TestSubcase::Create<CVBODrawElementsSingle<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-drawElements-manyPrimitives", |
| TestSubcase::Create<CVBODrawElementsMany<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-drawElements-instancing", |
| TestSubcase::Create<CVBODrawElementsInstancing<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-drawElements-xfbPaused", |
| TestSubcase::Create<CVBODrawArraysXFBPaused<test_api::GL> >)); |
| |
| addChild(new TestSubcase(m_context, "basic-drawArrays-simple", |
| TestSubcase::Create<CBufferIndirectDrawArraysSimple<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-drawArrays-noFirst", |
| TestSubcase::Create<CBufferIndirectDrawArraysNoFirst<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-drawArrays-bufferOffset", |
| TestSubcase::Create<CBufferIndirectDrawArraysOffset<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-drawArrays-vertexIds", |
| TestSubcase::Create<CBufferIndirectDrawArraysVertexIds<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-drawElements-simple", |
| TestSubcase::Create<CBufferIndirectDrawElementsSimple<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-drawElements-noFirstIndex", |
| TestSubcase::Create<CBufferIndirectDrawElementsNoFirstIndex<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-drawElements-basevertex", |
| TestSubcase::Create<CBufferIndirectDrawElementsNoBasevertex<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-drawElements-bufferOffset", |
| TestSubcase::Create<CBufferIndirectDrawElementsOffset<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-drawElements-vertexIds", |
| TestSubcase::Create<CBufferIndirectDrawElementsVertexIds<test_api::GL> >)); |
| |
| addChild(new TestSubcase(m_context, "basic-indicesDataType-unsigned_short", |
| TestSubcase::Create<CIndicesDataTypeUnsignedShort<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-indicesDataType-unsigned_byte", |
| TestSubcase::Create<CIndicesDataTypeUnsignedByte<test_api::GL> >)); |
| |
| addChild(new TestSubcase(m_context, "basic-mode-drawArrays-points", |
| TestSubcase::Create<CModeDrawArraysPoints<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawArrays-lines", |
| TestSubcase::Create<CModeDrawArraysLines<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawArrays-line_strip", |
| TestSubcase::Create<CModeDrawArraysLineStrip<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawArrays-line_loop", |
| TestSubcase::Create<CModeDrawArraysLineLoop<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawArrays-triangle_strip", |
| TestSubcase::Create<CModeDrawArraysTriangleStrip<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawArrays-triangle_fan", |
| TestSubcase::Create<CModeDrawArraysTriangleFan<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawArrays-lines_adjacency", |
| TestSubcase::Create<CModeDrawArraysLinesAdjacency<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawArrays-line_strip_adjacency", |
| TestSubcase::Create<CModeDrawArraysLineStripAdjacency<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawArrays-triangles_adjacency", |
| TestSubcase::Create<CModeDrawArraysTrianglesAdjacency<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawArrays-triangle_strip_adjacency", |
| TestSubcase::Create<CModeDrawArraysTriangleStripAdjacency<test_api::GL> >)); |
| |
| addChild(new TestSubcase(m_context, "basic-mode-drawElements-points", |
| TestSubcase::Create<CModeDrawElementsPoints<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawElements-lines", |
| TestSubcase::Create<CModeDrawElementsLines<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawElements-line_strip", |
| TestSubcase::Create<CModeDrawElementsLineStrip<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawElements-line_loop", |
| TestSubcase::Create<CModeDrawElementsLineLoop<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawElements-triangle_strip", |
| TestSubcase::Create<CModeDrawElementsTriangleStrip<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawElements-triangle_fan", |
| TestSubcase::Create<CModeDrawElementsTriangleFan<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawElements-lines_adjacency", |
| TestSubcase::Create<CModeDrawElementsLinesAdjacency<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawElements-line_strip_adjacency", |
| TestSubcase::Create<CModeDrawElementsLineStripAdjacency<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawElements-triangles_adjacency", |
| TestSubcase::Create<CModeDrawElementsTrianglesAdjacency<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawElements-triangle_strip_adjacency", |
| TestSubcase::Create<CModeDrawElementsTriangleStripAdjacency<test_api::GL> >)); |
| |
| addChild(new TestSubcase(m_context, "advanced-twoPass-transformFeedback-arrays", |
| TestSubcase::Create<CTransformFeedbackArray<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "advanced-twoPass-transformFeedback-elements", |
| TestSubcase::Create<CTransformFeedbackElements<test_api::GL> >)); |
| |
| addChild(new TestSubcase(m_context, "advanced-primitiveRestart-elements", |
| TestSubcase::Create<CPrimitiveRestartElements<test_api::GL> >)); |
| |
| addChild(new TestSubcase(m_context, "negative-noindirect-arrays", |
| TestSubcase::Create<CNegativeZeroBufferArray<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "negative-noindirect-elements", |
| TestSubcase::Create<CNegativeZeroBufferElements<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "negative-invalidMode-arrays", |
| TestSubcase::Create<CNegativeInvalidModeArray<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "negative-invalidMode-elements", |
| TestSubcase::Create<CNegativeInvalidModeElements<test_api::GL> >)); |
| addChild( |
| new TestSubcase(m_context, "negative-noVAO-arrays", TestSubcase::Create<CNegativeNoVAOArrays<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "negative-noVAO-elements", |
| TestSubcase::Create<CNegativeNoVAOElements<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "negative-bufferMapped-arrays", |
| TestSubcase::Create<CNegativeBufferMappedArray<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "negative-bufferMapped-elements", |
| TestSubcase::Create<CNegativeBufferMappedElements<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "negative-invalidType-elements", |
| TestSubcase::Create<CNegativeDataWrongElements<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "negative-gshIncompatible-arrays", |
| TestSubcase::Create<CNegativeGshArray<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "negative-gshIncompatible-elements", |
| TestSubcase::Create<CNegativeGshElements<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "negative-wrongOffset-arrays", |
| TestSubcase::Create<CNegativeStructureWrongOffsetArray<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "negative-wrongOffset-elements", |
| TestSubcase::Create<CNegativeStructureWrongOffsetElements<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "negative-invalidSize-arrays", |
| TestSubcase::Create<CNegativeInvalidSizeArrays<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "negative-invalidSize-elements", |
| TestSubcase::Create<CNegativeInvalidSizeElements<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "negative-unalignedOffset", |
| TestSubcase::Create<CNegativeUnalignedOffset<test_api::GL> >)); |
| } |
| |
| DrawIndirectTestsGL43::DrawIndirectTestsGL43(glcts::Context& context) : TestCaseGroup(context, "draw_indirect_43", "") |
| { |
| } |
| |
| DrawIndirectTestsGL43::~DrawIndirectTestsGL43(void) |
| { |
| } |
| |
| void DrawIndirectTestsGL43::init() |
| { |
| using namespace glcts; |
| |
| DILogger::setOutput(m_context.getTestContext().getLog()); |
| addChild(new TestSubcase(m_context, "advanced-twoPass-Compute-arrays", |
| TestSubcase::Create<CComputeShaderArray<test_api::GL> >)); |
| addChild(new TestSubcase(m_context, "advanced-twoPass-Compute-elements", |
| TestSubcase::Create<CComputeShaderElements<test_api::GL> >)); |
| } |
| |
| DrawIndirectTestsES31::DrawIndirectTestsES31(glcts::Context& context) : TestCaseGroup(context, "draw_indirect", "") |
| { |
| } |
| |
| DrawIndirectTestsES31::~DrawIndirectTestsES31(void) |
| { |
| } |
| |
| void DrawIndirectTestsES31::init() |
| { |
| using namespace glcts; |
| |
| DILogger::setOutput(m_context.getTestContext().getLog()); |
| |
| addChild( |
| new TestSubcase(m_context, "basic-binding-default", TestSubcase::Create<CDefaultBindingPoint<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-binding-zero", TestSubcase::Create<CZeroBindingPoint<test_api::ES3> >)); |
| addChild( |
| new TestSubcase(m_context, "basic-binding-single", TestSubcase::Create<CSingleBindingPoint<test_api::ES3> >)); |
| addChild( |
| new TestSubcase(m_context, "basic-binding-multi", TestSubcase::Create<CMultiBindingPoint<test_api::ES3> >)); |
| addChild( |
| new TestSubcase(m_context, "basic-binding-delete", TestSubcase::Create<CDeleteBindingPoint<test_api::ES3> >)); |
| |
| addChild(new TestSubcase(m_context, "basic-buffer-data", TestSubcase::Create<CBufferData<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-buffer-subData", TestSubcase::Create<CBufferSubData<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-buffer-getPointerv", |
| TestSubcase::Create<CBufferGetPointerv<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-buffer-mapRange", TestSubcase::Create<CBufferMapRange<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-buffer-flushMappedRange", |
| TestSubcase::Create<CBufferFlushMappedRange<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-buffer-copySubData", |
| TestSubcase::Create<CBufferCopySubData<test_api::ES3> >)); |
| |
| addChild(new TestSubcase(m_context, "basic-drawArrays-singlePrimitive", |
| TestSubcase::Create<CVBODrawArraysSingle<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-drawArrays-manyPrimitives", |
| TestSubcase::Create<CVBODrawArraysMany<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-drawArrays-instancing", |
| TestSubcase::Create<CVBODrawArraysInstancing<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-drawArrays-xfbPaused", |
| TestSubcase::Create<CVBODrawArraysXFBPaused<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-drawElements-singlePrimitive", |
| TestSubcase::Create<CVBODrawElementsSingle<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-drawElements-manyPrimitives", |
| TestSubcase::Create<CVBODrawElementsMany<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-drawElements-instancing", |
| TestSubcase::Create<CVBODrawElementsInstancing<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-drawElements-xfbPaused", |
| TestSubcase::Create<CVBODrawArraysXFBPaused<test_api::ES3> >)); |
| |
| addChild(new TestSubcase(m_context, "basic-drawArrays-simple", |
| TestSubcase::Create<CBufferIndirectDrawArraysSimple<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-drawArrays-noFirst", |
| TestSubcase::Create<CBufferIndirectDrawArraysNoFirst<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-drawArrays-bufferOffset", |
| TestSubcase::Create<CBufferIndirectDrawArraysOffset<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-drawArrays-vertexIds", |
| TestSubcase::Create<CBufferIndirectDrawArraysVertexIds<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-drawElements-simple", |
| TestSubcase::Create<CBufferIndirectDrawElementsSimple<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-drawElements-noFirstIndex", |
| TestSubcase::Create<CBufferIndirectDrawElementsNoFirstIndex<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-drawElements-basevertex", |
| TestSubcase::Create<CBufferIndirectDrawElementsNoBasevertex<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-drawElements-bufferOffset", |
| TestSubcase::Create<CBufferIndirectDrawElementsOffset<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-drawElements-vertexIds", |
| TestSubcase::Create<CBufferIndirectDrawElementsVertexIds<test_api::ES3> >)); |
| |
| addChild(new TestSubcase(m_context, "basic-indicesDataType-unsigned_short", |
| TestSubcase::Create<CIndicesDataTypeUnsignedShort<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-indicesDataType-unsigned_byte", |
| TestSubcase::Create<CIndicesDataTypeUnsignedByte<test_api::ES3> >)); |
| |
| addChild(new TestSubcase(m_context, "basic-mode-drawArrays-points", |
| TestSubcase::Create<CModeDrawArraysPoints<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawArrays-lines", |
| TestSubcase::Create<CModeDrawArraysLines<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawArrays-line_strip", |
| TestSubcase::Create<CModeDrawArraysLineStrip<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawArrays-line_loop", |
| TestSubcase::Create<CModeDrawArraysLineLoop<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawArrays-triangle_strip", |
| TestSubcase::Create<CModeDrawArraysTriangleStrip<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawArrays-triangle_fan", |
| TestSubcase::Create<CModeDrawArraysTriangleFan<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawArrays-lines_adjacency", |
| TestSubcase::Create<CModeDrawArraysLinesAdjacency<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawArrays-line_strip_adjacency", |
| TestSubcase::Create<CModeDrawArraysLineStripAdjacency<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawArrays-triangles_adjacency", |
| TestSubcase::Create<CModeDrawArraysTrianglesAdjacency<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawArrays-triangle_strip_adjacency", |
| TestSubcase::Create<CModeDrawArraysTriangleStripAdjacency<test_api::ES3> >)); |
| |
| addChild(new TestSubcase(m_context, "basic-mode-drawElements-points", |
| TestSubcase::Create<CModeDrawElementsPoints<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawElements-lines", |
| TestSubcase::Create<CModeDrawElementsLines<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawElements-line_strip", |
| TestSubcase::Create<CModeDrawElementsLineStrip<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawElements-line_loop", |
| TestSubcase::Create<CModeDrawElementsLineLoop<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawElements-triangle_strip", |
| TestSubcase::Create<CModeDrawElementsTriangleStrip<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawElements-triangle_fan", |
| TestSubcase::Create<CModeDrawElementsTriangleFan<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawElements-lines_adjacency", |
| TestSubcase::Create<CModeDrawElementsLinesAdjacency<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawElements-line_strip_adjacency", |
| TestSubcase::Create<CModeDrawElementsLineStripAdjacency<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawElements-triangles_adjacency", |
| TestSubcase::Create<CModeDrawElementsTrianglesAdjacency<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "basic-mode-drawElements-triangle_strip_adjacency", |
| TestSubcase::Create<CModeDrawElementsTriangleStripAdjacency<test_api::ES3> >)); |
| |
| addChild(new TestSubcase(m_context, "advanced-twoPass-transformFeedback-arrays", |
| TestSubcase::Create<CTransformFeedbackArray<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "advanced-twoPass-transformFeedback-elements", |
| TestSubcase::Create<CTransformFeedbackElements<test_api::ES3> >)); |
| |
| addChild(new TestSubcase(m_context, "advanced-twoPass-Compute-arrays", |
| TestSubcase::Create<CComputeShaderArray<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "advanced-twoPass-Compute-elements", |
| TestSubcase::Create<CComputeShaderElements<test_api::ES3> >)); |
| |
| addChild(new TestSubcase(m_context, "advanced-primitiveRestart-elements", |
| TestSubcase::Create<CPrimitiveRestartElements<test_api::ES3> >)); |
| |
| addChild(new TestSubcase(m_context, "negative-noindirect-arrays", |
| TestSubcase::Create<CNegativeZeroBufferArray<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "negative-noindirect-elements", |
| TestSubcase::Create<CNegativeZeroBufferElements<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "negative-invalidMode-arrays", |
| TestSubcase::Create<CNegativeInvalidModeArray<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "negative-invalidMode-elements", |
| TestSubcase::Create<CNegativeInvalidModeElements<test_api::ES3> >)); |
| addChild( |
| new TestSubcase(m_context, "negative-noVAO-arrays", TestSubcase::Create<CNegativeNoVAOArrays<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "negative-noVAO-elements", |
| TestSubcase::Create<CNegativeNoVAOElements<test_api::ES3> >)); |
| addChild( |
| new TestSubcase(m_context, "negative-noVBO-arrays", TestSubcase::Create<CNegativeNoVBOArrays<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "negative-noVBO-elements", |
| TestSubcase::Create<CNegativeNoVBOElements<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "negative-bufferMapped-arrays", |
| TestSubcase::Create<CNegativeBufferMappedArray<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "negative-bufferMapped-elements", |
| TestSubcase::Create<CNegativeBufferMappedElements<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "negative-invalidType-elements", |
| TestSubcase::Create<CNegativeDataWrongElements<test_api::ES3> >)); |
| |
| addChild(new TestSubcase(m_context, "negative-wrongOffset-arrays", |
| TestSubcase::Create<CNegativeStructureWrongOffsetArray<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "negative-wrongOffset-elements", |
| TestSubcase::Create<CNegativeStructureWrongOffsetElements<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "negative-invalidSize-arrays", |
| TestSubcase::Create<CNegativeInvalidSizeArrays<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "negative-invalidSize-elements", |
| TestSubcase::Create<CNegativeInvalidSizeElements<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "negative-unalignedOffset", |
| TestSubcase::Create<CNegativeUnalignedOffset<test_api::ES3> >)); |
| addChild(new TestSubcase(m_context, "negative-xfb", TestSubcase::Create<CNegativeXFB<test_api::ES3> >)); |
| } |
| } |
