You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1049 lines
20 KiB
1049 lines
20 KiB
/*-------------------------------------------------------------------------
|
|
* drawElements Quality Program OpenGL ES 3.0 Module
|
|
* -------------------------------------------------
|
|
*
|
|
* Copyright 2014 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
*//*!
|
|
* \file
|
|
* \brief State change call performance tests.
|
|
*//*--------------------------------------------------------------------*/
|
|
|
|
#include "es3pStateChangeCallTests.hpp"
|
|
#include "glsStateChangePerfTestCases.hpp"
|
|
#include "glwFunctions.hpp"
|
|
#include "glwEnums.hpp"
|
|
|
|
namespace deqp
|
|
{
|
|
namespace gles3
|
|
{
|
|
namespace Performance
|
|
{
|
|
|
|
using namespace glw;
|
|
|
|
StateChangeCallTests::StateChangeCallTests (Context& context)
|
|
: TestCaseGroup(context, "state_change_only", "Test cost of state change calls without rendering anything")
|
|
{
|
|
}
|
|
|
|
StateChangeCallTests::~StateChangeCallTests (void)
|
|
{
|
|
}
|
|
|
|
#define ARG_LIST(...) __VA_ARGS__
|
|
|
|
#define ADD_ARG_CASE1(NAME, DESCRIPTION, FUNCNAME, TYPE0, ARGS0)\
|
|
do {\
|
|
class StateChangeCallTest_ ## NAME : public gls::StateChangeCallPerformanceCase\
|
|
{\
|
|
public:\
|
|
StateChangeCallTest_ ## NAME (Context& context, const char* name, const char* description)\
|
|
: gls::StateChangeCallPerformanceCase(context.getTestContext(), context.getRenderContext(), name, description)\
|
|
{\
|
|
}\
|
|
virtual void execCalls (const glw::Functions& gl, int iterNdx, int callCount)\
|
|
{\
|
|
const TYPE0 args0[] = ARGS0;\
|
|
for (int callNdx = 0; callNdx < callCount; callNdx++)\
|
|
{\
|
|
const int baseNdx = iterNdx*callCount + callNdx;\
|
|
const TYPE0 arg0 = args0[baseNdx%DE_LENGTH_OF_ARRAY(args0)];\
|
|
gl.FUNCNAME(arg0);\
|
|
}\
|
|
}\
|
|
};\
|
|
addChild(new StateChangeCallTest_ ## NAME (m_context, #NAME, DESCRIPTION));\
|
|
}while (0);
|
|
|
|
#define ADD_ARG_CASE2(NAME, DESCRIPTION, FUNCNAME, TYPE0, ARGS0, TYPE1, ARGS1)\
|
|
do {\
|
|
class StateChangeCallTest_ ## NAME : public gls::StateChangeCallPerformanceCase\
|
|
{\
|
|
public:\
|
|
StateChangeCallTest_ ## NAME (Context& context, const char* name, const char* description)\
|
|
: gls::StateChangeCallPerformanceCase(context.getTestContext(), context.getRenderContext(), name, description)\
|
|
{\
|
|
}\
|
|
virtual void execCalls (const glw::Functions& gl, int iterNdx, int callCount)\
|
|
{\
|
|
const TYPE0 args0[] = ARGS0;\
|
|
const TYPE1 args1[] = ARGS1;\
|
|
for (int callNdx = 0; callNdx < callCount; callNdx++)\
|
|
{\
|
|
const int baseNdx = iterNdx*callCount + callNdx;\
|
|
const TYPE0 arg0 = args0[baseNdx%DE_LENGTH_OF_ARRAY(args0)];\
|
|
const TYPE1 arg1 = args1[baseNdx%DE_LENGTH_OF_ARRAY(args1)];\
|
|
gl.FUNCNAME(arg0, arg1);\
|
|
}\
|
|
}\
|
|
};\
|
|
addChild(new StateChangeCallTest_ ## NAME (m_context, #NAME, DESCRIPTION));\
|
|
}while (0);
|
|
|
|
#define ADD_ARG_CASE3(NAME, DESCRIPTION, FUNCNAME, TYPE0, ARGS0, TYPE1, ARGS1, TYPE2, ARGS2)\
|
|
do {\
|
|
class StateChangeCallTest_ ## NAME : public gls::StateChangeCallPerformanceCase\
|
|
{\
|
|
public:\
|
|
StateChangeCallTest_ ## NAME (Context& context, const char* name, const char* description)\
|
|
: gls::StateChangeCallPerformanceCase(context.getTestContext(), context.getRenderContext(), name, description)\
|
|
{\
|
|
}\
|
|
virtual void execCalls (const glw::Functions& gl, int iterNdx, int callCount)\
|
|
{\
|
|
const TYPE0 args0[] = ARGS0;\
|
|
const TYPE1 args1[] = ARGS1;\
|
|
const TYPE2 args2[] = ARGS2;\
|
|
for (int callNdx = 0; callNdx < callCount; callNdx++)\
|
|
{\
|
|
const int baseNdx = iterNdx*callCount + callNdx;\
|
|
const TYPE0 arg0 = args0[baseNdx%DE_LENGTH_OF_ARRAY(args0)];\
|
|
const TYPE1 arg1 = args1[baseNdx%DE_LENGTH_OF_ARRAY(args1)];\
|
|
const TYPE2 arg2 = args2[baseNdx%DE_LENGTH_OF_ARRAY(args2)];\
|
|
gl.FUNCNAME(arg0, arg1, arg2);\
|
|
}\
|
|
}\
|
|
};\
|
|
addChild(new StateChangeCallTest_ ## NAME (m_context, #NAME, DESCRIPTION));\
|
|
}while (0);
|
|
|
|
#define ADD_ARG_CASE4(NAME, DESCRIPTION, FUNCNAME, TYPE0, ARGS0, TYPE1, ARGS1, TYPE2, ARGS2, TYPE3, ARGS3)\
|
|
do {\
|
|
class StateChangeCallTest_ ## NAME : public gls::StateChangeCallPerformanceCase\
|
|
{\
|
|
public:\
|
|
StateChangeCallTest_ ## NAME (Context& context, const char* name, const char* description)\
|
|
: gls::StateChangeCallPerformanceCase(context.getTestContext(), context.getRenderContext(), name, description)\
|
|
{\
|
|
}\
|
|
virtual void execCalls (const glw::Functions& gl, int iterNdx, int callCount)\
|
|
{\
|
|
const TYPE0 args0[] = ARGS0;\
|
|
const TYPE1 args1[] = ARGS1;\
|
|
const TYPE2 args2[] = ARGS2;\
|
|
const TYPE3 args3[] = ARGS3;\
|
|
for (int callNdx = 0; callNdx < callCount; callNdx++)\
|
|
{\
|
|
const int baseNdx = iterNdx*callCount + callNdx;\
|
|
const TYPE0 arg0 = args0[baseNdx%DE_LENGTH_OF_ARRAY(args0)];\
|
|
const TYPE1 arg1 = args1[baseNdx%DE_LENGTH_OF_ARRAY(args1)];\
|
|
const TYPE2 arg2 = args2[baseNdx%DE_LENGTH_OF_ARRAY(args2)];\
|
|
const TYPE3 arg3 = args3[baseNdx%DE_LENGTH_OF_ARRAY(args3)];\
|
|
gl.FUNCNAME(arg0, arg1, arg2, arg3);\
|
|
}\
|
|
}\
|
|
};\
|
|
addChild(new StateChangeCallTest_ ## NAME (m_context, #NAME, DESCRIPTION));\
|
|
}while (0);
|
|
|
|
#define ADD_ARG_CASE5(NAME, DESCRIPTION, FUNCNAME, TYPE0, ARGS0, TYPE1, ARGS1, TYPE2, ARGS2, TYPE3, ARGS3, TYPE4, ARGS4)\
|
|
do {\
|
|
class StateChangeCallTest_ ## NAME : public gls::StateChangeCallPerformanceCase\
|
|
{\
|
|
public:\
|
|
StateChangeCallTest_ ## NAME (Context& context, const char* name, const char* description)\
|
|
: gls::StateChangeCallPerformanceCase(context.getTestContext(), context.getRenderContext(), name, description)\
|
|
{\
|
|
}\
|
|
virtual void execCalls (const glw::Functions& gl, int iterNdx, int callCount)\
|
|
{\
|
|
const TYPE0 args0[] = ARGS0;\
|
|
const TYPE1 args1[] = ARGS1;\
|
|
const TYPE2 args2[] = ARGS2;\
|
|
const TYPE3 args3[] = ARGS3;\
|
|
const TYPE4 args4[] = ARGS4;\
|
|
for (int callNdx = 0; callNdx < callCount; callNdx++)\
|
|
{\
|
|
const int baseNdx = iterNdx*callCount + callNdx;\
|
|
const TYPE0 arg0 = args0[baseNdx%DE_LENGTH_OF_ARRAY(args0)];\
|
|
const TYPE1 arg1 = args1[baseNdx%DE_LENGTH_OF_ARRAY(args1)];\
|
|
const TYPE2 arg2 = args2[baseNdx%DE_LENGTH_OF_ARRAY(args2)];\
|
|
const TYPE3 arg3 = args3[baseNdx%DE_LENGTH_OF_ARRAY(args3)];\
|
|
const TYPE4 arg4 = args4[baseNdx%DE_LENGTH_OF_ARRAY(args4)];\
|
|
gl.FUNCNAME(arg0, arg1, arg2, arg3, arg4);\
|
|
}\
|
|
}\
|
|
};\
|
|
addChild(new StateChangeCallTest_ ## NAME (m_context, #NAME, DESCRIPTION));\
|
|
}while (0);
|
|
|
|
#define ADD_ARG_CASE6(NAME, DESCRIPTION, FUNCNAME, TYPE0, ARGS0, TYPE1, ARGS1, TYPE2, ARGS2, TYPE3, ARGS3, TYPE4, ARGS4, TYPE5, ARGS5)\
|
|
do {\
|
|
class StateChangeCallTest_ ## NAME : public gls::StateChangeCallPerformanceCase\
|
|
{\
|
|
public:\
|
|
StateChangeCallTest_ ## NAME (Context& context, const char* name, const char* description)\
|
|
: gls::StateChangeCallPerformanceCase(context.getTestContext(), context.getRenderContext(), name, description)\
|
|
{\
|
|
}\
|
|
virtual void execCalls (const glw::Functions& gl, int iterNdx, int callCount)\
|
|
{\
|
|
const TYPE0 args0[] = ARGS0;\
|
|
const TYPE1 args1[] = ARGS1;\
|
|
const TYPE2 args2[] = ARGS2;\
|
|
const TYPE3 args3[] = ARGS3;\
|
|
const TYPE4 args4[] = ARGS4;\
|
|
const TYPE5 args5[] = ARGS5;\
|
|
for (int callNdx = 0; callNdx < callCount; callNdx++)\
|
|
{\
|
|
const int baseNdx = iterNdx*callCount + callNdx;\
|
|
const TYPE0 arg0 = args0[baseNdx%DE_LENGTH_OF_ARRAY(args0)];\
|
|
const TYPE1 arg1 = args1[baseNdx%DE_LENGTH_OF_ARRAY(args1)];\
|
|
const TYPE2 arg2 = args2[baseNdx%DE_LENGTH_OF_ARRAY(args2)];\
|
|
const TYPE3 arg3 = args3[baseNdx%DE_LENGTH_OF_ARRAY(args3)];\
|
|
const TYPE4 arg4 = args4[baseNdx%DE_LENGTH_OF_ARRAY(args4)];\
|
|
const TYPE5 arg5 = args5[baseNdx%DE_LENGTH_OF_ARRAY(args5)];\
|
|
gl.FUNCNAME(arg0, arg1, arg2, arg3, arg4, arg5);\
|
|
}\
|
|
}\
|
|
};\
|
|
addChild(new StateChangeCallTest_ ## NAME (m_context, #NAME, DESCRIPTION));\
|
|
}while (0);
|
|
|
|
void StateChangeCallTests::init (void)
|
|
{
|
|
ADD_ARG_CASE1(enable, "Test cost of glEnable() calls",
|
|
enable,
|
|
GLenum,
|
|
ARG_LIST({
|
|
GL_CULL_FACE,
|
|
GL_POLYGON_OFFSET_FILL,
|
|
GL_SAMPLE_ALPHA_TO_COVERAGE,
|
|
GL_SAMPLE_COVERAGE,
|
|
GL_SCISSOR_TEST,
|
|
GL_STENCIL_TEST,
|
|
GL_DEPTH_TEST,
|
|
GL_BLEND,
|
|
GL_DITHER,
|
|
GL_RASTERIZER_DISCARD,
|
|
GL_PRIMITIVE_RESTART_FIXED_INDEX
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE1(disable, "Test cost of glDisable() calls",
|
|
disable,
|
|
GLenum,
|
|
ARG_LIST({
|
|
GL_CULL_FACE,
|
|
GL_POLYGON_OFFSET_FILL,
|
|
GL_SAMPLE_ALPHA_TO_COVERAGE,
|
|
GL_SAMPLE_COVERAGE,
|
|
GL_SCISSOR_TEST,
|
|
GL_STENCIL_TEST,
|
|
GL_DEPTH_TEST,
|
|
GL_BLEND,
|
|
GL_DITHER,
|
|
GL_RASTERIZER_DISCARD,
|
|
GL_PRIMITIVE_RESTART_FIXED_INDEX
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE1(depth_func, "Test cost of glDepthFunc() calls",
|
|
depthFunc,
|
|
GLenum,
|
|
ARG_LIST({
|
|
GL_NEVER,
|
|
GL_ALWAYS,
|
|
GL_LESS,
|
|
GL_LEQUAL,
|
|
GL_EQUAL,
|
|
GL_GREATER,
|
|
GL_GEQUAL,
|
|
GL_NOTEQUAL
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE1(depth_mask, "Test cost of glDepthMask() calls",
|
|
depthMask,
|
|
GLboolean,
|
|
ARG_LIST({
|
|
GL_TRUE,
|
|
GL_FALSE
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE1(stencil_mask, "Test cost of glStencilMask() calls",
|
|
stencilMask,
|
|
GLboolean,
|
|
ARG_LIST({
|
|
GL_TRUE,
|
|
GL_FALSE
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE1(clear_depth, "Test cost of glClearDepth() calls",
|
|
clearDepthf,
|
|
GLclampf,
|
|
ARG_LIST({
|
|
0.0f,
|
|
0.5f,
|
|
1.0f
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE1(clear_stencil, "Test cost of glClearStencil() calls",
|
|
clearStencil,
|
|
GLint,
|
|
ARG_LIST({
|
|
0,
|
|
128,
|
|
28
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE1(line_width, "Test cost of glLineWidth() calls",
|
|
lineWidth,
|
|
GLfloat,
|
|
ARG_LIST({
|
|
1.0f,
|
|
0.5f,
|
|
10.0f
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE1(cull_face, "Test cost of glCullFace() calls",
|
|
cullFace,
|
|
GLenum,
|
|
ARG_LIST({
|
|
GL_FRONT,
|
|
GL_BACK,
|
|
GL_FRONT_AND_BACK
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE1(front_face, "Test cost of glFrontFace() calls",
|
|
frontFace,
|
|
GLenum,
|
|
ARG_LIST({
|
|
GL_CCW,
|
|
GL_CW
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE1(blend_equation, "Test cost of glBlendEquation() calls",
|
|
blendEquation,
|
|
GLenum,
|
|
ARG_LIST({
|
|
GL_FUNC_ADD,
|
|
GL_FUNC_SUBTRACT,
|
|
GL_FUNC_REVERSE_SUBTRACT
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE1(enable_vertex_attrib_array, "Test cost of glEnableVertexAttribArray() calls",
|
|
enableVertexAttribArray,
|
|
GLuint,
|
|
ARG_LIST({
|
|
0,
|
|
1,
|
|
2,
|
|
3,
|
|
4,
|
|
5,
|
|
6,
|
|
7,
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE1(disable_vertex_attrib_array, "Test cost of glDisableVertexAttribArray() calls",
|
|
disableVertexAttribArray,
|
|
GLuint,
|
|
ARG_LIST({
|
|
0,
|
|
1,
|
|
2,
|
|
3,
|
|
4,
|
|
5,
|
|
6,
|
|
7,
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE1(use_program, "Test cost of glUseProgram() calls. Note: Uses only program 0.",
|
|
useProgram,
|
|
GLuint,
|
|
ARG_LIST({
|
|
0,
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE1(active_texture, "Test cost of glActiveTexture() calls",
|
|
activeTexture,
|
|
GLenum,
|
|
ARG_LIST({
|
|
GL_TEXTURE0,
|
|
GL_TEXTURE1,
|
|
GL_TEXTURE2,
|
|
GL_TEXTURE3,
|
|
GL_TEXTURE4,
|
|
GL_TEXTURE5,
|
|
GL_TEXTURE6,
|
|
GL_TEXTURE7
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE2(depth_range, "Test cost of glDepthRangef() calls",
|
|
depthRangef,
|
|
GLclampf,
|
|
ARG_LIST({
|
|
0.0f,
|
|
1.0f,
|
|
0.5f
|
|
}),
|
|
GLclampf,
|
|
ARG_LIST({
|
|
0.0f,
|
|
1.0f,
|
|
0.5f
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE2(polygon_offset, "Test cost of glPolygonOffset() calls",
|
|
polygonOffset,
|
|
GLfloat,
|
|
ARG_LIST({
|
|
0.0f,
|
|
1.0f,
|
|
0.5f,
|
|
10.0f
|
|
}),
|
|
GLfloat,
|
|
ARG_LIST({
|
|
0.0f,
|
|
1.0f,
|
|
0.5f,
|
|
1000.0f
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE2(sample_coverage, "Test cost of glSampleCoverage() calls",
|
|
sampleCoverage,
|
|
GLclampf,
|
|
ARG_LIST({
|
|
0.0f,
|
|
1.0f,
|
|
0.5f,
|
|
0.67f
|
|
}),
|
|
GLboolean,
|
|
ARG_LIST({
|
|
GL_TRUE,
|
|
GL_FALSE
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE2(blend_func, "Test cost of glBlendFunc() calls",
|
|
blendFunc,
|
|
GLenum,
|
|
ARG_LIST({
|
|
GL_ZERO,
|
|
GL_ONE,
|
|
GL_SRC_COLOR,
|
|
GL_ONE_MINUS_SRC_COLOR,
|
|
GL_DST_COLOR,
|
|
GL_ONE_MINUS_DST_COLOR,
|
|
GL_SRC_ALPHA,
|
|
GL_ONE_MINUS_SRC_ALPHA,
|
|
GL_DST_ALPHA,
|
|
GL_ONE_MINUS_DST_ALPHA,
|
|
GL_CONSTANT_COLOR,
|
|
GL_ONE_MINUS_CONSTANT_COLOR,
|
|
GL_CONSTANT_ALPHA,
|
|
GL_ONE_MINUS_CONSTANT_ALPHA
|
|
}),
|
|
GLenum,
|
|
ARG_LIST({
|
|
GL_ZERO,
|
|
GL_ONE,
|
|
GL_SRC_COLOR,
|
|
GL_ONE_MINUS_SRC_COLOR,
|
|
GL_DST_COLOR,
|
|
GL_ONE_MINUS_DST_COLOR,
|
|
GL_SRC_ALPHA,
|
|
GL_ONE_MINUS_SRC_ALPHA,
|
|
GL_DST_ALPHA,
|
|
GL_ONE_MINUS_DST_ALPHA,
|
|
GL_CONSTANT_COLOR,
|
|
GL_ONE_MINUS_CONSTANT_COLOR,
|
|
GL_CONSTANT_ALPHA,
|
|
GL_ONE_MINUS_CONSTANT_ALPHA
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE2(blend_equation_separate, "Test cost of glBlendEquationSeparate() calls",
|
|
blendEquationSeparate,
|
|
GLenum,
|
|
ARG_LIST({
|
|
GL_FUNC_ADD,
|
|
GL_FUNC_SUBTRACT,
|
|
GL_FUNC_REVERSE_SUBTRACT
|
|
}),
|
|
GLenum,
|
|
ARG_LIST({
|
|
GL_FUNC_ADD,
|
|
GL_FUNC_SUBTRACT,
|
|
GL_FUNC_REVERSE_SUBTRACT
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE2(stencil_mask_separate, "Test cost of glStencilMaskSeparate() calls",
|
|
stencilMaskSeparate,
|
|
GLenum,
|
|
ARG_LIST({
|
|
GL_FRONT,
|
|
GL_BACK,
|
|
GL_FRONT_AND_BACK
|
|
}),
|
|
GLboolean,
|
|
ARG_LIST({
|
|
GL_TRUE,
|
|
GL_FALSE
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE2(bind_buffer, "Test cost of glBindBuffer() calls. Note: Uses only buffer 0",
|
|
bindBuffer,
|
|
GLenum,
|
|
ARG_LIST({
|
|
GL_ELEMENT_ARRAY_BUFFER,
|
|
GL_ARRAY_BUFFER
|
|
}),
|
|
GLuint,
|
|
ARG_LIST({
|
|
0
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE2(bind_texture, "Test cost of glBindTexture() calls. Note: Uses only texture 0",
|
|
bindTexture,
|
|
GLenum,
|
|
ARG_LIST({
|
|
GL_TEXTURE_2D,
|
|
GL_TEXTURE_CUBE_MAP
|
|
}),
|
|
GLuint,
|
|
ARG_LIST({
|
|
0
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE2(bind_sampler, "Test cost of glBindSampler() calls. Note: Uses only sampler 0",
|
|
bindSampler,
|
|
GLuint,
|
|
ARG_LIST({
|
|
0,
|
|
1,
|
|
2,
|
|
3,
|
|
4,
|
|
5,
|
|
6,
|
|
7
|
|
}),
|
|
GLuint,
|
|
ARG_LIST({
|
|
0
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE1(bind_vertex_array, "Test cost of glBindVertexArray() calls. Note: Uses only VAO 0",
|
|
bindVertexArray,
|
|
GLuint,
|
|
ARG_LIST({
|
|
0
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE2(hint, "Test cost of glHint() calls",
|
|
hint,
|
|
GLenum,
|
|
ARG_LIST({
|
|
GL_GENERATE_MIPMAP_HINT
|
|
}),
|
|
GLenum,
|
|
ARG_LIST({
|
|
GL_FASTEST,
|
|
GL_NICEST,
|
|
GL_DONT_CARE
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE3(stencil_func, "Test cost of glStencilFunc() calls",
|
|
stencilFunc,
|
|
GLenum,
|
|
ARG_LIST({
|
|
GL_NEVER,
|
|
GL_ALWAYS,
|
|
GL_LESS,
|
|
GL_LEQUAL,
|
|
GL_EQUAL,
|
|
GL_GEQUAL,
|
|
GL_GREATER,
|
|
GL_NOTEQUAL
|
|
}),
|
|
GLint,
|
|
ARG_LIST({
|
|
0,
|
|
1,
|
|
255,
|
|
128,
|
|
7
|
|
}),
|
|
GLuint,
|
|
ARG_LIST({
|
|
0,
|
|
1,
|
|
255,
|
|
128,
|
|
7,
|
|
0xFFFFFFFF
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE3(stencil_op, "Test cost of glStencilOp() calls",
|
|
stencilOp,
|
|
GLenum,
|
|
ARG_LIST({
|
|
GL_KEEP,
|
|
GL_ZERO,
|
|
GL_REPLACE,
|
|
GL_INCR,
|
|
GL_DECR,
|
|
GL_INVERT,
|
|
GL_INCR_WRAP,
|
|
GL_DECR_WRAP
|
|
}),
|
|
GLenum,
|
|
ARG_LIST({
|
|
GL_KEEP,
|
|
GL_ZERO,
|
|
GL_REPLACE,
|
|
GL_INCR,
|
|
GL_DECR,
|
|
GL_INVERT,
|
|
GL_INCR_WRAP,
|
|
GL_DECR_WRAP
|
|
}),
|
|
GLenum,
|
|
ARG_LIST({
|
|
GL_KEEP,
|
|
GL_ZERO,
|
|
GL_REPLACE,
|
|
GL_INCR,
|
|
GL_DECR,
|
|
GL_INVERT,
|
|
GL_INCR_WRAP,
|
|
GL_DECR_WRAP
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE4(viewport, "Test cost of glViewport() calls",
|
|
viewport,
|
|
GLint,
|
|
ARG_LIST({
|
|
0,
|
|
1,
|
|
100,
|
|
1145235
|
|
}),
|
|
GLint,
|
|
ARG_LIST({
|
|
0,
|
|
1,
|
|
100,
|
|
1145235
|
|
}),
|
|
GLint,
|
|
ARG_LIST({
|
|
0,
|
|
1,
|
|
100,
|
|
1145235
|
|
}),
|
|
GLint,
|
|
ARG_LIST({
|
|
0,
|
|
1,
|
|
100,
|
|
1145235
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE4(scissor, "Test cost of glScissor() calls",
|
|
scissor,
|
|
GLint,
|
|
ARG_LIST({
|
|
0,
|
|
1,
|
|
100,
|
|
1145235
|
|
}),
|
|
GLint,
|
|
ARG_LIST({
|
|
0,
|
|
1,
|
|
100,
|
|
1145235
|
|
}),
|
|
GLint,
|
|
ARG_LIST({
|
|
0,
|
|
1,
|
|
100,
|
|
1145235
|
|
}),
|
|
GLint,
|
|
ARG_LIST({
|
|
0,
|
|
1,
|
|
100,
|
|
1145235
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE4(stencil_func_separate, "Test cost of glStencilFuncSeparate() calls",
|
|
stencilFuncSeparate,
|
|
GLenum,
|
|
ARG_LIST({
|
|
GL_FRONT,
|
|
GL_BACK,
|
|
GL_FRONT_AND_BACK
|
|
}),
|
|
GLenum,
|
|
ARG_LIST({
|
|
GL_NEVER,
|
|
GL_ALWAYS,
|
|
GL_LESS,
|
|
GL_LEQUAL,
|
|
GL_EQUAL,
|
|
GL_GEQUAL,
|
|
GL_GREATER,
|
|
GL_NOTEQUAL
|
|
}),
|
|
GLint,
|
|
ARG_LIST({
|
|
0,
|
|
1,
|
|
255,
|
|
128,
|
|
7
|
|
}),
|
|
GLuint,
|
|
ARG_LIST({
|
|
0,
|
|
1,
|
|
255,
|
|
128,
|
|
7,
|
|
0xFFFFFFFF
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE4(stencil_op_separatae, "Test cost of glStencilOpSeparate() calls",
|
|
stencilOpSeparate,
|
|
GLenum,
|
|
ARG_LIST({
|
|
GL_FRONT,
|
|
GL_BACK,
|
|
GL_FRONT_AND_BACK
|
|
}),
|
|
GLenum,
|
|
ARG_LIST({
|
|
GL_KEEP,
|
|
GL_ZERO,
|
|
GL_REPLACE,
|
|
GL_INCR,
|
|
GL_DECR,
|
|
GL_INVERT,
|
|
GL_INCR_WRAP,
|
|
GL_DECR_WRAP
|
|
}),
|
|
GLenum,
|
|
ARG_LIST({
|
|
GL_KEEP,
|
|
GL_ZERO,
|
|
GL_REPLACE,
|
|
GL_INCR,
|
|
GL_DECR,
|
|
GL_INVERT,
|
|
GL_INCR_WRAP,
|
|
GL_DECR_WRAP
|
|
}),
|
|
GLenum,
|
|
ARG_LIST({
|
|
GL_KEEP,
|
|
GL_ZERO,
|
|
GL_REPLACE,
|
|
GL_INCR,
|
|
GL_DECR,
|
|
GL_INVERT,
|
|
GL_INCR_WRAP,
|
|
GL_DECR_WRAP
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE4(blend_func_separate, "Test cost of glBlendFuncSeparate() calls",
|
|
blendFuncSeparate,
|
|
GLenum,
|
|
ARG_LIST({
|
|
GL_ZERO,
|
|
GL_ONE,
|
|
GL_SRC_COLOR,
|
|
GL_ONE_MINUS_SRC_COLOR,
|
|
GL_DST_COLOR,
|
|
GL_ONE_MINUS_DST_COLOR,
|
|
GL_SRC_ALPHA,
|
|
GL_ONE_MINUS_SRC_ALPHA,
|
|
GL_DST_ALPHA,
|
|
GL_ONE_MINUS_DST_ALPHA,
|
|
GL_CONSTANT_COLOR,
|
|
GL_ONE_MINUS_CONSTANT_COLOR,
|
|
GL_CONSTANT_ALPHA,
|
|
GL_ONE_MINUS_CONSTANT_ALPHA
|
|
}),
|
|
GLenum,
|
|
ARG_LIST({
|
|
GL_ZERO,
|
|
GL_ONE,
|
|
GL_SRC_COLOR,
|
|
GL_ONE_MINUS_SRC_COLOR,
|
|
GL_DST_COLOR,
|
|
GL_ONE_MINUS_DST_COLOR,
|
|
GL_SRC_ALPHA,
|
|
GL_ONE_MINUS_SRC_ALPHA,
|
|
GL_DST_ALPHA,
|
|
GL_ONE_MINUS_DST_ALPHA,
|
|
GL_CONSTANT_COLOR,
|
|
GL_ONE_MINUS_CONSTANT_COLOR,
|
|
GL_CONSTANT_ALPHA,
|
|
GL_ONE_MINUS_CONSTANT_ALPHA
|
|
}),
|
|
GLenum,
|
|
ARG_LIST({
|
|
GL_ZERO,
|
|
GL_ONE,
|
|
GL_SRC_COLOR,
|
|
GL_ONE_MINUS_SRC_COLOR,
|
|
GL_DST_COLOR,
|
|
GL_ONE_MINUS_DST_COLOR,
|
|
GL_SRC_ALPHA,
|
|
GL_ONE_MINUS_SRC_ALPHA,
|
|
GL_DST_ALPHA,
|
|
GL_ONE_MINUS_DST_ALPHA,
|
|
GL_CONSTANT_COLOR,
|
|
GL_ONE_MINUS_CONSTANT_COLOR,
|
|
GL_CONSTANT_ALPHA,
|
|
GL_ONE_MINUS_CONSTANT_ALPHA
|
|
}),
|
|
GLenum,
|
|
ARG_LIST({
|
|
GL_ZERO,
|
|
GL_ONE,
|
|
GL_SRC_COLOR,
|
|
GL_ONE_MINUS_SRC_COLOR,
|
|
GL_DST_COLOR,
|
|
GL_ONE_MINUS_DST_COLOR,
|
|
GL_SRC_ALPHA,
|
|
GL_ONE_MINUS_SRC_ALPHA,
|
|
GL_DST_ALPHA,
|
|
GL_ONE_MINUS_DST_ALPHA,
|
|
GL_CONSTANT_COLOR,
|
|
GL_ONE_MINUS_CONSTANT_COLOR,
|
|
GL_CONSTANT_ALPHA,
|
|
GL_ONE_MINUS_CONSTANT_ALPHA
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE4(color_mask, "Test cost of glColorMask() calls",
|
|
colorMask,
|
|
GLboolean,
|
|
ARG_LIST({
|
|
GL_TRUE,
|
|
GL_FALSE
|
|
}),
|
|
GLboolean,
|
|
ARG_LIST({
|
|
GL_TRUE,
|
|
GL_FALSE
|
|
}),
|
|
GLboolean,
|
|
ARG_LIST({
|
|
GL_TRUE,
|
|
GL_FALSE
|
|
}),
|
|
GLboolean,
|
|
ARG_LIST({
|
|
GL_TRUE,
|
|
GL_FALSE
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE4(clear_color, "Test cost of glClearColor() calls",
|
|
clearColor,
|
|
GLclampf,
|
|
ARG_LIST({
|
|
0.0f,
|
|
1.0f,
|
|
0.5f,
|
|
0.33f
|
|
}),
|
|
GLclampf,
|
|
ARG_LIST({
|
|
0.0f,
|
|
1.0f,
|
|
0.5f,
|
|
0.33f
|
|
}),
|
|
GLclampf,
|
|
ARG_LIST({
|
|
0.0f,
|
|
1.0f,
|
|
0.5f,
|
|
0.33f
|
|
}),
|
|
GLclampf,
|
|
ARG_LIST({
|
|
0.0f,
|
|
1.0f,
|
|
0.5f,
|
|
0.33f
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE6(vertex_attrib_pointer, "Test cost of glVertexAttribPointer() calls",
|
|
vertexAttribPointer,
|
|
GLuint,
|
|
ARG_LIST({
|
|
0,
|
|
1,
|
|
2,
|
|
3,
|
|
4,
|
|
5,
|
|
6,
|
|
7
|
|
}),
|
|
GLint,
|
|
ARG_LIST({
|
|
1,
|
|
2,
|
|
3,
|
|
4
|
|
}),
|
|
GLenum,
|
|
ARG_LIST({
|
|
GL_UNSIGNED_BYTE,
|
|
GL_BYTE,
|
|
GL_UNSIGNED_SHORT,
|
|
GL_SHORT,
|
|
GL_FLOAT
|
|
}),
|
|
GLboolean,
|
|
ARG_LIST({
|
|
GL_FALSE,
|
|
GL_TRUE
|
|
}),
|
|
GLsizei,
|
|
ARG_LIST({
|
|
0,
|
|
2,
|
|
4
|
|
}),
|
|
void*,
|
|
ARG_LIST({
|
|
(void*)(deUintptr)(0x0FF),
|
|
(void*)(deUintptr)(0x0EF)
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE2(vertex_attrib_divisor, "Test cost of glVertexAttribDivisor() calls",
|
|
vertexAttribDivisor,
|
|
GLuint,
|
|
ARG_LIST({
|
|
0,
|
|
1,
|
|
2,
|
|
3,
|
|
4,
|
|
5,
|
|
6,
|
|
7
|
|
}),
|
|
GLuint,
|
|
ARG_LIST({
|
|
0,
|
|
1,
|
|
3,
|
|
7,
|
|
11,
|
|
127,
|
|
256
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE3(bind_buffer_base, "Test cost of glBindBufferBase() calls. Note: uses only buffer 0.",
|
|
bindBufferBase,
|
|
GLuint,
|
|
ARG_LIST({
|
|
GL_UNIFORM_BUFFER
|
|
}),
|
|
GLuint,
|
|
ARG_LIST({
|
|
0,
|
|
1,
|
|
2,
|
|
3
|
|
}),
|
|
GLuint,
|
|
ARG_LIST({
|
|
0
|
|
})
|
|
);
|
|
|
|
ADD_ARG_CASE5(bind_buffer_range, "Test cost of glBindBufferRange() calls. Note: uses only buffer 0.",
|
|
bindBufferRange,
|
|
GLuint,
|
|
ARG_LIST({
|
|
GL_UNIFORM_BUFFER
|
|
}),
|
|
GLuint,
|
|
ARG_LIST({
|
|
0,
|
|
1,
|
|
2,
|
|
3
|
|
}),
|
|
GLuint,
|
|
ARG_LIST({
|
|
0
|
|
}),
|
|
GLintptr,
|
|
ARG_LIST({
|
|
0
|
|
}),
|
|
GLsizeiptr,
|
|
ARG_LIST({
|
|
0
|
|
})
|
|
);
|
|
}
|
|
|
|
} // Performance
|
|
} // gles3
|
|
} // deqp
|