blob: db4dafccc0876421b7f44def950287c53831c58b [file] [log] [blame]
//
// Copyright 2017 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// ProgramInterfaceTest: Tests of program interfaces.
#include "common/string_utils.h"
#include "test_utils/ANGLETest.h"
#include "test_utils/gl_raii.h"
using namespace angle;
namespace
{
class ProgramInterfaceTestES31 : public ANGLETest
{
protected:
ProgramInterfaceTestES31()
{
setWindowWidth(64);
setWindowHeight(64);
setConfigRedBits(8);
setConfigGreenBits(8);
setConfigBlueBits(8);
setConfigAlphaBits(8);
}
};
// Tests glGetProgramResourceIndex.
TEST_P(ProgramInterfaceTestES31, GetResourceIndex)
{
constexpr char kFS[] =
"#version 310 es\n"
"precision highp float;\n"
"uniform vec4 color;\n"
"out vec4 oColor;\n"
"void main()\n"
"{\n"
" oColor = color;\n"
"}";
ANGLE_GL_PROGRAM(program, essl31_shaders::vs::Simple(), kFS);
GLuint index =
glGetProgramResourceIndex(program, GL_PROGRAM_INPUT, essl31_shaders::PositionAttrib());
EXPECT_GL_NO_ERROR();
EXPECT_NE(GL_INVALID_INDEX, index);
index = glGetProgramResourceIndex(program, GL_PROGRAM_INPUT, "missing");
EXPECT_GL_NO_ERROR();
EXPECT_EQ(GL_INVALID_INDEX, index);
index = glGetProgramResourceIndex(program, GL_PROGRAM_OUTPUT, "oColor");
EXPECT_GL_NO_ERROR();
EXPECT_NE(GL_INVALID_INDEX, index);
index = glGetProgramResourceIndex(program, GL_PROGRAM_OUTPUT, "missing");
EXPECT_GL_NO_ERROR();
EXPECT_EQ(GL_INVALID_INDEX, index);
index = glGetProgramResourceIndex(program, GL_ATOMIC_COUNTER_BUFFER, "missing");
EXPECT_GL_ERROR(GL_INVALID_ENUM);
}
// Tests glGetProgramResourceName.
TEST_P(ProgramInterfaceTestES31, GetResourceName)
{
constexpr char kFS[] =
"#version 310 es\n"
"precision highp float;\n"
"uniform vec4 color;\n"
"out vec4 oColor[4];\n"
"void main()\n"
"{\n"
" oColor[0] = color;\n"
"}";
ANGLE_GL_PROGRAM(program, essl31_shaders::vs::Simple(), kFS);
GLuint index =
glGetProgramResourceIndex(program, GL_PROGRAM_INPUT, essl31_shaders::PositionAttrib());
EXPECT_GL_NO_ERROR();
EXPECT_NE(GL_INVALID_INDEX, index);
GLchar name[64];
GLsizei length;
glGetProgramResourceName(program, GL_PROGRAM_INPUT, index, sizeof(name), &length, name);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(static_cast<int>(strlen(essl31_shaders::PositionAttrib())), length);
EXPECT_EQ(essl31_shaders::PositionAttrib(), std::string(name));
glGetProgramResourceName(program, GL_PROGRAM_INPUT, index, 4, &length, name);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(3, length);
EXPECT_TRUE(angle::BeginsWith(essl31_shaders::PositionAttrib(), name));
glGetProgramResourceName(program, GL_PROGRAM_INPUT, index, -1, &length, name);
EXPECT_GL_ERROR(GL_INVALID_VALUE);
glGetProgramResourceName(program, GL_PROGRAM_INPUT, GL_INVALID_INDEX, sizeof(name), &length,
name);
EXPECT_GL_ERROR(GL_INVALID_VALUE);
index = glGetProgramResourceIndex(program, GL_PROGRAM_OUTPUT, "oColor");
EXPECT_GL_NO_ERROR();
EXPECT_NE(GL_INVALID_INDEX, index);
glGetProgramResourceName(program, GL_PROGRAM_OUTPUT, index, sizeof(name), &length, name);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(9, length);
EXPECT_EQ("oColor[0]", std::string(name));
glGetProgramResourceName(program, GL_PROGRAM_OUTPUT, index, 8, &length, name);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(7, length);
EXPECT_EQ("oColor[", std::string(name));
}
// Tests glGetProgramResourceLocation.
TEST_P(ProgramInterfaceTestES31, GetResourceLocation)
{
// http://anglebug.com/4092
ANGLE_SKIP_TEST_IF(isSwiftshader());
constexpr char kVS[] =
"#version 310 es\n"
"precision highp float;\n"
"layout(location = 3) in highp vec4 position;\n"
"in highp vec4 noLocationSpecified;\n"
"void main()\n"
"{\n"
" gl_Position = position;\n"
"}";
constexpr char kFS[] =
"#version 310 es\n"
"precision highp float;\n"
"uniform vec4 color;\n"
"layout(location = 2) out vec4 oColor[4];\n"
"void main()\n"
"{\n"
" oColor[0] = color;\n"
"}";
ANGLE_GL_PROGRAM(program, kVS, kFS);
GLenum invalidInterfaces[] = {GL_UNIFORM_BLOCK, GL_TRANSFORM_FEEDBACK_VARYING,
GL_BUFFER_VARIABLE, GL_SHADER_STORAGE_BLOCK,
GL_ATOMIC_COUNTER_BUFFER};
GLint location;
for (auto &invalidInterface : invalidInterfaces)
{
location = glGetProgramResourceLocation(program, invalidInterface, "any");
EXPECT_GL_ERROR(GL_INVALID_ENUM);
EXPECT_EQ(-1, location);
}
location = glGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "position");
EXPECT_GL_NO_ERROR();
EXPECT_EQ(3, location);
location = glGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "noLocationSpecified");
EXPECT_GL_NO_ERROR();
EXPECT_EQ(-1, location);
location = glGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "missing");
EXPECT_GL_NO_ERROR();
EXPECT_EQ(-1, location);
location = glGetProgramResourceLocation(program, GL_PROGRAM_OUTPUT, "oColor");
EXPECT_GL_NO_ERROR();
EXPECT_EQ(2, location);
location = glGetProgramResourceLocation(program, GL_PROGRAM_OUTPUT, "oColor[0]");
EXPECT_GL_NO_ERROR();
EXPECT_EQ(2, location);
location = glGetProgramResourceLocation(program, GL_PROGRAM_OUTPUT, "oColor[3]");
EXPECT_GL_NO_ERROR();
EXPECT_EQ(5, location);
}
// Tests glGetProgramResource.
TEST_P(ProgramInterfaceTestES31, GetResource)
{
// http://anglebug.com/4092
ANGLE_SKIP_TEST_IF(isSwiftshader());
constexpr char kVS[] =
"#version 310 es\n"
"precision highp float;\n"
"layout(location = 3) in highp vec4 position;\n"
"void main()\n"
"{\n"
" gl_Position = position;\n"
"}";
constexpr char kFS[] =
"#version 310 es\n"
"precision highp float;\n"
"uniform vec4 color;\n"
"layout(location = 2) out vec4 oColor[4];\n"
"void main()\n"
"{\n"
" oColor[0] = color;\n"
"}";
ANGLE_GL_PROGRAM(program, kVS, kFS);
GLuint index = glGetProgramResourceIndex(program, GL_PROGRAM_INPUT, "position");
EXPECT_GL_NO_ERROR();
EXPECT_NE(GL_INVALID_INDEX, index);
GLenum props[] = {GL_TYPE,
GL_ARRAY_SIZE,
GL_LOCATION,
GL_NAME_LENGTH,
GL_REFERENCED_BY_VERTEX_SHADER,
GL_REFERENCED_BY_FRAGMENT_SHADER,
GL_REFERENCED_BY_COMPUTE_SHADER};
GLsizei propCount = static_cast<GLsizei>(ArraySize(props));
GLint params[ArraySize(props)];
GLsizei length;
glGetProgramResourceiv(program, GL_PROGRAM_INPUT, index, propCount, props, propCount, &length,
params);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(propCount, length);
EXPECT_EQ(GL_FLOAT_VEC4, params[0]); // type
EXPECT_EQ(1, params[1]); // array_size
EXPECT_EQ(3, params[2]); // location
EXPECT_EQ(9, params[3]); // name_length
EXPECT_EQ(1, params[4]); // referenced_by_vertex_shader
EXPECT_EQ(0, params[5]); // referenced_by_fragment_shader
EXPECT_EQ(0, params[6]); // referenced_by_compute_shader
index = glGetProgramResourceIndex(program, GL_PROGRAM_OUTPUT, "oColor[0]");
EXPECT_GL_NO_ERROR();
EXPECT_NE(index, GL_INVALID_INDEX);
// bufSize is smaller than propCount.
glGetProgramResourceiv(program, GL_PROGRAM_OUTPUT, index, propCount, props, propCount - 1,
&length, params);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(propCount - 1, length);
EXPECT_EQ(GL_FLOAT_VEC4, params[0]); // type
EXPECT_EQ(4, params[1]); // array_size
EXPECT_EQ(2, params[2]); // location
EXPECT_EQ(10, params[3]); // name_length
EXPECT_EQ(0, params[4]); // referenced_by_vertex_shader
EXPECT_EQ(1, params[5]); // referenced_by_fragment_shader
GLenum invalidOutputProp = GL_OFFSET;
glGetProgramResourceiv(program, GL_PROGRAM_OUTPUT, index, 1, &invalidOutputProp, 1, &length,
params);
EXPECT_GL_ERROR(GL_INVALID_OPERATION);
}
// Tests glGetProgramInterfaceiv.
TEST_P(ProgramInterfaceTestES31, GetProgramInterface)
{
// TODO(jiajia.qin@intel.com): Don't skip this test once SSBO are supported on render pipeline.
// http://anglebug.com/1951
ANGLE_SKIP_TEST_IF(IsD3D11());
constexpr char kFS[] =
"#version 310 es\n"
"precision highp float;\n"
"uniform vec4 color;\n"
"out vec4 oColor;\n"
"uniform ub {\n"
" vec4 mem0;\n"
" vec4 mem1;\n"
"} instance;\n"
"layout(std430) buffer shaderStorageBlock1 {\n"
" vec3 target;\n"
"};\n"
"layout(std430) buffer shaderStorageBlock2 {\n"
" vec3 target;\n"
"} blockInstance2[1];\n"
"void main()\n"
"{\n"
" oColor = color;\n"
" target = vec3(0, 0, 0);\n"
" blockInstance2[0].target = vec3(1, 1, 1);\n"
"}";
ANGLE_GL_PROGRAM(program, essl31_shaders::vs::Simple(), kFS);
GLint num;
glGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_ACTIVE_RESOURCES, &num);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(1, num);
glGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_MAX_NAME_LENGTH, &num);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(static_cast<GLint>(strlen(essl3_shaders::PositionAttrib())) + 1, num);
glGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_MAX_NUM_ACTIVE_VARIABLES, &num);
EXPECT_GL_ERROR(GL_INVALID_OPERATION);
glGetProgramInterfaceiv(program, GL_PROGRAM_OUTPUT, GL_ACTIVE_RESOURCES, &num);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(1, num);
glGetProgramInterfaceiv(program, GL_PROGRAM_OUTPUT, GL_MAX_NAME_LENGTH, &num);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(7, num);
glGetProgramInterfaceiv(program, GL_PROGRAM_OUTPUT, GL_MAX_NUM_ACTIVE_VARIABLES, &num);
EXPECT_GL_ERROR(GL_INVALID_OPERATION);
glGetProgramInterfaceiv(program, GL_UNIFORM_BLOCK, GL_ACTIVE_RESOURCES, &num);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(1, num);
glGetProgramInterfaceiv(program, GL_UNIFORM_BLOCK, GL_MAX_NAME_LENGTH, &num);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(3, num);
glGetProgramInterfaceiv(program, GL_UNIFORM_BLOCK, GL_MAX_NUM_ACTIVE_VARIABLES, &num);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(2, num); // mem0, mem1
glGetProgramInterfaceiv(program, GL_UNIFORM, GL_ACTIVE_RESOURCES, &num);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(3, num);
glGetProgramInterfaceiv(program, GL_UNIFORM, GL_MAX_NAME_LENGTH, &num);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(8, num); // "ub.mem0"
glGetProgramInterfaceiv(program, GL_UNIFORM, GL_MAX_NUM_ACTIVE_VARIABLES, &num);
EXPECT_GL_ERROR(GL_INVALID_OPERATION);
glGetProgramInterfaceiv(program, GL_SHADER_STORAGE_BLOCK, GL_ACTIVE_RESOURCES, &num);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(2, num);
glGetProgramInterfaceiv(program, GL_SHADER_STORAGE_BLOCK, GL_MAX_NAME_LENGTH, &num);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(23, num); // "shaderStorageBlock2[0]"
glGetProgramInterfaceiv(program, GL_SHADER_STORAGE_BLOCK, GL_MAX_NUM_ACTIVE_VARIABLES, &num);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(1, num);
}
// Tests the resource property query for uniform can be done correctly.
TEST_P(ProgramInterfaceTestES31, GetUniformProperties)
{
// TODO(jiajia.qin@intel.com): Don't skip this test once atomic counter is supported on d3d
// backend. http://anglebug.com/1729
ANGLE_SKIP_TEST_IF(IsD3D11());
constexpr char kVS[] =
"#version 310 es\n"
"precision highp float;\n"
"uniform layout(location=12) vec4 color;\n"
"layout(binding = 2, offset = 4) uniform atomic_uint foo;\n"
"void main()\n"
"{\n"
" atomicCounterIncrement(foo);\n"
"}";
constexpr char kFS[] =
"#version 310 es\n"
"precision highp float;\n"
"uniform vec4 color;\n"
"out vec4 oColor;\n"
"void main()\n"
"{\n"
" oColor = color;\n"
"}";
ANGLE_GL_PROGRAM(program, kVS, kFS);
GLuint index = glGetProgramResourceIndex(program, GL_UNIFORM, "color");
EXPECT_GL_NO_ERROR();
EXPECT_NE(GL_INVALID_INDEX, index);
GLchar name[64];
GLsizei length;
glGetProgramResourceName(program, GL_UNIFORM, index, sizeof(name), &length, name);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(5, length);
EXPECT_EQ("color", std::string(name));
GLint location = glGetProgramResourceLocation(program, GL_UNIFORM, "color");
EXPECT_GL_NO_ERROR();
EXPECT_EQ(12, location);
GLenum props[] = {GL_TYPE,
GL_ARRAY_SIZE,
GL_LOCATION,
GL_NAME_LENGTH,
GL_REFERENCED_BY_VERTEX_SHADER,
GL_REFERENCED_BY_FRAGMENT_SHADER,
GL_REFERENCED_BY_COMPUTE_SHADER,
GL_ARRAY_STRIDE,
GL_BLOCK_INDEX,
GL_IS_ROW_MAJOR,
GL_MATRIX_STRIDE,
GL_OFFSET,
GL_ATOMIC_COUNTER_BUFFER_INDEX};
GLsizei propCount = static_cast<GLsizei>(ArraySize(props));
GLint params[ArraySize(props)];
glGetProgramResourceiv(program, GL_UNIFORM, index, propCount, props, propCount, &length,
params);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(propCount, length);
EXPECT_EQ(GL_FLOAT_VEC4, params[0]); // type
EXPECT_EQ(1, params[1]); // array_size
EXPECT_EQ(12, params[2]); // location
EXPECT_EQ(6, params[3]); // name_length
EXPECT_EQ(0, params[4]); // referenced_by_vertex_shader
EXPECT_EQ(1, params[5]); // referenced_by_fragment_shader
EXPECT_EQ(0, params[6]); // referenced_by_compute_shader
EXPECT_EQ(-1, params[7]); // array_stride
EXPECT_EQ(-1, params[8]); // block_index
EXPECT_EQ(0, params[9]); // is_row_major
EXPECT_EQ(-1, params[10]); // matrix_stride
EXPECT_EQ(-1, params[11]); // offset
EXPECT_EQ(-1, params[12]); // atomic_counter_buffer_index
index = glGetProgramResourceIndex(program, GL_UNIFORM, "foo");
EXPECT_GL_NO_ERROR();
EXPECT_NE(GL_INVALID_INDEX, index);
glGetProgramResourceName(program, GL_UNIFORM, index, sizeof(name), &length, name);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(3, length);
EXPECT_EQ("foo", std::string(name));
location = glGetProgramResourceLocation(program, GL_UNIFORM, "foo");
EXPECT_GL_NO_ERROR();
EXPECT_EQ(-1, location);
glGetProgramResourceiv(program, GL_UNIFORM, index, propCount, props, propCount, &length,
params);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(propCount, length);
EXPECT_EQ(GL_UNSIGNED_INT_ATOMIC_COUNTER, params[0]); // type
EXPECT_EQ(1, params[1]); // array_size
EXPECT_EQ(-1, params[2]); // location
EXPECT_EQ(4, params[3]); // name_length
EXPECT_EQ(1, params[4]); // referenced_by_vertex_shader
EXPECT_EQ(0, params[5]); // referenced_by_fragment_shader
EXPECT_EQ(0, params[6]); // referenced_by_compute_shader
EXPECT_EQ(0, params[7]); // array_stride
EXPECT_EQ(-1, params[8]); // block_index
EXPECT_EQ(0, params[9]); // is_row_major
EXPECT_EQ(0, params[10]); // matrix_stride
EXPECT_EQ(4, params[11]); // offset
EXPECT_NE(-1, params[12]); // atomic_counter_buffer_index
}
// Tests the resource property query for uniform block can be done correctly.
TEST_P(ProgramInterfaceTestES31, GetUniformBlockProperties)
{
constexpr char kVS[] =
"#version 310 es\n"
"in vec2 position;\n"
"out vec2 v;\n"
"layout(binding = 2) uniform blockName {\n"
" float f1;\n"
" float f2;\n"
"} instanceName;\n"
"void main() {\n"
" v = vec2(instanceName.f1, instanceName.f2);\n"
" gl_Position = vec4(position, 0, 1);\n"
"}";
constexpr char kFS[] =
"#version 310 es\n"
"precision highp float;\n"
"in vec2 v;\n"
"out vec4 color;\n"
"void main() {\n"
" color = vec4(v, 0, 1);\n"
"}";
ANGLE_GL_PROGRAM(program, kVS, kFS);
GLuint index = glGetProgramResourceIndex(program, GL_UNIFORM_BLOCK, "blockName");
EXPECT_GL_NO_ERROR();
EXPECT_NE(GL_INVALID_INDEX, index);
GLchar name[64];
GLsizei length;
glGetProgramResourceName(program, GL_UNIFORM_BLOCK, index, sizeof(name), &length, name);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(9, length);
EXPECT_EQ("blockName", std::string(name));
GLenum props[] = {GL_BUFFER_BINDING,
GL_BUFFER_DATA_SIZE,
GL_NAME_LENGTH,
GL_NUM_ACTIVE_VARIABLES,
GL_ACTIVE_VARIABLES,
GL_REFERENCED_BY_VERTEX_SHADER,
GL_REFERENCED_BY_FRAGMENT_SHADER,
GL_REFERENCED_BY_COMPUTE_SHADER};
GLsizei propCount = static_cast<GLsizei>(ArraySize(props));
constexpr int kBufSize = 256;
GLint params[kBufSize];
GLint magic = 0xBEEF;
// Tests bufSize is respected even some prop returns more than one value.
params[propCount] = magic;
glGetProgramResourceiv(program, GL_UNIFORM_BLOCK, index, propCount, props, propCount, &length,
params);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(propCount, length);
EXPECT_EQ(2, params[0]); // buffer_binding
EXPECT_NE(0, params[1]); // buffer_data_size
EXPECT_EQ(10, params[2]); // name_length
EXPECT_EQ(2, params[3]); // num_active_variables
EXPECT_LE(0, params[4]); // index of 'f1' or 'f2'
EXPECT_LE(0, params[5]); // index of 'f1' or 'f2'
EXPECT_EQ(1, params[6]); // referenced_by_vertex_shader
EXPECT_EQ(0, params[7]); // referenced_by_fragment_shader
EXPECT_EQ(magic, params[8]);
glGetProgramResourceiv(program, GL_UNIFORM_BLOCK, index, propCount, props, kBufSize, &length,
params);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(propCount + 1, length);
EXPECT_EQ(0, params[8]); // referenced_by_compute_shader
// bufSize is reached in middle of outputting values for GL_ACTIVE_VARIABLES.
GLenum actvieVariablesProperty = GL_ACTIVE_VARIABLES;
params[1] = magic;
glGetProgramResourceiv(program, GL_UNIFORM_BLOCK, index, 1, &actvieVariablesProperty, 1,
&length, params);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(1, length);
EXPECT_LE(0, params[0]); // index of 'f1' or 'f2'
EXPECT_EQ(magic, params[1]);
}
// Tests atomic counter buffer qeury works correctly.
TEST_P(ProgramInterfaceTestES31, QueryAtomicCounteBuffer)
{
// TODO(jiajia.qin@intel.com): Don't skip this test once atomic counter is supported on d3d
// backend. http://anglebug.com/1729
ANGLE_SKIP_TEST_IF(IsD3D11());
constexpr char kVS[] =
"#version 310 es\n"
"precision highp float;\n"
"layout(binding = 2, offset = 0) uniform atomic_uint vcounter;\n"
"in highp vec4 a_position;\n"
"void main()\n"
"{\n"
" atomicCounterIncrement(vcounter);\n"
" gl_Position = a_position;\n"
"}\n";
constexpr char kFS[] =
"#version 310 es\n"
"precision highp float;\n"
"layout(binding = 2, offset = 4) uniform atomic_uint fcounter;\n"
"out highp vec4 my_color;\n"
"void main()\n"
"{\n"
" atomicCounterDecrement(fcounter);\n"
" my_color = vec4(0.0);\n"
"}\n";
ANGLE_GL_PROGRAM(program, kVS, kFS);
GLint num;
glGetProgramInterfaceiv(program, GL_ATOMIC_COUNTER_BUFFER, GL_ACTIVE_RESOURCES, &num);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(1, num);
glGetProgramInterfaceiv(program, GL_ATOMIC_COUNTER_BUFFER, GL_MAX_NUM_ACTIVE_VARIABLES, &num);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(2, num);
GLenum props[] = {GL_BUFFER_BINDING, GL_NUM_ACTIVE_VARIABLES, GL_REFERENCED_BY_VERTEX_SHADER,
GL_REFERENCED_BY_FRAGMENT_SHADER, GL_REFERENCED_BY_COMPUTE_SHADER};
GLsizei propCount = static_cast<GLsizei>(ArraySize(props));
GLint params[ArraySize(props)];
GLsizei length = 0;
glGetProgramResourceiv(program, GL_ATOMIC_COUNTER_BUFFER, 0, propCount, props, propCount,
&length, params);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(propCount, length);
EXPECT_EQ(2, params[0]); // buffer_binding
EXPECT_EQ(2, params[1]); // num_active_variables
EXPECT_EQ(1, params[2]); // referenced_by_vertex_shader
EXPECT_EQ(1, params[3]); // referenced_by_fragment_shader
EXPECT_EQ(0, params[4]); // referenced_by_compute_shader
}
// Tests the resource property query for buffer variable can be done correctly.
TEST_P(ProgramInterfaceTestES31, GetBufferVariableProperties)
{
// TODO(jiajia.qin@intel.com): Don't skip this test once non-simple SSBO sentences are supported
// on d3d backend. http://anglebug.com/1951
ANGLE_SKIP_TEST_IF(IsD3D11());
// Check SSBO support
GLint numSupported;
glGetIntegerv(GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS, &numSupported);
EXPECT_GL_NO_ERROR();
ANGLE_SKIP_TEST_IF(numSupported < 2);
constexpr char kVS[] =
"#version 310 es\n"
"precision highp float;\n"
"struct S {\n"
" vec3 a;\n"
" ivec2 b[4];\n"
"};\n"
"layout(std140) buffer blockName0 {\n"
" S s0;\n"
" vec2 v0;\n"
" S s1[2];\n"
" uint u0;\n"
"};\n"
"layout(binding = 1) buffer blockName1 {\n"
" uint u1[2];\n"
" float f1;\n"
"} instanceName1[2];\n"
"void main()\n"
"{\n"
" gl_Position = vec4(instanceName1[0].f1, s1[0].a);\n"
"}\n";
constexpr char kFS[] =
"#version 310 es\n"
"precision highp float;\n"
"layout(binding = 1) buffer blockName1 {\n"
" uint u1[2];\n"
" float f1;\n"
"} instanceName1[2];\n"
"out vec4 oColor;\n"
"void main()\n"
"{\n"
" oColor = vec4(instanceName1[0].f1, 0, 0, 1);\n"
"}";
ANGLE_GL_PROGRAM(program, kVS, kFS);
GLuint index = glGetProgramResourceIndex(program, GL_BUFFER_VARIABLE, "blockName1.f1");
EXPECT_GL_NO_ERROR();
EXPECT_NE(GL_INVALID_INDEX, index);
GLchar name[64];
GLsizei length;
glGetProgramResourceName(program, GL_BUFFER_VARIABLE, index, sizeof(name), &length, name);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(13, length);
EXPECT_EQ("blockName1.f1", std::string(name));
GLenum props[] = {GL_ARRAY_SIZE,
GL_ARRAY_STRIDE,
GL_BLOCK_INDEX,
GL_IS_ROW_MAJOR,
GL_MATRIX_STRIDE,
GL_NAME_LENGTH,
GL_OFFSET,
GL_REFERENCED_BY_VERTEX_SHADER,
GL_REFERENCED_BY_FRAGMENT_SHADER,
GL_REFERENCED_BY_COMPUTE_SHADER,
GL_TOP_LEVEL_ARRAY_SIZE,
GL_TOP_LEVEL_ARRAY_STRIDE,
GL_TYPE};
GLsizei propCount = static_cast<GLsizei>(ArraySize(props));
constexpr int kBufSize = 256;
GLint params[kBufSize];
glGetProgramResourceiv(program, GL_BUFFER_VARIABLE, index, propCount, props, kBufSize, &length,
params);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(propCount, length);
EXPECT_EQ(1, params[0]); // array_size
EXPECT_LE(0, params[1]); // array_stride
EXPECT_LE(0, params[2]); // block_index
EXPECT_EQ(0, params[3]); // is_row_major
EXPECT_EQ(0, params[4]); // matrix_stride
EXPECT_EQ(14, params[5]); // name_length
EXPECT_LE(0, params[6]); // offset
EXPECT_EQ(1, params[7]); // referenced_by_vertex_shader
EXPECT_EQ(1, params[8]); // referenced_by_fragment_shader
EXPECT_EQ(0, params[9]); // referenced_by_compute_shader
EXPECT_EQ(1, params[10]); // top_level_array_size
EXPECT_LE(0, params[11]); // top_level_array_stride
EXPECT_EQ(GL_FLOAT, params[12]); // type
index = glGetProgramResourceIndex(program, GL_BUFFER_VARIABLE, "s1[0].a");
EXPECT_GL_NO_ERROR();
EXPECT_NE(GL_INVALID_INDEX, index);
glGetProgramResourceName(program, GL_BUFFER_VARIABLE, index, sizeof(name), &length, name);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(7, length);
EXPECT_EQ("s1[0].a", std::string(name));
glGetProgramResourceiv(program, GL_BUFFER_VARIABLE, index, propCount, props, kBufSize, &length,
params);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(propCount, length);
EXPECT_EQ(1, params[0]); // array_size
EXPECT_LE(0, params[1]); // array_stride
EXPECT_LE(0, params[2]); // block_index
EXPECT_EQ(0, params[3]); // is_row_major
EXPECT_EQ(0, params[4]); // matrix_stride
EXPECT_EQ(8, params[5]); // name_length
EXPECT_LE(0, params[6]); // offset
EXPECT_EQ(1, params[7]); // referenced_by_vertex_shader
EXPECT_EQ(0, params[8]); // referenced_by_fragment_shader
EXPECT_EQ(0, params[9]); // referenced_by_compute_shader
EXPECT_EQ(2, params[10]); // top_level_array_size
EXPECT_EQ(80, params[11]); // top_level_array_stride
EXPECT_EQ(GL_FLOAT_VEC3, params[12]); // type
}
// Tests the resource property querying for buffer variable in std430 SSBO works correctly.
TEST_P(ProgramInterfaceTestES31, GetStd430BufferVariableProperties)
{
ANGLE_SKIP_TEST_IF(IsAMD() && IsWindows() && IsOpenGL());
constexpr char kComputeShaderSource[] =
R"(#version 310 es
layout(local_size_x=1, local_size_y=1, local_size_z=1) in;
struct S
{
uvec2 v;
mat2 m;
};
layout(std430, binding = 0) buffer blockIn {
uint u;
uint a[2];
S s;
} instanceIn;
layout(std430, binding = 1) buffer blockOut {
uint u;
uint a[2];
S s;
} instanceOut;
void main()
{
instanceOut.u = instanceIn.u;
instanceOut.a[0] = instanceIn.a[0];
instanceOut.a[1] = instanceIn.a[1];
instanceOut.s.v = instanceIn.s.v;
instanceOut.s.m = instanceIn.s.m;
}
)";
ANGLE_GL_COMPUTE_PROGRAM(program, kComputeShaderSource);
GLuint index = glGetProgramResourceIndex(program, GL_BUFFER_VARIABLE, "blockIn.a");
EXPECT_GL_NO_ERROR();
EXPECT_NE(GL_INVALID_INDEX, index);
GLchar name[64];
GLsizei length;
glGetProgramResourceName(program, GL_BUFFER_VARIABLE, index, sizeof(name), &length, name);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(12, length);
EXPECT_EQ("blockIn.a[0]", std::string(name));
GLenum props[] = {GL_ARRAY_SIZE,
GL_ARRAY_STRIDE,
GL_BLOCK_INDEX,
GL_IS_ROW_MAJOR,
GL_MATRIX_STRIDE,
GL_NAME_LENGTH,
GL_OFFSET,
GL_REFERENCED_BY_VERTEX_SHADER,
GL_REFERENCED_BY_FRAGMENT_SHADER,
GL_REFERENCED_BY_COMPUTE_SHADER,
GL_TOP_LEVEL_ARRAY_SIZE,
GL_TOP_LEVEL_ARRAY_STRIDE,
GL_TYPE};
GLsizei propCount = static_cast<GLsizei>(ArraySize(props));
constexpr int kBufSize = 256;
GLint params[kBufSize];
glGetProgramResourceiv(program, GL_BUFFER_VARIABLE, index, propCount, props, kBufSize, &length,
params);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(propCount, length);
EXPECT_EQ(2, params[0]); // array_size
EXPECT_LE(4, params[1]); // array_stride
EXPECT_LE(0, params[2]); // block_index
EXPECT_EQ(0, params[3]); // is_row_major
EXPECT_EQ(0, params[4]); // matrix_stride
EXPECT_EQ(13, params[5]); // name_length
EXPECT_EQ(4, params[6]); // offset
EXPECT_EQ(0, params[7]); // referenced_by_vertex_shader
EXPECT_EQ(0, params[8]); // referenced_by_fragment_shader
EXPECT_EQ(1, params[9]); // referenced_by_compute_shader
EXPECT_EQ(1, params[10]); // top_level_array_size
EXPECT_EQ(0, params[11]); // top_level_array_stride
EXPECT_EQ(GL_UNSIGNED_INT, params[12]); // type
index = glGetProgramResourceIndex(program, GL_BUFFER_VARIABLE, "blockIn.s.m");
EXPECT_GL_NO_ERROR();
EXPECT_NE(GL_INVALID_INDEX, index);
glGetProgramResourceName(program, GL_BUFFER_VARIABLE, index, sizeof(name), &length, name);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(11, length);
EXPECT_EQ("blockIn.s.m", std::string(name));
glGetProgramResourceiv(program, GL_BUFFER_VARIABLE, index, propCount, props, kBufSize, &length,
params);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(propCount, length);
EXPECT_EQ(1, params[0]); // array_size
EXPECT_LE(0, params[1]); // array_stride
EXPECT_LE(0, params[2]); // block_index
EXPECT_EQ(0, params[3]); // is_row_major
EXPECT_EQ(8, params[4]); // matrix_stride
EXPECT_EQ(12, params[5]); // name_length
EXPECT_EQ(24, params[6]); // offset
EXPECT_EQ(0, params[7]); // referenced_by_vertex_shader
EXPECT_EQ(0, params[8]); // referenced_by_fragment_shader
// TODO(jiajia.qin@intel.com): referenced_by_compute_shader is not
// correctly handled. http://anglebug.com/1920.
// EXPECT_EQ(1, params[9]); // referenced_by_compute_shader
EXPECT_EQ(1, params[10]); // top_level_array_size
EXPECT_EQ(0, params[11]); // top_level_array_stride
EXPECT_EQ(GL_FLOAT_MAT2, params[12]); // type
}
// Test that TOP_LEVEL_ARRAY_STRIDE for buffer variable with aggregate type works correctly.
TEST_P(ProgramInterfaceTestES31, TopLevelArrayStrideWithAggregateType)
{
constexpr char kComputeShaderSource[] =
R"(#version 310 es
layout(local_size_x=1, local_size_y=1, local_size_z=1) in;
struct S
{
uvec2 v;
mat2 m;
};
layout(std430, binding = 0) buffer blockIn {
uint u;
uint a[2];
S s;
} instanceIn;
layout(std430, binding = 1) buffer blockOut {
uint u;
uint a[4][3];
S s[3][2];
} instanceOut;
void main()
{
instanceOut.u = instanceIn.u;
instanceOut.a[0][0] = instanceIn.a[0];
instanceOut.a[0][1] = instanceIn.a[1];
instanceOut.s[0][0].v = instanceIn.s.v;
instanceOut.s[0][0].m = instanceIn.s.m;
}
)";
ANGLE_GL_COMPUTE_PROGRAM(program, kComputeShaderSource);
GLuint index = glGetProgramResourceIndex(program, GL_BUFFER_VARIABLE, "blockOut.s[0][0].m");
EXPECT_GL_NO_ERROR();
EXPECT_NE(GL_INVALID_INDEX, index);
GLchar name[64];
GLsizei length;
glGetProgramResourceName(program, GL_BUFFER_VARIABLE, index, sizeof(name), &length, name);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(18, length);
EXPECT_EQ("blockOut.s[0][0].m", std::string(name));
GLenum props[] = {GL_ARRAY_SIZE,
GL_ARRAY_STRIDE,
GL_BLOCK_INDEX,
GL_IS_ROW_MAJOR,
GL_MATRIX_STRIDE,
GL_NAME_LENGTH,
GL_OFFSET,
GL_REFERENCED_BY_VERTEX_SHADER,
GL_REFERENCED_BY_FRAGMENT_SHADER,
GL_REFERENCED_BY_COMPUTE_SHADER,
GL_TOP_LEVEL_ARRAY_SIZE,
GL_TOP_LEVEL_ARRAY_STRIDE,
GL_TYPE};
GLsizei propCount = static_cast<GLsizei>(ArraySize(props));
constexpr int kBufSize = 256;
GLint params[kBufSize];
glGetProgramResourceiv(program, GL_BUFFER_VARIABLE, index, propCount, props, kBufSize, &length,
params);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(propCount, length);
EXPECT_EQ(1, params[0]); // array_size
EXPECT_LE(0, params[1]); // array_stride
EXPECT_LE(0, params[2]); // block_index
EXPECT_EQ(0, params[3]); // is_row_major
EXPECT_EQ(8, params[4]); // matrix_stride
EXPECT_EQ(19, params[5]); // name_length
EXPECT_EQ(64, params[6]); // offset
EXPECT_EQ(0, params[7]); // referenced_by_vertex_shader
EXPECT_EQ(0, params[8]); // referenced_by_fragment_shader
// TODO(jiajia.qin@intel.com): referenced_by_compute_shader is not
// correctly handled. http://anglebug.com/1920.
// EXPECT_EQ(1, params[9]); // referenced_by_compute_shader
EXPECT_EQ(3, params[10]); // top_level_array_size
EXPECT_EQ(48, params[11]); // top_level_array_stride
EXPECT_EQ(GL_FLOAT_MAT2, params[12]); // type
index = glGetProgramResourceIndex(program, GL_BUFFER_VARIABLE, "blockOut.a[0][0]");
EXPECT_GL_NO_ERROR();
EXPECT_NE(GL_INVALID_INDEX, index);
glGetProgramResourceName(program, GL_BUFFER_VARIABLE, index, sizeof(name), &length, name);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(16, length);
EXPECT_EQ("blockOut.a[0][0]", std::string(name));
glGetProgramResourceiv(program, GL_BUFFER_VARIABLE, index, propCount, props, kBufSize, &length,
params);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(propCount, length);
EXPECT_EQ(3, params[0]); // array_size
EXPECT_LE(0, params[1]); // array_stride
EXPECT_LE(0, params[2]); // block_index
EXPECT_EQ(0, params[3]); // is_row_major
EXPECT_EQ(0, params[4]); // matrix_stride
EXPECT_EQ(17, params[5]); // name_length
EXPECT_EQ(4, params[6]); // offset
EXPECT_EQ(0, params[7]); // referenced_by_vertex_shader
EXPECT_EQ(0, params[8]); // referenced_by_fragment_shader
EXPECT_EQ(1, params[9]); // referenced_by_compute_shader
EXPECT_EQ(4, params[10]); // top_level_array_size
EXPECT_EQ(12, params[11]); // top_level_array_stride
EXPECT_EQ(GL_UNSIGNED_INT, params[12]); // type
}
// Tests the resource property query for shader storage block can be done correctly.
TEST_P(ProgramInterfaceTestES31, GetShaderStorageBlockProperties)
{
// TODO(jiajia.qin@intel.com): Don't skip this test once non-simple SSBO sentences are supported
// on d3d backend. http://anglebug.com/1951
ANGLE_SKIP_TEST_IF(IsD3D11());
// Check SSBO support
GLint numSupported;
glGetIntegerv(GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS, &numSupported);
EXPECT_GL_NO_ERROR();
ANGLE_SKIP_TEST_IF(numSupported < 3);
constexpr char kVS[] =
"#version 310 es\n"
"precision highp float;\n"
"struct S {\n"
" vec3 a;\n"
" ivec2 b[4];\n"
"};\n"
"layout(std140) buffer blockName0 {\n"
" S s0;\n"
" vec2 v0;\n"
" S s1[2];\n"
" uint u0;\n"
"};\n"
"layout(binding = 1) buffer blockName1 {\n"
" uint u1[2];\n"
" float f1;\n"
"} instanceName1[2];\n"
"layout(binding = 2) buffer blockName2 {\n"
" uint u2;\n"
" float f2;\n"
"};\n"
"void main()\n"
"{\n"
" gl_Position = vec4(instanceName1[0].f1, s1[0].a);\n"
"}\n";
constexpr char kFS[] =
"#version 310 es\n"
"precision highp float;\n"
"uniform vec4 color;\n"
"out vec4 oColor;\n"
"void main()\n"
"{\n"
" oColor = color;\n"
"}";
ANGLE_GL_PROGRAM(program, kVS, kFS);
GLuint index = glGetProgramResourceIndex(program, GL_SHADER_STORAGE_BLOCK, "blockName0");
EXPECT_GL_NO_ERROR();
EXPECT_NE(GL_INVALID_INDEX, index);
GLchar name[64];
GLsizei length;
glGetProgramResourceName(program, GL_SHADER_STORAGE_BLOCK, index, sizeof(name), &length, name);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(10, length);
EXPECT_EQ("blockName0", std::string(name));
GLenum props[] = {GL_ACTIVE_VARIABLES,
GL_BUFFER_BINDING,
GL_NUM_ACTIVE_VARIABLES,
GL_BUFFER_DATA_SIZE,
GL_NAME_LENGTH,
GL_REFERENCED_BY_VERTEX_SHADER,
GL_REFERENCED_BY_FRAGMENT_SHADER,
GL_REFERENCED_BY_COMPUTE_SHADER};
GLsizei propCount = static_cast<GLsizei>(ArraySize(props));
constexpr int kBufSize = 256;
GLint params[kBufSize];
glGetProgramResourceiv(program, GL_SHADER_STORAGE_BLOCK, index, propCount, props, kBufSize,
&length, params);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(13, length);
EXPECT_LE(0, params[0]); // active_variables s0.a
EXPECT_LE(0, params[1]); // active_variables s0.b
EXPECT_LE(0, params[2]); // active_variables v0
EXPECT_LE(0, params[3]); // active_variables s1[0].a
EXPECT_LE(0, params[4]); // active_variables s1[0].b
EXPECT_LE(0, params[5]); // active_variables u0
EXPECT_EQ(0, params[6]); // buffer_binding
EXPECT_EQ(6, params[7]); // num_active_variables
EXPECT_LE(0, params[8]); // buffer_data_size
EXPECT_EQ(11, params[9]); // name_length
EXPECT_EQ(1, params[10]); // referenced_by_vertex_shader
EXPECT_EQ(0, params[11]); // referenced_by_fragment_shader
EXPECT_EQ(0, params[12]); // referenced_by_compute_shader
index = glGetProgramResourceIndex(program, GL_SHADER_STORAGE_BLOCK, "blockName1");
EXPECT_GL_NO_ERROR();
EXPECT_NE(GL_INVALID_INDEX, index);
glGetProgramResourceName(program, GL_SHADER_STORAGE_BLOCK, index, sizeof(name), &length, name);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(13, length);
EXPECT_EQ("blockName1[0]", std::string(name));
}
// Tests querying the program resources of atomic counter buffers.
TEST_P(ProgramInterfaceTestES31, GetAtomicCounterProperties)
{
constexpr char kCSSource[] = R"(#version 310 es
layout(local_size_x=1, local_size_y=1, local_size_z=1) in;
layout(binding = 0) uniform atomic_uint acbase;
layout(binding = 0, offset = 8) uniform atomic_uint ac[1];
layout(binding = 0) uniform atomic_uint ac2;
void main()
{
atomicCounter(acbase);
atomicCounter(ac[0]);
atomicCounter(ac2);
})";
ANGLE_GL_COMPUTE_PROGRAM(program, kCSSource);
GLuint index = glGetProgramResourceIndex(program, GL_UNIFORM, "ac");
EXPECT_GL_NO_ERROR();
EXPECT_NE(GL_INVALID_INDEX, index);
GLenum props[] = {GL_ATOMIC_COUNTER_BUFFER_INDEX};
GLsizei propCount = static_cast<GLsizei>(ArraySize(props));
GLint atomicIndex;
GLsizei length;
glGetProgramResourceiv(program, GL_UNIFORM, index, propCount, props, 1, &length, &atomicIndex);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(1, length);
EXPECT_LE(0, atomicIndex);
GLenum atomicProps[] = {GL_ACTIVE_VARIABLES,
GL_BUFFER_BINDING,
GL_NUM_ACTIVE_VARIABLES,
GL_BUFFER_DATA_SIZE,
GL_REFERENCED_BY_VERTEX_SHADER,
GL_REFERENCED_BY_FRAGMENT_SHADER,
GL_REFERENCED_BY_COMPUTE_SHADER};
GLsizei atomicPropsCount = static_cast<GLsizei>(ArraySize(atomicProps));
constexpr int kBufSize = 256;
GLint params[kBufSize];
GLsizei length2;
glGetProgramResourceiv(program, GL_ATOMIC_COUNTER_BUFFER, atomicIndex, atomicPropsCount,
atomicProps, kBufSize, &length2, params);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(9, length2);
EXPECT_LE(0, params[0]); // active_variables acbase
EXPECT_LE(0, params[1]); // active_variables ac[1]
EXPECT_LE(0, params[2]); // active_variables ac2
EXPECT_EQ(0, params[3]); // buffer_binding
EXPECT_EQ(3, params[4]); // num_active_variables
EXPECT_EQ(16, params[5]); // buffer_data_size
EXPECT_EQ(0, params[6]); // referenced_by_vertex_shader
EXPECT_EQ(0, params[7]); // referenced_by_fragment_shader
EXPECT_EQ(1, params[8]); // referenced_by_compute_shader
}
// Tests transform feedback varying qeury works correctly.
TEST_P(ProgramInterfaceTestES31, QueryTransformFeedbackVarying)
{
constexpr char kVS[] = R"(#version 310 es
in vec3 position;
out float outSingleType;
out vec2 outWholeArray[2];
out vec3 outArrayElements[16];
void main() {
outSingleType = 0.0;
outWholeArray[0] = vec2(position);
outArrayElements[7] = vec3(0, 0, 0);
outArrayElements[15] = position;
gl_Position = vec4(position, 1);
})";
constexpr char kFS[] = R"(#version 310 es
precision mediump float;
out vec4 color;
in float outSingleType;
in vec2 outWholeArray[2];
in vec3 outArrayElements[16];
void main() {
color = vec4(0);
})";
std::vector<std::string> tfVaryings;
tfVaryings.push_back("outArrayElements[7]");
tfVaryings.push_back("outArrayElements[15]");
tfVaryings.push_back("outSingleType");
tfVaryings.push_back("outWholeArray");
GLuint program =
CompileProgramWithTransformFeedback(kVS, kFS, tfVaryings, GL_INTERLEAVED_ATTRIBS);
ASSERT_NE(0u, program);
GLint num;
glGetProgramInterfaceiv(program, GL_TRANSFORM_FEEDBACK_VARYING, GL_ACTIVE_RESOURCES, &num);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(4, num);
glGetProgramInterfaceiv(program, GL_TRANSFORM_FEEDBACK_VARYING, GL_MAX_NAME_LENGTH, &num);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(21, num); // outArrayElements[15]
// GLES 3.10, Page 77:
// For TRANSFORM_FEEDBACK_VARYING, the active resource list will use the variable order
// specified in the most recent call to TransformFeedbackVaryings before the last call to
// LinkProgram.
GLuint index =
glGetProgramResourceIndex(program, GL_TRANSFORM_FEEDBACK_VARYING, "outArrayElements[7]");
EXPECT_GL_NO_ERROR();
EXPECT_EQ(0u, index);
index =
glGetProgramResourceIndex(program, GL_TRANSFORM_FEEDBACK_VARYING, "outArrayElements[15]");
EXPECT_GL_NO_ERROR();
EXPECT_EQ(1u, index);
index = glGetProgramResourceIndex(program, GL_TRANSFORM_FEEDBACK_VARYING, "outSingleType");
EXPECT_GL_NO_ERROR();
EXPECT_EQ(2u, index);
index = glGetProgramResourceIndex(program, GL_TRANSFORM_FEEDBACK_VARYING, "outWholeArray");
EXPECT_GL_NO_ERROR();
EXPECT_EQ(3u, index);
// GLES 3.10, Page 80:
// For TRANSFORM_FEEDBACK_VARYING resources, name must match one of the variables to be captured
// as specified by a previous call to TransformFeedbackVaryings. Otherwise, INVALID_INDEX is
// returned.
// If name does not match a resource as described above, the value INVALID_INDEX is returned,
// but no GL error is generated.
index = glGetProgramResourceIndex(program, GL_TRANSFORM_FEEDBACK_VARYING, "outWholeArray[0]");
EXPECT_GL_NO_ERROR();
EXPECT_EQ(GL_INVALID_INDEX, index);
GLenum props[] = {GL_TYPE, GL_ARRAY_SIZE, GL_NAME_LENGTH};
GLsizei propCount = static_cast<GLsizei>(ArraySize(props));
GLint params[ArraySize(props)];
GLsizei length = 0;
// Query properties of 'outArrayElements[15]'.
glGetProgramResourceiv(program, GL_TRANSFORM_FEEDBACK_VARYING, 1, propCount, props, propCount,
&length, params);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(propCount, length);
EXPECT_EQ(GL_FLOAT_VEC3, params[0]); // type
EXPECT_EQ(1, params[1]); // array_size
EXPECT_EQ(21, params[2]); // name_length
// Query properties of 'outWholeArray'.
glGetProgramResourceiv(program, GL_TRANSFORM_FEEDBACK_VARYING, 3, propCount, props, propCount,
&length, params);
EXPECT_GL_NO_ERROR();
EXPECT_EQ(propCount, length);
EXPECT_EQ(GL_FLOAT_VEC2, params[0]); // type
EXPECT_EQ(2, params[1]); // array_size
EXPECT_EQ(14, params[2]); // name_length
glDeleteProgram(program);
}
ANGLE_INSTANTIATE_TEST_ES31(ProgramInterfaceTestES31);
} // anonymous namespace