Google Git
Sign in
android / platform / external / angle / HEAD / . / src / tests / gl_tests / ClipDistanceTest.cpp
blob: 071adbc6e71d3cdc00c5ac17a2c69d50ff8ad6ba [file] [log] [blame]
//
// Copyright 2020 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.
//
// ClipDistanceTest.cpp: Test cases for
// GL_APPLE_clip_distance / GL_EXT_clip_cull_distance / GL_ANGLE_clip_cull_distance extensions.
//
#include "test_utils/ANGLETest.h"
#include "test_utils/gl_raii.h"
#include "util/EGLWindow.h"
#include "util/test_utils.h"
using namespace angle;
class ClipDistanceAPPLETest : public ANGLETest<>
{
protected:
ClipDistanceAPPLETest()
{
setWindowWidth(64);
setWindowHeight(64);
setConfigRedBits(8);
setConfigGreenBits(8);
setConfigBlueBits(8);
setConfigAlphaBits(8);
setConfigDepthBits(24);
setExtensionsEnabled(false);
}
};
// Query max clip distances and enable, disable states of clip distances
TEST_P(ClipDistanceAPPLETest, StateQuery)
{
GLint maxClipDistances = 0;
glGetIntegerv(GL_MAX_CLIP_DISTANCES_APPLE, &maxClipDistances);
EXPECT_EQ(maxClipDistances, 0);
EXPECT_GL_ERROR(GL_INVALID_ENUM);
auto assertState = [](GLenum pname, bool valid, bool expectedState) {
EXPECT_EQ(glIsEnabled(pname), valid ? expectedState : false);
EXPECT_GL_ERROR(valid ? GL_NO_ERROR : GL_INVALID_ENUM);
GLboolean result = false;
glGetBooleanv(pname, &result);
EXPECT_EQ(result, valid ? expectedState : false);
EXPECT_GL_ERROR(valid ? GL_NO_ERROR : GL_INVALID_ENUM);
};
for (size_t i = 0; i < 8; i++)
{
assertState(GL_CLIP_DISTANCE0_APPLE + i, false, false);
glEnable(GL_CLIP_DISTANCE0_APPLE + i);
EXPECT_GL_ERROR(GL_INVALID_ENUM);
assertState(GL_CLIP_DISTANCE0_APPLE + i, false, false);
glDisable(GL_CLIP_DISTANCE0_APPLE + i);
EXPECT_GL_ERROR(GL_INVALID_ENUM);
assertState(GL_CLIP_DISTANCE0_APPLE + i, false, false);
}
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_APPLE_clip_distance"));
ASSERT_GL_NO_ERROR();
glGetIntegerv(GL_MAX_CLIP_DISTANCES_APPLE, &maxClipDistances);
EXPECT_EQ(maxClipDistances, 8);
EXPECT_GL_NO_ERROR();
for (size_t i = 0; i < 8; i++)
{
assertState(GL_CLIP_DISTANCE0_APPLE + i, true, false);
glEnable(GL_CLIP_DISTANCE0_APPLE + i);
EXPECT_GL_NO_ERROR();
assertState(GL_CLIP_DISTANCE0_APPLE + i, true, true);
glDisable(GL_CLIP_DISTANCE0_APPLE + i);
EXPECT_GL_NO_ERROR();
assertState(GL_CLIP_DISTANCE0_APPLE + i, true, false);
}
}
// Check that gl_ClipDistance is not defined for fragment shaders
TEST_P(ClipDistanceAPPLETest, FragmentShader)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_APPLE_clip_distance"));
constexpr char kVS[] = R"(
#extension GL_APPLE_clip_distance : require
void main()
{
gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
gl_ClipDistance[0] = gl_Position.w;
})";
constexpr char kFS[] = R"(
#extension GL_APPLE_clip_distance : require
void main()
{
gl_FragColor = vec4(gl_ClipDistance[0], 1.0, 1.0, 1.0);
})";
GLProgram prg;
prg.makeRaster(kVS, kFS);
EXPECT_FALSE(prg.valid());
}
// Check that gl_ClipDistance cannot be redeclared as a global
TEST_P(ClipDistanceAPPLETest, NotVarying)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_APPLE_clip_distance"));
constexpr char kVS[] = R"(
#extension GL_APPLE_clip_distance : require
highp float gl_ClipDistance[1];
void main()
{
gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
gl_ClipDistance[0] = gl_Position.w;
})";
GLProgram prg;
prg.makeRaster(kVS, essl1_shaders::fs::Red());
EXPECT_FALSE(prg.valid());
}
// Check that gl_ClipDistance size cannot be undefined
TEST_P(ClipDistanceAPPLETest, UndefinedArraySize)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_APPLE_clip_distance"));
constexpr char kVS[] = R"(
#extension GL_APPLE_clip_distance : require
void main()
{
gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
for (int i = 0; i < 8; i++)
{
gl_ClipDistance[i] = gl_Position.w;
}
})";
GLProgram prg;
prg.makeRaster(kVS, essl1_shaders::fs::Red());
EXPECT_FALSE(prg.valid());
}
// Check that gl_ClipDistance size cannot be more than maximum
TEST_P(ClipDistanceAPPLETest, OutOfRangeArraySize)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_APPLE_clip_distance"));
GLint maxClipDistances = 0;
glGetIntegerv(GL_MAX_CLIP_DISTANCES_APPLE, &maxClipDistances);
std::stringstream vsImplicit;
vsImplicit << R"(#extension GL_APPLE_clip_distance : require
void main()
{
gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
gl_ClipDistance[)"
<< maxClipDistances << R"(] = gl_Position.w;
})";
std::stringstream vsRedeclared;
vsRedeclared << R"(#extension GL_APPLE_clip_distance : require
varying highp float gl_ClipDistance[)"
<< (maxClipDistances + 1) << R"(];
void main()
{
gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
gl_ClipDistance[)"
<< (maxClipDistances - 1) << R"(] = gl_Position.w;
})";
std::stringstream vsRedeclaredInvalidIndex;
vsRedeclaredInvalidIndex << R"(#extension GL_APPLE_clip_distance : require
varying highp float gl_ClipDistance[)"
<< (maxClipDistances - 2) << R"(];
void main()
{
gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
gl_ClipDistance[)" << (maxClipDistances - 1)
<< R"(] = gl_Position.w;
})";
for (auto stream : {&vsImplicit, &vsRedeclared, &vsRedeclaredInvalidIndex})
{
GLProgram prg;
prg.makeRaster(stream->str().c_str(), essl1_shaders::fs::Red());
EXPECT_FALSE(prg.valid());
}
}
// Write to one gl_ClipDistance element
TEST_P(ClipDistanceAPPLETest, OneClipDistance)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_APPLE_clip_distance"));
constexpr char kVS[] = R"(
#extension GL_APPLE_clip_distance : require
uniform vec4 u_plane;
attribute vec2 a_position;
void main()
{
gl_Position = vec4(a_position, 0.0, 1.0);
gl_ClipDistance[0] = dot(gl_Position, u_plane);
})";
ANGLE_GL_PROGRAM(programRed, kVS, essl1_shaders::fs::Red());
glUseProgram(programRed);
ASSERT_GL_NO_ERROR();
glEnable(GL_CLIP_DISTANCE0_APPLE);
// Clear to blue
glClearColor(0, 0, 1, 1);
glClear(GL_COLOR_BUFFER_BIT);
// Draw full screen quad with color red
glUniform4f(glGetUniformLocation(programRed, "u_plane"), 1, 0, 0, 0.5);
EXPECT_GL_NO_ERROR();
drawQuad(programRed, "a_position", 0);
EXPECT_GL_NO_ERROR();
// All pixels on the left of the plane x = -0.5 must be blue
GLuint x = 0;
GLuint y = 0;
GLuint width = getWindowWidth() / 4 - 1;
GLuint height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::blue);
// All pixels on the right of the plane x = -0.5 must be red
x = getWindowWidth() / 4 + 2;
y = 0;
width = getWindowWidth() - x;
height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::red);
// Clear to green
glClearColor(0, 1, 0, 1);
glClear(GL_COLOR_BUFFER_BIT);
// Draw full screen quad with color red
glUniform4f(glGetUniformLocation(programRed, "u_plane"), -1, 0, 0, -0.5);
EXPECT_GL_NO_ERROR();
drawQuad(programRed, "a_position", 0);
EXPECT_GL_NO_ERROR();
// All pixels on the left of the plane x = -0.5 must be red
x = 0;
y = 0;
width = getWindowWidth() / 4 - 1;
height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::red);
// All pixels on the right of the plane x = -0.5 must be green
x = getWindowWidth() / 4 + 2;
y = 0;
width = getWindowWidth() - x;
height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::green);
// Disable GL_CLIP_DISTANCE
glDisable(GL_CLIP_DISTANCE0_APPLE);
drawQuad(programRed, "a_position", 0);
// All pixels must be red
x = 0;
y = 0;
width = getWindowWidth();
height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::red);
}
// Write to each gl_ClipDistance element
TEST_P(ClipDistanceAPPLETest, EachClipDistance)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_APPLE_clip_distance"));
for (size_t i = 0; i < 8; i++)
{
std::stringstream vertexShaderStr;
vertexShaderStr << "#extension GL_APPLE_clip_distance : require\n"
<< "uniform vec4 u_plane;\n"
<< "attribute vec2 a_position;\n"
<< "void main()\n"
<< "{\n"
<< " gl_Position = vec4(a_position, 0.0, 1.0);\n"
<< " gl_ClipDistance[" << i << "] = dot(gl_Position, u_plane);\n"
<< "}";
ANGLE_GL_PROGRAM(programRed, vertexShaderStr.str().c_str(), essl1_shaders::fs::Red());
glUseProgram(programRed);
ASSERT_GL_NO_ERROR();
// Enable the current clip distance, disable all others.
for (size_t j = 0; j < 8; j++)
{
if (j == i)
glEnable(GL_CLIP_DISTANCE0_APPLE + j);
else
glDisable(GL_CLIP_DISTANCE0_APPLE + j);
}
// Clear to blue
glClearColor(0, 0, 1, 1);
glClear(GL_COLOR_BUFFER_BIT);
// Draw full screen quad with color red
glUniform4f(glGetUniformLocation(programRed, "u_plane"), 1, 0, 0, 0.5);
EXPECT_GL_NO_ERROR();
drawQuad(programRed, "a_position", 0);
EXPECT_GL_NO_ERROR();
// All pixels on the left of the plane x = -0.5 must be blue
GLuint x = 0;
GLuint y = 0;
GLuint width = getWindowWidth() / 4 - 1;
GLuint height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::blue);
// All pixels on the right of the plane x = -0.5 must be red
x = getWindowWidth() / 4 + 2;
y = 0;
width = getWindowWidth() - x;
height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::red);
// Clear to green
glClearColor(0, 1, 0, 1);
glClear(GL_COLOR_BUFFER_BIT);
// Draw full screen quad with color red
glUniform4f(glGetUniformLocation(programRed, "u_plane"), -1, 0, 0, -0.5);
EXPECT_GL_NO_ERROR();
drawQuad(programRed, "a_position", 0);
EXPECT_GL_NO_ERROR();
// All pixels on the left of the plane x = -0.5 must be red
x = 0;
y = 0;
width = getWindowWidth() / 4 - 1;
height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::red);
// All pixels on the right of the plane x = -0.5 must be green
x = getWindowWidth() / 4 + 2;
y = 0;
width = getWindowWidth() - x;
height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::green);
// Disable GL_CLIP_DISTANCE
glDisable(GL_CLIP_DISTANCE0_APPLE + i);
drawQuad(programRed, "a_position", 0);
// All pixels must be red
x = 0;
y = 0;
width = getWindowWidth();
height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::red);
}
}
// Use 8 clip distances to draw an octagon
TEST_P(ClipDistanceAPPLETest, Octagon)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_APPLE_clip_distance"));
constexpr char kVS[] = R"(
#extension GL_APPLE_clip_distance : require
attribute vec2 a_position;
void main()
{
gl_Position = vec4(a_position, 0.0, 1.0);
gl_ClipDistance[0] = dot(gl_Position, vec4( 1, 0, 0, 0.5));
gl_ClipDistance[1] = dot(gl_Position, vec4(-1, 0, 0, 0.5));
gl_ClipDistance[2] = dot(gl_Position, vec4( 0, 1, 0, 0.5));
gl_ClipDistance[3] = dot(gl_Position, vec4( 0, -1, 0, 0.5));
gl_ClipDistance[4] = dot(gl_Position, vec4( 1, 1, 0, 0.70710678));
gl_ClipDistance[5] = dot(gl_Position, vec4( 1, -1, 0, 0.70710678));
gl_ClipDistance[6] = dot(gl_Position, vec4(-1, 1, 0, 0.70710678));
gl_ClipDistance[7] = dot(gl_Position, vec4(-1, -1, 0, 0.70710678));
})";
ANGLE_GL_PROGRAM(programRed, kVS, essl1_shaders::fs::Red());
glUseProgram(programRed);
ASSERT_GL_NO_ERROR();
glEnable(GL_CLIP_DISTANCE0_APPLE);
glEnable(GL_CLIP_DISTANCE1_APPLE);
glEnable(GL_CLIP_DISTANCE2_APPLE);
glEnable(GL_CLIP_DISTANCE3_APPLE);
glEnable(GL_CLIP_DISTANCE4_APPLE);
glEnable(GL_CLIP_DISTANCE5_APPLE);
glEnable(GL_CLIP_DISTANCE6_APPLE);
glEnable(GL_CLIP_DISTANCE7_APPLE);
// Clear to blue
glClearColor(0, 0, 1, 1);
glClear(GL_COLOR_BUFFER_BIT);
// Draw full screen quad with color red
drawQuad(programRed, "a_position", 0);
EXPECT_GL_NO_ERROR();
// Top edge
EXPECT_PIXEL_COLOR_EQ(32, 56, GLColor::blue);
EXPECT_PIXEL_COLOR_EQ(32, 40, GLColor::red);
// Top-right edge
EXPECT_PIXEL_COLOR_EQ(48, 48, GLColor::blue);
EXPECT_PIXEL_COLOR_EQ(40, 40, GLColor::red);
// Right edge
EXPECT_PIXEL_COLOR_EQ(56, 32, GLColor::blue);
EXPECT_PIXEL_COLOR_EQ(40, 32, GLColor::red);
// Bottom-right edge
EXPECT_PIXEL_COLOR_EQ(48, 16, GLColor::blue);
EXPECT_PIXEL_COLOR_EQ(40, 24, GLColor::red);
// Bottom edge
EXPECT_PIXEL_COLOR_EQ(32, 8, GLColor::blue);
EXPECT_PIXEL_COLOR_EQ(32, 24, GLColor::red);
// Bottom-left edge
EXPECT_PIXEL_COLOR_EQ(16, 16, GLColor::blue);
EXPECT_PIXEL_COLOR_EQ(24, 24, GLColor::red);
// Left edge
EXPECT_PIXEL_COLOR_EQ(8, 32, GLColor::blue);
EXPECT_PIXEL_COLOR_EQ(24, 32, GLColor::red);
// Top-left edge
EXPECT_PIXEL_COLOR_EQ(16, 48, GLColor::blue);
EXPECT_PIXEL_COLOR_EQ(24, 40, GLColor::red);
}
// Write to 3 clip distances
TEST_P(ClipDistanceAPPLETest, ThreeClipDistances)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_APPLE_clip_distance"));
constexpr char kVS[] = R"(
#extension GL_APPLE_clip_distance : require
uniform vec4 u_plane[3];
attribute vec2 a_position;
void main()
{
gl_Position = vec4(a_position, 0.0, 1.0);
gl_ClipDistance[0] = dot(gl_Position, u_plane[0]);
gl_ClipDistance[3] = dot(gl_Position, u_plane[1]);
gl_ClipDistance[7] = dot(gl_Position, u_plane[2]);
})";
ANGLE_GL_PROGRAM(programRed, kVS, essl1_shaders::fs::Red());
glUseProgram(programRed);
ASSERT_GL_NO_ERROR();
// Enable 3 clip distances
glEnable(GL_CLIP_DISTANCE0_APPLE);
glEnable(GL_CLIP_DISTANCE3_APPLE);
glEnable(GL_CLIP_DISTANCE7_APPLE);
ASSERT_GL_NO_ERROR();
// Clear to blue
glClearColor(0, 0, 1, 1);
glClear(GL_COLOR_BUFFER_BIT);
// Draw full screen quad with color red
// x = -0.5
glUniform4f(glGetUniformLocation(programRed, "u_plane[0]"), 1, 0, 0, 0.5);
// x = 0.5
glUniform4f(glGetUniformLocation(programRed, "u_plane[1]"), -1, 0, 0, 0.5);
// x + y = 1
glUniform4f(glGetUniformLocation(programRed, "u_plane[2]"), -1, -1, 0, 1);
EXPECT_GL_NO_ERROR();
drawQuad(programRed, "a_position", 0);
EXPECT_GL_NO_ERROR();
{
// All pixels on the left of the plane x = -0.5 must be blue
GLuint x = 0;
GLuint y = 0;
GLuint width = getWindowWidth() / 4 - 1;
GLuint height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::blue);
// All pixels from the plane x = -0.5 to the plane x = 0 must be red
x = getWindowWidth() / 4 + 2;
y = 0;
width = getWindowWidth() / 2 - x;
height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::red);
}
{
// Check pixels to the right of the plane x = 0
std::vector<GLColor> actualColors(getWindowWidth() * getWindowHeight());
glReadPixels(0, 0, getWindowWidth(), getWindowHeight(), GL_RGBA, GL_UNSIGNED_BYTE,
actualColors.data());
for (int y = 0; y < getWindowHeight(); ++y)
{
for (int x = getWindowWidth() / 2; x < getWindowWidth(); ++x)
{
const int currentPosition = y * getWindowHeight() + x;
if (x < getWindowWidth() * 3 / 2 - y - 1 && x < getWindowWidth() * 3 / 4 - 1)
{
// Bottom of the plane x + y = 1 clipped by x = 0.5 plane
EXPECT_EQ(GLColor::red, actualColors[currentPosition]);
}
else if (x > getWindowWidth() * 3 / 2 - y + 1 || x > getWindowWidth() * 3 / 4 + 1)
{
// Top of the plane x + y = 1 plus right of x = 0.5 plane
EXPECT_EQ(GLColor::blue, actualColors[currentPosition]);
}
}
}
}
// Clear to green
glClearColor(0, 1, 0, 1);
glClear(GL_COLOR_BUFFER_BIT);
// Disable gl_ClipDistance[3]
glDisable(GL_CLIP_DISTANCE3_APPLE);
// Draw full screen quad with color red
EXPECT_GL_NO_ERROR();
drawQuad(programRed, "a_position", 0);
EXPECT_GL_NO_ERROR();
{
// All pixels on the left of the plane x = -0.5 must be green
GLuint x = 0;
GLuint y = 0;
GLuint width = getWindowWidth() / 4 - 1;
GLuint height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::green);
// All pixels from the plane x = -0.5 to the plane x = 0 must be red
x = getWindowWidth() / 4 + 2;
y = 0;
width = getWindowWidth() / 2 - x;
height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::red);
}
// Check pixels to the right of the plane x = 0
std::vector<GLColor> actualColors(getWindowWidth() * getWindowHeight());
glReadPixels(0, 0, getWindowWidth(), getWindowHeight(), GL_RGBA, GL_UNSIGNED_BYTE,
actualColors.data());
for (int y = 0; y < getWindowHeight(); ++y)
{
for (int x = getWindowWidth() / 2; x < getWindowWidth(); ++x)
{
const int currentPosition = y * getWindowHeight() + x;
if (x < getWindowWidth() * 3 / 2 - y - 1)
{
// Bottom of the plane x + y = 1
EXPECT_EQ(GLColor::red, actualColors[currentPosition]);
}
else if (x > getWindowWidth() * 3 / 2 - y + 1)
{
// Top of the plane x + y = 1
EXPECT_EQ(GLColor::green, actualColors[currentPosition]);
}
}
}
}
// Redeclare gl_ClipDistance in shader with explicit size, also use it in a global function
// outside main()
TEST_P(ClipDistanceAPPLETest, ThreeClipDistancesRedeclared)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_APPLE_clip_distance"));
constexpr char kVS[] = R"(
#extension GL_APPLE_clip_distance : require
varying highp float gl_ClipDistance[3];
void computeClipDistances(in vec4 position, in vec4 plane[3])
{
gl_ClipDistance[0] = dot(position, plane[0]);
gl_ClipDistance[1] = dot(position, plane[1]);
gl_ClipDistance[2] = dot(position, plane[2]);
}
uniform vec4 u_plane[3];
attribute vec2 a_position;
void main()
{
gl_Position = vec4(a_position, 0.0, 1.0);
computeClipDistances(gl_Position, u_plane);
})";
ANGLE_GL_PROGRAM(programRed, kVS, essl1_shaders::fs::Red());
glUseProgram(programRed);
ASSERT_GL_NO_ERROR();
// Enable 3 clip distances
glEnable(GL_CLIP_DISTANCE0_APPLE);
glEnable(GL_CLIP_DISTANCE1_APPLE);
glEnable(GL_CLIP_DISTANCE2_APPLE);
ASSERT_GL_NO_ERROR();
// Clear to blue
glClearColor(0, 0, 1, 1);
glClear(GL_COLOR_BUFFER_BIT);
// Draw full screen quad with color red
// x = -0.5
glUniform4f(glGetUniformLocation(programRed, "u_plane[0]"), 1, 0, 0, 0.5);
// x = 0.5
glUniform4f(glGetUniformLocation(programRed, "u_plane[1]"), -1, 0, 0, 0.5);
// x + y = 1
glUniform4f(glGetUniformLocation(programRed, "u_plane[2]"), -1, -1, 0, 1);
EXPECT_GL_NO_ERROR();
drawQuad(programRed, "a_position", 0);
EXPECT_GL_NO_ERROR();
{
// All pixels on the left of the plane x = -0.5 must be blue
GLuint x = 0;
GLuint y = 0;
GLuint width = getWindowWidth() / 4 - 1;
GLuint height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::blue);
// All pixels from the plane x = -0.5 to the plane x = 0 must be red
x = getWindowWidth() / 4 + 2;
y = 0;
width = getWindowWidth() / 2 - x;
height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::red);
}
// Check pixels to the right of the plane x = 0
std::vector<GLColor> actualColors(getWindowWidth() * getWindowHeight());
glReadPixels(0, 0, getWindowWidth(), getWindowHeight(), GL_RGBA, GL_UNSIGNED_BYTE,
actualColors.data());
for (int y = 0; y < getWindowHeight(); ++y)
{
for (int x = getWindowWidth() / 2; x < getWindowWidth(); ++x)
{
const int currentPosition = y * getWindowHeight() + x;
if (x < getWindowWidth() * 3 / 2 - y - 1 && x < getWindowWidth() * 3 / 4 - 1)
{
// Bottom of the plane x + y = 1 clipped by x = 0.5 plane
EXPECT_EQ(GLColor::red, actualColors[currentPosition]);
}
else if (x > getWindowWidth() * 3 / 2 - y + 1 || x > getWindowWidth() * 3 / 4 + 1)
{
// Top of the plane x + y = 1 plus right of x = 0.5 plane
EXPECT_EQ(GLColor::blue, actualColors[currentPosition]);
}
}
}
}
using ClipCullDistanceTestParams = std::tuple<angle::PlatformParameters, bool>;
std::string PrintToStringParamName(const ::testing::TestParamInfo<ClipCullDistanceTestParams> &info)
{
std::stringstream ss;
ss << std::get<0>(info.param);
if (std::get<1>(info.param))
{
ss << "__EXT";
}
else
{
ss << "__ANGLE";
}
return ss.str();
}
class ClipCullDistanceTest : public ANGLETest<ClipCullDistanceTestParams>
{
protected:
const bool mCullDistanceSupportRequired;
const std::string kExtensionName;
ClipCullDistanceTest()
: mCullDistanceSupportRequired(::testing::get<1>(GetParam())),
kExtensionName(::testing::get<1>(GetParam()) ? "GL_EXT_clip_cull_distance"
: "GL_ANGLE_clip_cull_distance")
{
setWindowWidth(64);
setWindowHeight(64);
setConfigRedBits(8);
setConfigGreenBits(8);
setConfigBlueBits(8);
setConfigAlphaBits(8);
setConfigDepthBits(24);
setExtensionsEnabled(false);
}
};
// Query max clip distances and enable, disable states of clip distances
TEST_P(ClipCullDistanceTest, StateQuery)
{
GLint maxClipDistances = 0;
glGetIntegerv(GL_MAX_CLIP_DISTANCES_EXT, &maxClipDistances);
EXPECT_EQ(maxClipDistances, 0);
EXPECT_GL_ERROR(GL_INVALID_ENUM);
GLint maxCullDistances = 0;
glGetIntegerv(GL_MAX_CULL_DISTANCES_EXT, &maxCullDistances);
EXPECT_EQ(maxCullDistances, 0);
EXPECT_GL_ERROR(GL_INVALID_ENUM);
GLint maxCombinedClipAndCullDistances = 0;
glGetIntegerv(GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES_EXT, &maxCombinedClipAndCullDistances);
EXPECT_EQ(maxCombinedClipAndCullDistances, 0);
EXPECT_GL_ERROR(GL_INVALID_ENUM);
auto assertState = [](GLenum pname, bool valid, bool expectedState) {
EXPECT_EQ(glIsEnabled(pname), valid ? expectedState : false);
EXPECT_GL_ERROR(valid ? GL_NO_ERROR : GL_INVALID_ENUM);
GLboolean result = false;
glGetBooleanv(pname, &result);
EXPECT_EQ(result, valid ? expectedState : false);
EXPECT_GL_ERROR(valid ? GL_NO_ERROR : GL_INVALID_ENUM);
};
for (size_t i = 0; i < 8; i++)
{
assertState(GL_CLIP_DISTANCE0_EXT + i, false, false);
glEnable(GL_CLIP_DISTANCE0_EXT + i);
EXPECT_GL_ERROR(GL_INVALID_ENUM);
assertState(GL_CLIP_DISTANCE0_EXT + i, false, false);
glDisable(GL_CLIP_DISTANCE0_EXT + i);
EXPECT_GL_ERROR(GL_INVALID_ENUM);
assertState(GL_CLIP_DISTANCE0_EXT + i, false, false);
}
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled(kExtensionName));
ASSERT_GL_NO_ERROR();
glGetIntegerv(GL_MAX_CLIP_DISTANCES_EXT, &maxClipDistances);
EXPECT_GE(maxClipDistances, 8);
EXPECT_GL_NO_ERROR();
glGetIntegerv(GL_MAX_CULL_DISTANCES_EXT, &maxCullDistances);
if (mCullDistanceSupportRequired)
{
EXPECT_GE(maxCullDistances, 8);
}
else
{
EXPECT_TRUE(maxCullDistances == 0 || maxCullDistances >= 8);
}
EXPECT_GL_NO_ERROR();
glGetIntegerv(GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES_EXT, &maxCombinedClipAndCullDistances);
if (mCullDistanceSupportRequired)
{
EXPECT_GE(maxCombinedClipAndCullDistances, 8);
}
else
{
EXPECT_TRUE(maxCombinedClipAndCullDistances == 0 || maxCombinedClipAndCullDistances >= 8);
}
EXPECT_GL_NO_ERROR();
for (size_t i = 0; i < 8; i++)
{
assertState(GL_CLIP_DISTANCE0_EXT + i, true, false);
glEnable(GL_CLIP_DISTANCE0_EXT + i);
EXPECT_GL_NO_ERROR();
assertState(GL_CLIP_DISTANCE0_EXT + i, true, true);
glDisable(GL_CLIP_DISTANCE0_EXT + i);
EXPECT_GL_NO_ERROR();
assertState(GL_CLIP_DISTANCE0_EXT + i, true, false);
}
}
// Check that gl_ClipDistance and gl_CullDistance sizes cannot be undefined
TEST_P(ClipCullDistanceTest, UndefinedArraySize)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled(kExtensionName));
std::string kVSClip = R"(#version 300 es
#extension )" + kExtensionName +
R"( : require
void main()
{
gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
for (int i = 0; i < gl_MaxClipDistances; i++)
{
gl_ClipDistance[i] = gl_Position.w;
}
})";
std::string kVSCull = R"(#version 300 es
#extension )" + kExtensionName +
R"( : require
void main()
{
gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
for (int i = 0; i < gl_MaxCullDistances; i++)
{
gl_CullDistance[i] = gl_Position.w;
}
})";
for (auto vs : {kVSClip, kVSCull})
{
GLProgram prg;
prg.makeRaster(vs.c_str(), essl1_shaders::fs::Red());
EXPECT_FALSE(prg.valid());
}
}
// Check that shaders with invalid or missing storage qualifiers are rejected
TEST_P(ClipCullDistanceTest, StorageQualifiers)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled(kExtensionName));
std::stringstream vertexSource;
auto vs = [this, &vertexSource](std::string name, std::string qualifier) {
vertexSource.str(std::string());
vertexSource.clear();
vertexSource << "#version 300 es\n"
<< "#extension " << kExtensionName << " : require\n"
<< qualifier << " highp float " << name << "[1];\n"
<< "void main()\n"
<< "{\n"
<< " gl_Position = vec4(0.0, 0.0, 0.0, 1.0);\n"
<< " " << name << "[0] = 1.0;\n"
<< "}";
};
std::stringstream fragmentSource;
auto fs = [this, &fragmentSource](std::string name, std::string qualifier) {
fragmentSource.str(std::string());
fragmentSource.clear();
fragmentSource << "#version 300 es\n"
<< "#extension " << kExtensionName << " : require\n"
<< qualifier << " highp float " << name << "[1];\n"
<< "out highp vec4 my_FragColor;\n"
<< "void main()\n"
<< "{\n"
<< " my_FragColor = vec4(" << name << "[0], 0.0, 0.0, 1.0);\n"
<< "}";
};
auto checkProgram = [=, &vertexSource, &fragmentSource](std::string name,
std::string qualifierVertex,
std::string qualifierFragment) {
GLProgram program;
vs(name, qualifierVertex);
fs(name, qualifierFragment);
program.makeRaster(vertexSource.str().c_str(), fragmentSource.str().c_str());
return program.valid();
};
GLint maxClipDistances = 0;
glGetIntegerv(GL_MAX_CLIP_DISTANCES_EXT, &maxClipDistances);
ASSERT_GT(maxClipDistances, 0);
GLint maxCullDistances = 0;
glGetIntegerv(GL_MAX_CULL_DISTANCES_EXT, &maxCullDistances);
if (mCullDistanceSupportRequired)
{
ASSERT_GT(maxCullDistances, 0);
}
else
{
ASSERT_GE(maxCullDistances, 0);
}
std::pair<std::string, int> entries[2] = {{"gl_ClipDistance", maxClipDistances},
{"gl_CullDistance", maxCullDistances}};
for (auto entry : entries)
{
if (entry.second == 0)
continue;
EXPECT_TRUE(checkProgram(entry.first, "out", "in"));
EXPECT_FALSE(checkProgram(entry.first, "", ""));
EXPECT_FALSE(checkProgram(entry.first, "", "in"));
EXPECT_FALSE(checkProgram(entry.first, "", "out"));
EXPECT_FALSE(checkProgram(entry.first, "in", ""));
EXPECT_FALSE(checkProgram(entry.first, "in", "in"));
EXPECT_FALSE(checkProgram(entry.first, "in", "out"));
EXPECT_FALSE(checkProgram(entry.first, "out", ""));
EXPECT_FALSE(checkProgram(entry.first, "out", "out"));
}
}
// Check that array sizes cannot be more than maximum
TEST_P(ClipCullDistanceTest, OutOfRangeArraySize)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled(kExtensionName));
auto test = [this](std::string name, int maxSize) {
std::stringstream vsImplicit;
vsImplicit << R"(#version 300 es
#extension )"
<< kExtensionName << R"( : require
void main()
{
gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
)" << name << "["
<< maxSize << R"(] = gl_Position.w;
})";
std::stringstream vsRedeclared;
vsRedeclared << R"(#version 300 es
#extension )" << kExtensionName
<< R"( : require
out highp float )" << name
<< "[" << (maxSize + 1) << R"(];
void main()
{
gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
)" << name << "[" << (maxSize ? maxSize - 1 : 0)
<< R"(] = gl_Position.w;
})";
std::stringstream vsRedeclaredInvalidIndex;
vsRedeclaredInvalidIndex << R"(#version 300 es
#extension )" << kExtensionName << R"( : require
out highp float )" << name << "[" << (maxSize ? maxSize - 2 : 0)
<< R"(];
void main()
{
gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
)" << name << "[" << (maxSize ? maxSize - 1 : 0)
<< R"(] = gl_Position.w;
})";
for (auto stream : {&vsImplicit, &vsRedeclared, &vsRedeclaredInvalidIndex})
{
GLProgram prg;
prg.makeRaster(stream->str().c_str(), essl1_shaders::fs::Red());
EXPECT_FALSE(prg.valid());
}
};
GLint maxClipDistances = 0;
glGetIntegerv(GL_MAX_CLIP_DISTANCES_EXT, &maxClipDistances);
ASSERT_GT(maxClipDistances, 0);
GLint maxCullDistances = 0;
glGetIntegerv(GL_MAX_CULL_DISTANCES_EXT, &maxCullDistances);
if (mCullDistanceSupportRequired)
{
ASSERT_GT(maxCullDistances, 0);
}
else
{
ASSERT_GE(maxCullDistances, 0);
}
test("gl_ClipDistance", maxClipDistances);
test("gl_CullDistance", maxCullDistances);
}
// Check that shader validation enforces matching array sizes between shader stages
TEST_P(ClipCullDistanceTest, SizeCheck)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled(kExtensionName));
std::stringstream vertexSource;
auto vs = [this, &vertexSource](std::string name, bool declare, int size) {
vertexSource.str(std::string());
vertexSource.clear();
vertexSource << "#version 300 es\n";
vertexSource << "#extension " << kExtensionName << " : require\n";
if (declare)
{
ASSERT(size);
vertexSource << "out highp float " << name << "[" << size << "];\n";
}
vertexSource << "void main()\n";
vertexSource << "{\n";
vertexSource << " gl_Position = vec4(0.0, 0.0, 0.0, 1.0);\n";
if (size)
{
vertexSource << " " << name << "[" << (size - 1) << "] = 1.0;\n";
}
vertexSource << "}";
};
std::stringstream fragmentSource;
auto fs = [this, &fragmentSource](std::string name, bool declare, int size) {
fragmentSource.str(std::string());
fragmentSource.clear();
fragmentSource << "#version 300 es\n";
fragmentSource << "#extension " << kExtensionName << " : require\n";
if (declare)
{
ASSERT(size);
fragmentSource << "in highp float " << name << "[" << size << "];\n";
}
fragmentSource << "out highp vec4 my_FragColor;\n"
<< "void main()\n"
<< "{\n"
<< " my_FragColor = vec4(";
if (size)
{
fragmentSource << name << "[" << (size - 1) << "]";
}
else
{
fragmentSource << "1.0";
}
fragmentSource << ", 0.0, 0.0, 1.0);\n";
fragmentSource << "}\n";
};
auto checkProgram = [=, &vertexSource, &fragmentSource](std::string name, bool declareVertex,
int sizeVertex, bool declareFragment,
int sizeFragment) {
GLProgram program;
vs(name, declareVertex, sizeVertex);
fs(name, declareFragment, sizeFragment);
program.makeRaster(vertexSource.str().c_str(), fragmentSource.str().c_str());
return program.valid();
};
GLint maxClipDistances = 0;
glGetIntegerv(GL_MAX_CLIP_DISTANCES_EXT, &maxClipDistances);
ASSERT_GT(maxClipDistances, 0);
GLint maxCullDistances = 0;
glGetIntegerv(GL_MAX_CULL_DISTANCES_EXT, &maxCullDistances);
if (mCullDistanceSupportRequired)
{
ASSERT_GT(maxCullDistances, 0);
}
else
{
ASSERT_GE(maxCullDistances, 0);
}
std::pair<std::string, int> entries[2] = {{"gl_ClipDistance", maxClipDistances},
{"gl_CullDistance", maxCullDistances}};
for (auto entry : entries)
{
const std::string name = entry.first;
const int maxSize = entry.second;
// Any VS array size is valid when the value is not accessed in the fragment shader
for (int i = 1; i <= maxSize; i++)
{
EXPECT_TRUE(checkProgram(name, false, i, false, 0));
EXPECT_TRUE(checkProgram(name, true, i, false, 0));
}
// Any FS array size is invalid when the value is not written in the vertex shader
for (int i = 1; i <= maxSize; i++)
{
EXPECT_FALSE(checkProgram(name, false, 0, false, i));
EXPECT_FALSE(checkProgram(name, false, 0, true, i));
}
// Matching sizes are valid both for redeclared and implicitly sized arrays
for (int i = 1; i <= maxSize; i++)
{
EXPECT_TRUE(checkProgram(name, false, i, false, i));
EXPECT_TRUE(checkProgram(name, false, i, true, i));
EXPECT_TRUE(checkProgram(name, true, i, false, i));
EXPECT_TRUE(checkProgram(name, true, i, true, i));
}
// Non-matching sizes are invalid both for redeclared and implicitly sized arrays
for (int i = 2; i <= maxSize; i++)
{
EXPECT_FALSE(checkProgram(name, false, i - 1, false, i));
EXPECT_FALSE(checkProgram(name, false, i - 1, true, i));
EXPECT_FALSE(checkProgram(name, true, i - 1, false, i));
EXPECT_FALSE(checkProgram(name, true, i - 1, true, i));
EXPECT_FALSE(checkProgram(name, false, i, false, i - 1));
EXPECT_FALSE(checkProgram(name, false, i, true, i - 1));
EXPECT_FALSE(checkProgram(name, true, i, false, i - 1));
EXPECT_FALSE(checkProgram(name, true, i, true, i - 1));
}
// Out-of-range sizes are invalid
{
EXPECT_FALSE(checkProgram(name, false, 0, false, maxSize + 1));
EXPECT_FALSE(checkProgram(name, false, maxSize + 1, false, 0));
EXPECT_FALSE(checkProgram(name, false, maxSize + 1, false, maxSize + 1));
EXPECT_FALSE(checkProgram(name, false, 0, true, maxSize + 1));
EXPECT_FALSE(checkProgram(name, false, maxSize + 1, true, maxSize + 1));
EXPECT_FALSE(checkProgram(name, true, maxSize + 1, false, 0));
EXPECT_FALSE(checkProgram(name, true, maxSize + 1, false, maxSize + 1));
EXPECT_FALSE(checkProgram(name, true, maxSize + 1, true, maxSize + 1));
}
}
}
// Check that the sum of clip and cull distance array sizes is valid
TEST_P(ClipCullDistanceTest, SizeCheckCombined)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled(kExtensionName));
std::stringstream vertexSource;
auto vs = [this, &vertexSource](bool declareClip, int sizeClip, bool declareCull,
int sizeCull) {
vertexSource.str(std::string());
vertexSource.clear();
vertexSource << "#version 300 es\n";
vertexSource << "#extension " << kExtensionName << " : require\n";
if (declareClip)
{
ASSERT(sizeClip);
vertexSource << "out highp float gl_ClipDistance[" << sizeClip << "];\n";
}
if (declareCull)
{
ASSERT(sizeCull);
vertexSource << "out highp float gl_CullDistance[" << sizeCull << "];\n";
}
vertexSource << "void main()\n"
<< "{\n"
<< " gl_Position = vec4(0.0, 0.0, 0.0, 1.0);\n"
<< " gl_ClipDistance[" << (sizeClip - 1) << "] = 1.0;\n"
<< " gl_CullDistance[" << (sizeCull - 1) << "] = 1.0;\n"
<< "}";
};
std::stringstream fragmentSource;
auto fs = [this, &fragmentSource](bool declareClip, int sizeClip, bool declareCull,
int sizeCull) {
fragmentSource.str(std::string());
fragmentSource.clear();
fragmentSource << "#version 300 es\n";
fragmentSource << "#extension " << kExtensionName << " : require\n";
if (declareClip)
{
ASSERT(sizeClip);
fragmentSource << "in highp float gl_ClipDistance[" << sizeClip << "];\n";
}
if (declareCull)
{
ASSERT(sizeClip);
fragmentSource << "in highp float gl_CullDistance[" << sizeCull << "];\n";
}
fragmentSource << "out highp vec4 my_FragColor;\n"
<< "void main()\n"
<< "{\n"
<< " my_FragColor = vec4(\n"
<< " gl_ClipDistance[" << (sizeClip - 1) << "],\n"
<< " gl_CullDistance[" << (sizeCull - 1) << "],\n"
<< " 0.0, 1.0);\n"
<< "}\n";
};
auto checkProgram = [=, &vertexSource, &fragmentSource](
bool declareVertexClip, bool declareFragmentClip, int sizeClip,
bool declareVertexCull, bool declareFragmentCull, int sizeCull) {
GLProgram program;
vs(declareVertexClip, sizeClip, declareVertexCull, sizeCull);
fs(declareVertexClip, sizeClip, declareVertexCull, sizeCull);
program.makeRaster(vertexSource.str().c_str(), fragmentSource.str().c_str());
return program.valid();
};
GLint maxClipDistances = 0;
glGetIntegerv(GL_MAX_CLIP_DISTANCES_EXT, &maxClipDistances);
ASSERT_GT(maxClipDistances, 0);
GLint maxCullDistances = 0;
glGetIntegerv(GL_MAX_CULL_DISTANCES_EXT, &maxCullDistances);
if (mCullDistanceSupportRequired)
{
ASSERT_GT(maxCullDistances, 0);
}
else
{
ASSERT_GE(maxCullDistances, 0);
}
GLint maxCombinedClipAndCullDistances = 0;
glGetIntegerv(GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES_EXT, &maxCombinedClipAndCullDistances);
if (mCullDistanceSupportRequired)
{
ASSERT_GT(maxCombinedClipAndCullDistances, 0);
}
else
{
ASSERT_GE(maxCombinedClipAndCullDistances, 0);
}
for (int sizeClip = 1; sizeClip <= maxClipDistances; sizeClip++)
{
for (int sizeCull = 1; sizeCull <= maxCullDistances; sizeCull++)
{
// clang-format off
const bool valid = sizeClip + sizeCull <= maxCombinedClipAndCullDistances;
EXPECT_EQ(checkProgram(false, false, sizeClip, false, false, sizeCull), valid);
EXPECT_EQ(checkProgram(false, false, sizeClip, false, true, sizeCull), valid);
EXPECT_EQ(checkProgram(false, false, sizeClip, true, false, sizeCull), valid);
EXPECT_EQ(checkProgram(false, false, sizeClip, true, true, sizeCull), valid);
EXPECT_EQ(checkProgram(false, true, sizeClip, false, false, sizeCull), valid);
EXPECT_EQ(checkProgram(false, true, sizeClip, false, true, sizeCull), valid);
EXPECT_EQ(checkProgram(false, true, sizeClip, true, false, sizeCull), valid);
EXPECT_EQ(checkProgram(false, true, sizeClip, true, true, sizeCull), valid);
EXPECT_EQ(checkProgram(true, false, sizeClip, false, false, sizeCull), valid);
EXPECT_EQ(checkProgram(true, false, sizeClip, false, true, sizeCull), valid);
EXPECT_EQ(checkProgram(true, false, sizeClip, true, false, sizeCull), valid);
EXPECT_EQ(checkProgram(true, false, sizeClip, true, true, sizeCull), valid);
EXPECT_EQ(checkProgram(true, true, sizeClip, false, false, sizeCull), valid);
EXPECT_EQ(checkProgram(true, true, sizeClip, false, true, sizeCull), valid);
EXPECT_EQ(checkProgram(true, true, sizeClip, true, false, sizeCull), valid);
EXPECT_EQ(checkProgram(true, true, sizeClip, true, true, sizeCull), valid);
// clang-format on
}
}
}
// Test that declared but unused built-ins do not cause frontend failures. The internal uniform,
// which is used for passing GL state on some platforms, could be removed when built-ins are not
// accessed.
TEST_P(ClipCullDistanceTest, Unused)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled(kExtensionName));
std::stringstream vertexSource;
auto vs = [this, &vertexSource](std::string name) {
vertexSource.str(std::string());
vertexSource.clear();
vertexSource << "#version 300 es\n"
<< "#extension " << kExtensionName << " : require\n"
<< "out highp float " << name << "[8];\n"
<< "void main() { gl_Position = vec4(0.0, 0.0, 0.0, 1.0); }";
};
std::stringstream fragmentSource;
auto fs = [this, &fragmentSource](std::string name, bool declare) {
fragmentSource.str(std::string());
fragmentSource.clear();
fragmentSource << "#version 300 es\n";
fragmentSource << "#extension " << kExtensionName << " : require\n";
if (declare)
{
fragmentSource << "in highp float " << name << "[8];\n";
}
fragmentSource << "out highp vec4 my_FragColor;\n"
<< "void main() { my_FragColor = vec4(1.0, 0.0, 0.0, 1.0); }\n";
};
auto checkProgram = [=, &vertexSource, &fragmentSource](std::string name,
bool declareFragment) {
GLProgram program;
vs(name);
fs(name, declareFragment);
program.makeRaster(vertexSource.str().c_str(), fragmentSource.str().c_str());
return program.valid();
};
GLint maxClipDistances = 0;
glGetIntegerv(GL_MAX_CLIP_DISTANCES_EXT, &maxClipDistances);
ASSERT_GT(maxClipDistances, 0);
GLint maxCullDistances = 0;
glGetIntegerv(GL_MAX_CULL_DISTANCES_EXT, &maxCullDistances);
if (mCullDistanceSupportRequired)
{
ASSERT_GT(maxCullDistances, 0);
}
else
{
ASSERT_GE(maxCullDistances, 0);
}
std::pair<std::string, int> entries[2] = {{"gl_ClipDistance", maxClipDistances},
{"gl_CullDistance", maxCullDistances}};
for (auto entry : entries)
{
if (entry.second == 0)
continue;
EXPECT_TRUE(checkProgram(entry.first, false));
EXPECT_TRUE(checkProgram(entry.first, true));
}
}
// Test that unused gl_ClipDistance does not cause a translator crash
TEST_P(ClipCullDistanceTest, UnusedVertexVaryingNoCrash)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled(kExtensionName));
std::string kVS = R"(#version 300 es
#extension )" + kExtensionName +
R"( : require
precision highp float;
void main()
{
float r = gl_ClipDistance[1] + 0.5;
})";
GLProgram prg;
prg.makeRaster(kVS.c_str(), essl3_shaders::fs::Red());
EXPECT_TRUE(prg.valid());
}
// Test that unused gl_ClipDistance does not cause a translator crash
TEST_P(ClipCullDistanceTest, UnusedFragmentVaryingNoCrash)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled(kExtensionName));
std::string kFS = R"(#version 300 es
#extension )" + kExtensionName +
R"( : require
precision highp float;
out vec4 my_FragColor;
void main()
{
float r = gl_ClipDistance[1] + 0.5;
})";
GLProgram prg;
prg.makeRaster(essl3_shaders::vs::Simple(), kFS.c_str());
EXPECT_FALSE(prg.valid());
}
// Test that length() does not compile for unsized arrays
TEST_P(ClipCullDistanceTest, UnsizedArrayLength)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled(kExtensionName));
for (std::string name : {"gl_ClipDistance", "gl_CullDistance"})
{
std::stringstream vertexSource;
vertexSource << "#version 300 es\n"
<< "#extension " << kExtensionName << " : require\n"
<< "void main() { " << name << ".length(); }";
GLProgram program;
program.makeRaster(vertexSource.str().c_str(), essl3_shaders::fs::Red());
EXPECT_FALSE(program.valid()) << name;
}
}
// Test that length() returns correct values for sized arrays
TEST_P(ClipCullDistanceTest, SizedArrayLength)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled(kExtensionName));
std::stringstream vertexSource;
auto vs = [this, &vertexSource](std::string name, bool declare, int size) {
vertexSource.str(std::string());
vertexSource.clear();
vertexSource << "#version 300 es\n";
vertexSource << "#extension " << kExtensionName << " : require\n";
if (declare)
{
vertexSource << "out highp float " << name << "[" << size << "];\n";
}
vertexSource << "in vec4 a_position;\n"
<< "out float v_length;\n"
<< "void main()\n"
<< "{\n"
<< " gl_Position = a_position;\n"
<< " v_length = float(" << name << ".length()) / 16.0;\n";
// Assign all elements to avoid undefined behavior
for (int i = 0; i < size; ++i)
{
vertexSource << " " << name << "[" << i << "] = 1.0;\n";
}
vertexSource << "}";
};
std::string kFS = R"(#version 300 es
#extension )" + kExtensionName +
R"( : require
in mediump float v_length;
out mediump vec4 my_FragColor;
void main()
{
my_FragColor = vec4(v_length, 0.0, 0.0, 1.0);
})";
auto checkLength = [this, vs, kFS, &vertexSource](std::string name, bool declare, int size) {
GLProgram program;
vs(name, declare, size);
program.makeRaster(vertexSource.str().c_str(), kFS.c_str());
ASSERT_TRUE(program.valid()) << name;
glClear(GL_COLOR_BUFFER_BIT);
drawQuad(program, "a_position", 0);
EXPECT_PIXEL_NEAR(0, 0, size * 16, 0, 0, 255, 1);
};
GLint maxClipDistances = 0;
glGetIntegerv(GL_MAX_CLIP_DISTANCES_EXT, &maxClipDistances);
ASSERT_GT(maxClipDistances, 0);
GLint maxCullDistances = 0;
glGetIntegerv(GL_MAX_CULL_DISTANCES_EXT, &maxCullDistances);
if (mCullDistanceSupportRequired)
{
ASSERT_GT(maxCullDistances, 0);
}
else
{
ASSERT_GE(maxCullDistances, 0);
}
std::pair<std::string, int> entries[2] = {{"gl_ClipDistance", maxClipDistances},
{"gl_CullDistance", maxCullDistances}};
for (auto entry : entries)
{
const std::string name = entry.first;
const int maxSize = entry.second;
for (int i = 1; i <= maxSize; i++)
{
checkLength(name, false, i);
checkLength(name, true, i);
}
}
}
// Test that pruning clip/cull distance variables does not cause a translator crash
TEST_P(ClipCullDistanceTest, Pruned)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled(kExtensionName));
std::stringstream vertexSource;
auto vs = [this, &vertexSource](std::string name, bool doReturn) {
vertexSource.str(std::string());
vertexSource.clear();
vertexSource << "#version 300 es\n";
vertexSource << "#extension " << kExtensionName << " : require\n";
vertexSource << "void main()\n"
<< "{\n"
<< " " << (doReturn ? "return;\n" : "") << " " << name << "[1];\n";
vertexSource << "}";
};
std::stringstream fragmentSource;
auto fs = [this, &fragmentSource](std::string name) {
fragmentSource.str(std::string());
fragmentSource.clear();
fragmentSource << "#version 300 es\n";
fragmentSource << "#extension " << kExtensionName << " : require\n";
fragmentSource << "out mediump vec4 my_FragColor;\n"
<< "void main()\n"
<< "{\n"
<< " my_FragColor = vec4(" << name << "[1]);\n";
fragmentSource << "}";
};
auto checkPruning = [vs, fs, &vertexSource, &fragmentSource](std::string name, bool doReturn) {
GLProgram program;
vs(name, doReturn);
fs(name);
program.makeRaster(vertexSource.str().c_str(), fragmentSource.str().c_str());
ASSERT_TRUE(program.valid()) << name << (doReturn ? " after return" : "");
};
GLint maxClipDistances = 0;
glGetIntegerv(GL_MAX_CLIP_DISTANCES_EXT, &maxClipDistances);
ASSERT_GT(maxClipDistances, 0);
checkPruning("gl_ClipDistance", false);
checkPruning("gl_ClipDistance", true);
GLint maxCullDistances = 0;
glGetIntegerv(GL_MAX_CULL_DISTANCES_EXT, &maxCullDistances);
if (mCullDistanceSupportRequired)
{
ASSERT_GT(maxCullDistances, 0);
checkPruning("gl_CullDistance", false);
checkPruning("gl_CullDistance", true);
}
}
// Write to one gl_ClipDistance element
TEST_P(ClipCullDistanceTest, OneClipDistance)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled(kExtensionName));
std::string kVS = R"(#version 300 es
#extension )" + kExtensionName +
R"( : require
uniform vec4 u_plane;
in vec2 a_position;
void main()
{
gl_Position = vec4(a_position, 0.0, 1.0);
gl_ClipDistance[0] = dot(gl_Position, u_plane);
})";
ANGLE_GL_PROGRAM(programRed, kVS.c_str(), essl3_shaders::fs::Red());
glUseProgram(programRed);
ASSERT_GL_NO_ERROR();
glEnable(GL_CLIP_DISTANCE0_EXT);
// Clear to blue
glClearColor(0, 0, 1, 1);
glClear(GL_COLOR_BUFFER_BIT);
// Draw full screen quad with color red
glUniform4f(glGetUniformLocation(programRed, "u_plane"), 1, 0, 0, 0.5);
EXPECT_GL_NO_ERROR();
drawQuad(programRed, "a_position", 0);
EXPECT_GL_NO_ERROR();
// All pixels on the left of the plane x = -0.5 must be blue
GLuint x = 0;
GLuint y = 0;
GLuint width = getWindowWidth() / 4 - 1;
GLuint height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::blue);
// All pixels on the right of the plane x = -0.5 must be red
x = getWindowWidth() / 4 + 2;
y = 0;
width = getWindowWidth() - x;
height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::red);
// Clear to green
glClearColor(0, 1, 0, 1);
glClear(GL_COLOR_BUFFER_BIT);
// Draw full screen quad with color red
glUniform4f(glGetUniformLocation(programRed, "u_plane"), -1, 0, 0, -0.5);
EXPECT_GL_NO_ERROR();
drawQuad(programRed, "a_position", 0);
EXPECT_GL_NO_ERROR();
// All pixels on the left of the plane x = -0.5 must be red
x = 0;
y = 0;
width = getWindowWidth() / 4 - 1;
height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::red);
// All pixels on the right of the plane x = -0.5 must be green
x = getWindowWidth() / 4 + 2;
y = 0;
width = getWindowWidth() - x;
height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::green);
// Disable GL_CLIP_DISTANCE
glDisable(GL_CLIP_DISTANCE0_EXT);
drawQuad(programRed, "a_position", 0);
// All pixels must be red
x = 0;
y = 0;
width = getWindowWidth();
height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::red);
}
// Write to each gl_ClipDistance element
TEST_P(ClipCullDistanceTest, EachClipDistance)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled(kExtensionName));
for (size_t i = 0; i < 8; i++)
{
std::stringstream vertexShaderStr;
vertexShaderStr << "#version 300 es\n"
<< "#extension " << kExtensionName << " : require\n"
<< "uniform vec4 u_plane;\n"
<< "in vec2 a_position;\n"
<< "void main()\n"
<< "{\n"
<< " gl_Position = vec4(a_position, 0.0, 1.0);\n"
<< " gl_ClipDistance[" << i << "] = dot(gl_Position, u_plane);\n"
<< "}";
ANGLE_GL_PROGRAM(programRed, vertexShaderStr.str().c_str(), essl3_shaders::fs::Red());
glUseProgram(programRed);
ASSERT_GL_NO_ERROR();
// Enable the current clip distance, disable all others.
for (size_t j = 0; j < 8; j++)
{
if (j == i)
glEnable(GL_CLIP_DISTANCE0_EXT + j);
else
glDisable(GL_CLIP_DISTANCE0_EXT + j);
}
// Clear to blue
glClearColor(0, 0, 1, 1);
glClear(GL_COLOR_BUFFER_BIT);
// Draw full screen quad with color red
glUniform4f(glGetUniformLocation(programRed, "u_plane"), 1, 0, 0, 0.5);
EXPECT_GL_NO_ERROR();
drawQuad(programRed, "a_position", 0);
EXPECT_GL_NO_ERROR();
// All pixels on the left of the plane x = -0.5 must be blue
GLuint x = 0;
GLuint y = 0;
GLuint width = getWindowWidth() / 4 - 1;
GLuint height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::blue);
// All pixels on the right of the plane x = -0.5 must be red
x = getWindowWidth() / 4 + 2;
y = 0;
width = getWindowWidth() - x;
height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::red);
// Clear to green
glClearColor(0, 1, 0, 1);
glClear(GL_COLOR_BUFFER_BIT);
// Draw full screen quad with color red
glUniform4f(glGetUniformLocation(programRed, "u_plane"), -1, 0, 0, -0.5);
EXPECT_GL_NO_ERROR();
drawQuad(programRed, "a_position", 0);
EXPECT_GL_NO_ERROR();
// All pixels on the left of the plane x = -0.5 must be red
x = 0;
y = 0;
width = getWindowWidth() / 4 - 1;
height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::red);
// All pixels on the right of the plane x = -0.5 must be green
x = getWindowWidth() / 4 + 2;
y = 0;
width = getWindowWidth() - x;
height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::green);
// Disable GL_CLIP_DISTANCE
glDisable(GL_CLIP_DISTANCE0_EXT + i);
drawQuad(programRed, "a_position", 0);
// All pixels must be red
x = 0;
y = 0;
width = getWindowWidth();
height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::red);
}
}
// Use 8 clip distances to draw an octagon
TEST_P(ClipCullDistanceTest, Octagon)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled(kExtensionName));
std::string kVS = R"(#version 300 es
#extension )" + kExtensionName +
R"( : require
in vec2 a_position;
void main()
{
gl_Position = vec4(a_position, 0.0, 1.0);
gl_ClipDistance[0] = dot(gl_Position, vec4( 1, 0, 0, 0.5));
gl_ClipDistance[1] = dot(gl_Position, vec4(-1, 0, 0, 0.5));
gl_ClipDistance[2] = dot(gl_Position, vec4( 0, 1, 0, 0.5));
gl_ClipDistance[3] = dot(gl_Position, vec4( 0, -1, 0, 0.5));
gl_ClipDistance[4] = dot(gl_Position, vec4( 1, 1, 0, 0.70710678));
gl_ClipDistance[5] = dot(gl_Position, vec4( 1, -1, 0, 0.70710678));
gl_ClipDistance[6] = dot(gl_Position, vec4(-1, 1, 0, 0.70710678));
gl_ClipDistance[7] = dot(gl_Position, vec4(-1, -1, 0, 0.70710678));
})";
ANGLE_GL_PROGRAM(programRed, kVS.c_str(), essl3_shaders::fs::Red());
glUseProgram(programRed);
ASSERT_GL_NO_ERROR();
glEnable(GL_CLIP_DISTANCE0_EXT);
glEnable(GL_CLIP_DISTANCE1_EXT);
glEnable(GL_CLIP_DISTANCE2_EXT);
glEnable(GL_CLIP_DISTANCE3_EXT);
glEnable(GL_CLIP_DISTANCE4_EXT);
glEnable(GL_CLIP_DISTANCE5_EXT);
glEnable(GL_CLIP_DISTANCE6_EXT);
glEnable(GL_CLIP_DISTANCE7_EXT);
// Clear to blue
glClearColor(0, 0, 1, 1);
glClear(GL_COLOR_BUFFER_BIT);
// Draw full screen quad with color red
drawQuad(programRed, "a_position", 0);
EXPECT_GL_NO_ERROR();
// Top edge
EXPECT_PIXEL_COLOR_EQ(32, 56, GLColor::blue);
EXPECT_PIXEL_COLOR_EQ(32, 40, GLColor::red);
// Top-right edge
EXPECT_PIXEL_COLOR_EQ(48, 48, GLColor::blue);
EXPECT_PIXEL_COLOR_EQ(40, 40, GLColor::red);
// Right edge
EXPECT_PIXEL_COLOR_EQ(56, 32, GLColor::blue);
EXPECT_PIXEL_COLOR_EQ(40, 32, GLColor::red);
// Bottom-right edge
EXPECT_PIXEL_COLOR_EQ(48, 16, GLColor::blue);
EXPECT_PIXEL_COLOR_EQ(40, 24, GLColor::red);
// Bottom edge
EXPECT_PIXEL_COLOR_EQ(32, 8, GLColor::blue);
EXPECT_PIXEL_COLOR_EQ(32, 24, GLColor::red);
// Bottom-left edge
EXPECT_PIXEL_COLOR_EQ(16, 16, GLColor::blue);
EXPECT_PIXEL_COLOR_EQ(24, 24, GLColor::red);
// Left edge
EXPECT_PIXEL_COLOR_EQ(8, 32, GLColor::blue);
EXPECT_PIXEL_COLOR_EQ(24, 32, GLColor::red);
// Top-left edge
EXPECT_PIXEL_COLOR_EQ(16, 48, GLColor::blue);
EXPECT_PIXEL_COLOR_EQ(24, 40, GLColor::red);
}
// Write to 3 clip distances
TEST_P(ClipCullDistanceTest, ThreeClipDistances)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled(kExtensionName));
std::string kVS = R"(#version 300 es
#extension )" + kExtensionName +
R"( : require
uniform vec4 u_plane[3];
in vec2 a_position;
void main()
{
gl_Position = vec4(a_position, 0.0, 1.0);
gl_ClipDistance[0] = dot(gl_Position, u_plane[0]);
gl_ClipDistance[3] = dot(gl_Position, u_plane[1]);
gl_ClipDistance[7] = dot(gl_Position, u_plane[2]);
})";
ANGLE_GL_PROGRAM(programRed, kVS.c_str(), essl3_shaders::fs::Red());
glUseProgram(programRed);
ASSERT_GL_NO_ERROR();
// Enable 3 clip distances
glEnable(GL_CLIP_DISTANCE0_EXT);
glEnable(GL_CLIP_DISTANCE3_EXT);
glEnable(GL_CLIP_DISTANCE7_EXT);
ASSERT_GL_NO_ERROR();
// Clear to blue
glClearColor(0, 0, 1, 1);
glClear(GL_COLOR_BUFFER_BIT);
// Draw full screen quad with color red
// x = -0.5
glUniform4f(glGetUniformLocation(programRed, "u_plane[0]"), 1, 0, 0, 0.5);
// x = 0.5
glUniform4f(glGetUniformLocation(programRed, "u_plane[1]"), -1, 0, 0, 0.5);
// x + y = 1
glUniform4f(glGetUniformLocation(programRed, "u_plane[2]"), -1, -1, 0, 1);
EXPECT_GL_NO_ERROR();
drawQuad(programRed, "a_position", 0);
EXPECT_GL_NO_ERROR();
{
// All pixels on the left of the plane x = -0.5 must be blue
GLuint x = 0;
GLuint y = 0;
GLuint width = getWindowWidth() / 4 - 1;
GLuint height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::blue);
// All pixels from the plane x = -0.5 to the plane x = 0 must be red
x = getWindowWidth() / 4 + 2;
y = 0;
width = getWindowWidth() / 2 - x;
height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::red);
}
{
// Check pixels to the right of the plane x = 0
std::vector<GLColor> actualColors(getWindowWidth() * getWindowHeight());
glReadPixels(0, 0, getWindowWidth(), getWindowHeight(), GL_RGBA, GL_UNSIGNED_BYTE,
actualColors.data());
for (int y = 0; y < getWindowHeight(); ++y)
{
for (int x = getWindowWidth() / 2; x < getWindowWidth(); ++x)
{
const int currentPosition = y * getWindowHeight() + x;
if (x < getWindowWidth() * 3 / 2 - y - 1 && x < getWindowWidth() * 3 / 4 - 1)
{
// Bottom of the plane x + y = 1 clipped by x = 0.5 plane
EXPECT_EQ(GLColor::red, actualColors[currentPosition]);
}
else if (x > getWindowWidth() * 3 / 2 - y + 1 || x > getWindowWidth() * 3 / 4 + 1)
{
// Top of the plane x + y = 1 plus right of x = 0.5 plane
EXPECT_EQ(GLColor::blue, actualColors[currentPosition]);
}
}
}
}
// Clear to green
glClearColor(0, 1, 0, 1);
glClear(GL_COLOR_BUFFER_BIT);
// Disable gl_ClipDistance[3]
glDisable(GL_CLIP_DISTANCE3_EXT);
// Draw full screen quad with color red
EXPECT_GL_NO_ERROR();
drawQuad(programRed, "a_position", 0);
EXPECT_GL_NO_ERROR();
{
// All pixels on the left of the plane x = -0.5 must be green
GLuint x = 0;
GLuint y = 0;
GLuint width = getWindowWidth() / 4 - 1;
GLuint height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::green);
// All pixels from the plane x = -0.5 to the plane x = 0 must be red
x = getWindowWidth() / 4 + 2;
y = 0;
width = getWindowWidth() / 2 - x;
height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::red);
}
// Check pixels to the right of the plane x = 0
std::vector<GLColor> actualColors(getWindowWidth() * getWindowHeight());
glReadPixels(0, 0, getWindowWidth(), getWindowHeight(), GL_RGBA, GL_UNSIGNED_BYTE,
actualColors.data());
for (int y = 0; y < getWindowHeight(); ++y)
{
for (int x = getWindowWidth() / 2; x < getWindowWidth(); ++x)
{
const int currentPosition = y * getWindowHeight() + x;
if (x < getWindowWidth() * 3 / 2 - y - 1)
{
// Bottom of the plane x + y = 1
EXPECT_EQ(GLColor::red, actualColors[currentPosition]);
}
else if (x > getWindowWidth() * 3 / 2 - y + 1)
{
// Top of the plane x + y = 1
EXPECT_EQ(GLColor::green, actualColors[currentPosition]);
}
}
}
}
// Redeclare gl_ClipDistance in shader with explicit size, also use it in a global function
// outside main()
TEST_P(ClipCullDistanceTest, ThreeClipDistancesRedeclared)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled(kExtensionName));
std::string kVS = R"(#version 300 es
#extension )" + kExtensionName +
R"( : require
out highp float gl_ClipDistance[3];
void computeClipDistances(in vec4 position, in vec4 plane[3])
{
gl_ClipDistance[0] = dot(position, plane[0]);
gl_ClipDistance[1] = dot(position, plane[1]);
gl_ClipDistance[2] = dot(position, plane[2]);
}
uniform vec4 u_plane[3];
in vec2 a_position;
void main()
{
gl_Position = vec4(a_position, 0.0, 1.0);
computeClipDistances(gl_Position, u_plane);
})";
ANGLE_GL_PROGRAM(programRed, kVS.c_str(), essl3_shaders::fs::Red());
glUseProgram(programRed);
ASSERT_GL_NO_ERROR();
// Enable 3 clip distances
glEnable(GL_CLIP_DISTANCE0_EXT);
glEnable(GL_CLIP_DISTANCE1_EXT);
glEnable(GL_CLIP_DISTANCE2_EXT);
ASSERT_GL_NO_ERROR();
// Clear to blue
glClearColor(0, 0, 1, 1);
glClear(GL_COLOR_BUFFER_BIT);
// Draw full screen quad with color red
// x = -0.5
glUniform4f(glGetUniformLocation(programRed, "u_plane[0]"), 1, 0, 0, 0.5);
// x = 0.5
glUniform4f(glGetUniformLocation(programRed, "u_plane[1]"), -1, 0, 0, 0.5);
// x + y = 1
glUniform4f(glGetUniformLocation(programRed, "u_plane[2]"), -1, -1, 0, 1);
EXPECT_GL_NO_ERROR();
drawQuad(programRed, "a_position", 0);
EXPECT_GL_NO_ERROR();
{
// All pixels on the left of the plane x = -0.5 must be blue
GLuint x = 0;
GLuint y = 0;
GLuint width = getWindowWidth() / 4 - 1;
GLuint height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::blue);
// All pixels from the plane x = -0.5 to the plane x = 0 must be red
x = getWindowWidth() / 4 + 2;
y = 0;
width = getWindowWidth() / 2 - x;
height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::red);
}
// Check pixels to the right of the plane x = 0
std::vector<GLColor> actualColors(getWindowWidth() * getWindowHeight());
glReadPixels(0, 0, getWindowWidth(), getWindowHeight(), GL_RGBA, GL_UNSIGNED_BYTE,
actualColors.data());
for (int y = 0; y < getWindowHeight(); ++y)
{
for (int x = getWindowWidth() / 2; x < getWindowWidth(); ++x)
{
const int currentPosition = y * getWindowHeight() + x;
if (x < getWindowWidth() * 3 / 2 - y - 1 && x < getWindowWidth() * 3 / 4 - 1)
{
// Bottom of the plane x + y = 1 clipped by x = 0.5 plane
EXPECT_EQ(GLColor::red, actualColors[currentPosition]);
}
else if (x > getWindowWidth() * 3 / 2 - y + 1 || x > getWindowWidth() * 3 / 4 + 1)
{
// Top of the plane x + y = 1 plus right of x = 0.5 plane
EXPECT_EQ(GLColor::blue, actualColors[currentPosition]);
}
}
}
}
// Read clip distance varyings in fragment shaders
TEST_P(ClipCullDistanceTest, ClipInterpolation)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled(kExtensionName));
std::string kVS = R"(#version 300 es
#extension )" + kExtensionName +
R"( : require
in vec2 a_position;
void main()
{
gl_Position = vec4(a_position, 0.0, 1.0);
gl_ClipDistance[0] = dot(gl_Position, vec4( 1, 0, 0, 0.5));
gl_ClipDistance[1] = dot(gl_Position, vec4(-1, 0, 0, 0.5));
gl_ClipDistance[2] = dot(gl_Position, vec4( 0, 1, 0, 0.5));
gl_ClipDistance[3] = dot(gl_Position, vec4( 0, -1, 0, 0.5));
gl_ClipDistance[4] = gl_ClipDistance[0];
gl_ClipDistance[5] = gl_ClipDistance[1];
gl_ClipDistance[6] = gl_ClipDistance[2];
gl_ClipDistance[7] = gl_ClipDistance[3];
})";
std::string kFS = R"(#version 300 es
#extension )" + kExtensionName +
R"( : require
precision highp float;
out vec4 my_FragColor;
void main()
{
float r = gl_ClipDistance[0] + gl_ClipDistance[1];
float g = gl_ClipDistance[2] + gl_ClipDistance[3];
float b = gl_ClipDistance[4] + gl_ClipDistance[5];
float a = gl_ClipDistance[6] + gl_ClipDistance[7];
my_FragColor = vec4(r, g, b, a) * 0.5;
})";
ANGLE_GL_PROGRAM(programRed, kVS.c_str(), kFS.c_str());
glUseProgram(programRed);
ASSERT_GL_NO_ERROR();
glEnable(GL_CLIP_DISTANCE0_EXT);
glEnable(GL_CLIP_DISTANCE1_EXT);
glEnable(GL_CLIP_DISTANCE2_EXT);
glEnable(GL_CLIP_DISTANCE3_EXT);
glEnable(GL_CLIP_DISTANCE4_EXT);
glEnable(GL_CLIP_DISTANCE5_EXT);
glEnable(GL_CLIP_DISTANCE6_EXT);
glEnable(GL_CLIP_DISTANCE7_EXT);
// Clear to blue
glClearColor(0, 0, 1, 1);
glClear(GL_COLOR_BUFFER_BIT);
// Draw full screen quad with color red
drawQuad(programRed, "a_position", 0);
EXPECT_GL_NO_ERROR();
std::vector<GLColor> actualColors(getWindowWidth() * getWindowHeight());
glReadPixels(0, 0, getWindowWidth(), getWindowHeight(), GL_RGBA, GL_UNSIGNED_BYTE,
actualColors.data());
for (int x = 0; x < getWindowWidth(); x++)
{
for (int y = 0; y < getWindowHeight(); y++)
{
const int currentPosition = y * getWindowHeight() + x;
if (x >= getWindowWidth() / 4 && x < getWindowWidth() * 3 / 4 &&
y >= getWindowHeight() / 4 && y < getWindowHeight() * 3 / 4)
{
EXPECT_COLOR_NEAR(GLColor(127, 127, 127, 127), actualColors[currentPosition], 1);
}
else
{
EXPECT_EQ(GLColor::blue, actualColors[currentPosition]);
}
}
}
}
// Write to one gl_CullDistance element
TEST_P(ClipCullDistanceTest, OneCullDistance)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled(kExtensionName));
std::string kVS = R"(#version 300 es
#extension )" + kExtensionName +
R"( : require
uniform vec4 u_plane;
in vec2 a_position;
void main()
{
gl_Position = vec4(a_position, 0.0, 1.0);
gl_CullDistance[0] = dot(gl_Position, u_plane);
})";
GLProgram programRed;
programRed.makeRaster(kVS.c_str(), essl3_shaders::fs::Red());
if (!mCullDistanceSupportRequired)
{
GLint maxCullDistances;
glGetIntegerv(GL_MAX_CULL_DISTANCES_EXT, &maxCullDistances);
if (maxCullDistances == 0)
{
ASSERT_FALSE(programRed.valid());
return;
}
}
glUseProgram(programRed);
ASSERT_GL_NO_ERROR();
// Clear to blue
glClearColor(0, 0, 1, 1);
glClear(GL_COLOR_BUFFER_BIT);
// Draw full screen quad with color red
glUniform4f(glGetUniformLocation(programRed, "u_plane"), 1, 0, 0, 0.5);
EXPECT_GL_NO_ERROR();
drawQuad(programRed, "a_position", 0);
EXPECT_GL_NO_ERROR();
{
// All pixels must be red
GLuint x = 0;
GLuint y = 0;
GLuint width = getWindowWidth();
GLuint height = getWindowHeight();
EXPECT_PIXEL_RECT_EQ(x, y, width, height, GLColor::red);
}
// Clear to green
glClearColor(0, 1, 0, 1);
glClear(GL_COLOR_BUFFER_BIT);
// Draw full screen quad with color red
glUniform4f(glGetUniformLocation(programRed, "u_plane"), 1, 1, 0, 0);
EXPECT_GL_NO_ERROR();
drawQuad(programRed, "a_position", 0);
EXPECT_GL_NO_ERROR();
// All pixels on the plane y >= -x must be red
std::vector<GLColor> actualColors(getWindowWidth() * getWindowHeight());
glReadPixels(0, 0, getWindowWidth(), getWindowHeight(), GL_RGBA, GL_UNSIGNED_BYTE,
actualColors.data());
for (int x = 0; x < getWindowWidth(); ++x)
{
for (int y = 0; y < getWindowHeight(); ++y)
{
const int currentPosition = y * getWindowHeight() + x;
if ((x + y) >= 0)
{
EXPECT_EQ(GLColor::red, actualColors[currentPosition]);
}
else
{
EXPECT_EQ(GLColor::green, actualColors[currentPosition]);
}
}
}
}
// Read cull distance varyings in fragment shaders
TEST_P(ClipCullDistanceTest, CullInterpolation)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled(kExtensionName));
std::string kVS = R"(#version 300 es
#extension )" + kExtensionName +
R"( : require
in vec2 a_position;
void main()
{
gl_Position = vec4(a_position, 0.0, 1.0);
gl_CullDistance[0] = dot(gl_Position, vec4( 1, 0, 0, 1));
gl_CullDistance[1] = dot(gl_Position, vec4(-1, 0, 0, 1));
gl_CullDistance[2] = dot(gl_Position, vec4( 0, 1, 0, 1));
gl_CullDistance[3] = dot(gl_Position, vec4( 0, -1, 0, 1));
gl_CullDistance[4] = gl_CullDistance[0];
gl_CullDistance[5] = gl_CullDistance[1];
gl_CullDistance[6] = gl_CullDistance[2];
gl_CullDistance[7] = gl_CullDistance[3];
})";
std::string kFS = R"(#version 300 es
#extension )" + kExtensionName +
R"( : require
precision highp float;
out vec4 my_FragColor;
void main()
{
float r = gl_CullDistance[0] + gl_CullDistance[1];
float g = gl_CullDistance[2] + gl_CullDistance[3];
float b = gl_CullDistance[4] + gl_CullDistance[5];
float a = gl_CullDistance[6] + gl_CullDistance[7];
my_FragColor = vec4(r, g, b, a) * 0.25;
})";
GLProgram programRed;
programRed.makeRaster(kVS.c_str(), kFS.c_str());
if (!mCullDistanceSupportRequired)
{
GLint maxCullDistances;
glGetIntegerv(GL_MAX_CULL_DISTANCES_EXT, &maxCullDistances);
if (maxCullDistances == 0)
{
ASSERT_FALSE(programRed.valid());
return;
}
}
glUseProgram(programRed);
ASSERT_GL_NO_ERROR();
// Clear to blue
glClearColor(0, 0, 1, 1);
glClear(GL_COLOR_BUFFER_BIT);
// Draw full screen quad with color red
drawQuad(programRed, "a_position", 0, 0.5);
EXPECT_GL_NO_ERROR();
std::vector<GLColor> actualColors(getWindowWidth() * getWindowHeight());
glReadPixels(0, 0, getWindowWidth(), getWindowHeight(), GL_RGBA, GL_UNSIGNED_BYTE,
actualColors.data());
for (int x = 0; x < getWindowWidth(); x++)
{
for (int y = 0; y < getWindowHeight(); y++)
{
const int currentPosition = y * getWindowHeight() + x;
if (x >= getWindowWidth() / 4 && x < getWindowWidth() * 3 / 4 &&
y >= getWindowHeight() / 4 && y < getWindowHeight() * 3 / 4)
{
EXPECT_COLOR_NEAR(GLColor(127, 127, 127, 127), actualColors[currentPosition], 1);
}
else
{
EXPECT_EQ(GLColor::blue, actualColors[currentPosition]);
}
}
}
}
// Read both clip and cull distance varyings in fragment shaders
TEST_P(ClipCullDistanceTest, ClipCullInterpolation)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled(kExtensionName));
std::string kVS = R"(#version 300 es
#extension )" + kExtensionName +
R"( : require
in vec2 a_position;
void main()
{
gl_Position = vec4(a_position, 0.0, 1.0);
gl_ClipDistance[0] = dot(gl_Position, vec4( 1, 0, 0, 0.5));
gl_ClipDistance[1] = dot(gl_Position, vec4(-1, 0, 0, 0.5));
gl_ClipDistance[2] = dot(gl_Position, vec4( 0, 1, 0, 0.5));
gl_ClipDistance[3] = dot(gl_Position, vec4( 0, -1, 0, 0.5));
gl_CullDistance[0] = dot(gl_Position, vec4( 1, 0, 0, 1));
gl_CullDistance[1] = dot(gl_Position, vec4(-1, 0, 0, 1));
gl_CullDistance[2] = dot(gl_Position, vec4( 0, 1, 0, 1));
gl_CullDistance[3] = dot(gl_Position, vec4( 0, -1, 0, 1));
})";
std::string kFS = R"(#version 300 es
#extension )" + kExtensionName +
R"( : require
precision highp float;
out vec4 my_FragColor;
void main()
{
my_FragColor =
vec4(gl_ClipDistance[0] + gl_ClipDistance[1],
gl_ClipDistance[2] + gl_ClipDistance[3],
gl_CullDistance[0] + gl_CullDistance[1],
gl_CullDistance[2] + gl_CullDistance[3]) *
vec4(0.5, 0.5, 0.25, 0.25);
})";
GLProgram programRed;
programRed.makeRaster(kVS.c_str(), kFS.c_str());
if (!mCullDistanceSupportRequired)
{
GLint maxCullDistances;
glGetIntegerv(GL_MAX_CULL_DISTANCES_EXT, &maxCullDistances);
if (maxCullDistances == 0)
{
ASSERT_FALSE(programRed.valid());
return;
}
}
glUseProgram(programRed);
ASSERT_GL_NO_ERROR();
glEnable(GL_CLIP_DISTANCE0_EXT);
glEnable(GL_CLIP_DISTANCE1_EXT);
glEnable(GL_CLIP_DISTANCE2_EXT);
glEnable(GL_CLIP_DISTANCE3_EXT);
// Clear to blue
glClearColor(0, 0, 1, 1);
glClear(GL_COLOR_BUFFER_BIT);
// Draw full screen quad with color red
drawQuad(programRed, "a_position", 0);
EXPECT_GL_NO_ERROR();
std::vector<GLColor> actualColors(getWindowWidth() * getWindowHeight());
glReadPixels(0, 0, getWindowWidth(), getWindowHeight(), GL_RGBA, GL_UNSIGNED_BYTE,
actualColors.data());
for (int x = 0; x < getWindowWidth(); x++)
{
for (int y = 0; y < getWindowHeight(); y++)
{
const int currentPosition = y * getWindowHeight() + x;
if (x >= getWindowWidth() / 4 && x < getWindowWidth() * 3 / 4 &&
y >= getWindowHeight() / 4 && y < getWindowHeight() * 3 / 4)
{
EXPECT_COLOR_NEAR(GLColor(127, 127, 127, 127), actualColors[currentPosition], 1);
}
else
{
EXPECT_EQ(GLColor::blue, actualColors[currentPosition]);
}
}
}
}
// Write to 4 clip distances
TEST_P(ClipCullDistanceTest, FourClipDistances)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled(kExtensionName));
std::string kVS = R"(#version 300 es
#extension )" + kExtensionName +
R"( : require
in vec2 a_position;
uniform vec4 u_plane[4];
void main()
{
gl_Position = vec4(a_position, 0.0, 1.0);
gl_ClipDistance[0] = dot(gl_Position, u_plane[0]);
gl_ClipDistance[1] = dot(gl_Position, u_plane[1]);
gl_ClipDistance[2] = dot(gl_Position, u_plane[2]);
gl_ClipDistance[3] = dot(gl_Position, u_plane[3]);
})";
ANGLE_GL_PROGRAM(programRed, kVS.c_str(), essl3_shaders::fs::Red());
glUseProgram(programRed);
ASSERT_GL_NO_ERROR();
// Enable 3 clip distances
glEnable(GL_CLIP_DISTANCE0_EXT);
glEnable(GL_CLIP_DISTANCE2_EXT);
glEnable(GL_CLIP_DISTANCE3_EXT);
ASSERT_GL_NO_ERROR();
// Disable 1 clip distances
glDisable(GL_CLIP_DISTANCE1_EXT);
ASSERT_GL_NO_ERROR();
// Clear to blue
glClearColor(0, 0, 1, 1);
glClear(GL_COLOR_BUFFER_BIT);
constexpr unsigned int kNumVertices = 12;
const std::array<Vector3, kNumVertices> quadVertices = {
{Vector3(-1.0f, 1.0f, 0.0f), Vector3(0.0f, 0.0f, 0.0f), Vector3(1.0f, 1.0f, 0.0f),
Vector3(1.0f, 1.0f, 0.0f), Vector3(0.0f, 0.0f, 0.0f), Vector3(1.0f, -1.0f, 0.0f),
Vector3(1.0f, -1.0f, 0.0f), Vector3(0.0f, 0.0f, 0.0f), Vector3(-1.0f, -1.0f, 0.0f),
Vector3(-1.0f, -1.0f, 0.0f), Vector3(0.0f, 0.0f, 0.0f), Vector3(-1.0f, 1.0f, 0.0f)}};
GLBuffer vertexBuffer;
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 3 * kNumVertices, quadVertices.data(),
GL_STATIC_DRAW);
ASSERT_GL_NO_ERROR();
GLint positionLocation = glGetAttribLocation(programRed, "a_position");
glVertexAttribPointer(positionLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
ASSERT_GL_NO_ERROR();
glEnableVertexAttribArray(positionLocation);
ASSERT_GL_NO_ERROR();
// Draw full screen quad and small size triangle with color red
// y <= 1.0f
glUniform4f(glGetUniformLocation(programRed, "u_plane[0]"), 0, -1, 0, 1);
// y >= 0.5f
glUniform4f(glGetUniformLocation(programRed, "u_plane[1]"), 0, 1, 0, -0.5);
// y >= 3x-0.5f
glUniform4f(glGetUniformLocation(programRed, "u_plane[2]"), -3, 1, 0, 0.5);
// y >= -3x-0.5f
glUniform4f(glGetUniformLocation(programRed, "u_plane[3]"), 3, 1, 0, 0.5);
EXPECT_GL_NO_ERROR();
glDrawArrays(GL_TRIANGLES, 0, kNumVertices);
EXPECT_GL_NO_ERROR();
const int windowWidth = getWindowWidth();
const int windowHeight = getWindowHeight();
auto checkLeftPlaneFunc = [windowWidth, windowHeight](int x, int y) -> float {
return (3 * (x - (windowWidth / 2 - 1)) - (windowHeight / 4 + 1) + y);
};
auto checkRightPlaneFunc = [windowWidth, windowHeight](int x, int y) -> float {
return (-3 * (x - (windowWidth / 2)) - (windowHeight / 4 + 1) + y);
};
// Only pixels in the triangle must be red
std::vector<GLColor> actualColors(getWindowWidth() * getWindowHeight());
glReadPixels(0, 0, getWindowWidth(), getWindowHeight(), GL_RGBA, GL_UNSIGNED_BYTE,
actualColors.data());
for (int x = 0; x < getWindowWidth(); ++x)
{
for (int y = 0; y < getWindowHeight(); ++y)
{
// The drawing method of Swiftshader and Native graphic card is different. So the
// compare function doesn't check the value on the line.
const int currentPosition = y * getWindowHeight() + x;
if (checkLeftPlaneFunc(x, y) > 0 && checkRightPlaneFunc(x, y) > 0)
{
EXPECT_EQ(GLColor::red, actualColors[currentPosition]);
}
else if (checkLeftPlaneFunc(x, y) < 0 || checkRightPlaneFunc(x, y) < 0)
{
EXPECT_EQ(GLColor::blue, actualColors[currentPosition]);
}
}
}
}
// Write to 4 cull distances
TEST_P(ClipCullDistanceTest, FourCullDistances)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled(kExtensionName));
// SwiftShader bug: http://anglebug.com/42263990
ANGLE_SKIP_TEST_IF(isSwiftshader());
std::string kVS = R"(#version 300 es
#extension )" + kExtensionName +
R"( : require
uniform vec4 u_plane[4];
in vec2 a_position;
void main()
{
gl_Position = vec4(a_position, 0.0, 1.0);
gl_CullDistance[0] = dot(gl_Position, u_plane[0]);
gl_CullDistance[1] = dot(gl_Position, u_plane[1]);
gl_CullDistance[2] = dot(gl_Position, u_plane[2]);
gl_CullDistance[3] = dot(gl_Position, u_plane[3]);
})";
GLProgram programRed;
programRed.makeRaster(kVS.c_str(), essl3_shaders::fs::Red());
if (!mCullDistanceSupportRequired)
{
GLint maxCullDistances;
glGetIntegerv(GL_MAX_CULL_DISTANCES_EXT, &maxCullDistances);
if (maxCullDistances == 0)
{
ASSERT_FALSE(programRed.valid());
return;
}
}
glUseProgram(programRed);
ASSERT_GL_NO_ERROR();
// Clear to blue
glClearColor(0, 0, 1, 1);
glClear(GL_COLOR_BUFFER_BIT);
constexpr unsigned int kNumVertices = 12;
const std::array<Vector2, kNumVertices> quadVertices = {
{Vector2(-1.0f, 1.0f), Vector2(0.0f, 0.0f), Vector2(1.0f, 1.0f), Vector2(1.0f, 1.0f),
Vector2(0.0f, 0.0f), Vector2(1.0f, -1.0f), Vector2(1.0f, -1.0f), Vector2(0.0f, 0.0f),
Vector2(-1.0f, -1.0f), Vector2(-1.0f, -1.0f), Vector2(0.0f, 0.0f), Vector2(-1.0f, 1.0f)}};
GLBuffer vertexBuffer;
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 2 * kNumVertices, quadVertices.data(),
GL_STATIC_DRAW);
ASSERT_GL_NO_ERROR();
GLint positionLocation = glGetAttribLocation(programRed, "a_position");
glVertexAttribPointer(positionLocation, 2, GL_FLOAT, GL_FALSE, 0, 0);
ASSERT_GL_NO_ERROR();
glEnableVertexAttribArray(positionLocation);
ASSERT_GL_NO_ERROR();
// Draw full screen quad and small size triangle with color red
// y <= 1.0f
glUniform4f(glGetUniformLocation(programRed, "u_plane[0]"), 0, -1, 0, 1);
// y >= 0.5f
glUniform4f(glGetUniformLocation(programRed, "u_plane[1]"), 0, 1, 0, -0.5);
// y >= 3x-0.5f
glUniform4f(glGetUniformLocation(programRed, "u_plane[2]"), -3, 1, 0, 0.5);
// y >= -3x-0.5f
glUniform4f(glGetUniformLocation(programRed, "u_plane[3]"), 3, 1, 0, 0.5);
EXPECT_GL_NO_ERROR();
glDrawArrays(GL_TRIANGLES, 0, kNumVertices);
EXPECT_GL_NO_ERROR();
// Only the bottom triangle must be culled
std::vector<GLColor> actualColors(getWindowWidth() * getWindowHeight());
glReadPixels(0, 0, getWindowWidth(), getWindowHeight(), GL_RGBA, GL_UNSIGNED_BYTE,
actualColors.data());
for (int x = 0; x < getWindowWidth(); ++x)
{
for (int y = 0; y < getWindowHeight(); ++y)
{
const int currentPosition = y * getWindowHeight() + x;
if (y > x || y >= -x + getWindowHeight() - 1)
{
EXPECT_EQ(GLColor::red, actualColors[currentPosition]);
}
else
{
EXPECT_EQ(GLColor::blue, actualColors[currentPosition]);
}
}
}
}
// Verify that EXT_clip_cull_distance works with EXT_geometry_shader
TEST_P(ClipCullDistanceTest, ClipDistanceInteractWithGeometryShader)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled(kExtensionName) ||
!EnsureGLExtensionEnabled("GL_EXT_geometry_shader"));
std::string kVS = R"(#version 310 es
#extension )" + kExtensionName +
R"( : require
#extension GL_EXT_geometry_shader : require
in vec2 a_position;
uniform vec4 u_plane[4];
void main()
{
gl_Position = vec4(a_position, 0.0, 1.0);
gl_ClipDistance[0] = dot(gl_Position, u_plane[0]);
gl_ClipDistance[1] = dot(gl_Position, u_plane[1]);
gl_ClipDistance[2] = dot(gl_Position, u_plane[2]);
gl_ClipDistance[3] = dot(gl_Position, u_plane[3]);
})";
std::string kGS = R"(#version 310 es
#extension )" + kExtensionName +
R"( : require
#extension GL_EXT_geometry_shader : require
layout (triangles) in;
layout (triangle_strip, max_vertices = 3) out;
in gl_PerVertex {
highp vec4 gl_Position;
highp float gl_ClipDistance[];
} gl_in[];
out gl_PerVertex {
highp vec4 gl_Position;
highp float gl_ClipDistance[];
};
uniform vec4 u_plane[4];
void GetNewPosition(int i)
{
gl_Position = 2.0f * gl_in[i].gl_Position;
for (int index = 0 ; index < 4 ; index++)
{
if (gl_in[i].gl_ClipDistance[index] < 0.0f)
{
gl_ClipDistance[index] = dot(gl_Position, u_plane[index]);
}
}
EmitVertex();
}
void main()
{
for (int i = 0 ; i < 3 ; i++)
{
GetNewPosition(i);
}
EndPrimitive();
})";
ANGLE_GL_PROGRAM_WITH_GS(programRed, kVS.c_str(), kGS.c_str(), essl31_shaders::fs::Red());
glUseProgram(programRed);
ASSERT_GL_NO_ERROR();
// Enable 3 clip distances
glEnable(GL_CLIP_DISTANCE0_EXT);
glEnable(GL_CLIP_DISTANCE2_EXT);
glEnable(GL_CLIP_DISTANCE3_EXT);
ASSERT_GL_NO_ERROR();
// Disable 1 clip distances
glDisable(GL_CLIP_DISTANCE1_EXT);
ASSERT_GL_NO_ERROR();
// Clear to blue
glClearColor(0, 0, 1, 1);
glClear(GL_COLOR_BUFFER_BIT);
constexpr unsigned int kNumVertices = 12;
const std::array<Vector3, kNumVertices> quadVertices = {
{Vector3(-0.5f, 0.5f, 0.0f), Vector3(0.0f, 0.0f, 0.0f), Vector3(0.5f, 0.5f, 0.0f),
Vector3(0.5f, 0.5f, 0.0f), Vector3(0.0f, 0.0f, 0.0f), Vector3(0.5f, -0.5f, 0.0f),
Vector3(0.5f, -0.5f, 0.0f), Vector3(0.0f, 0.0f, 0.0f), Vector3(-0.5f, -0.5f, 0.0f),
Vector3(-0.5f, -0.5f, 0.0f), Vector3(0.0f, 0.0f, 0.0f), Vector3(-0.5f, 0.5f, 0.0f)}};
GLBuffer vertexBuffer;
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 3 * kNumVertices, quadVertices.data(),
GL_STATIC_DRAW);
ASSERT_GL_NO_ERROR();
GLint positionLocation = glGetAttribLocation(programRed, "a_position");
glVertexAttribPointer(positionLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
ASSERT_GL_NO_ERROR();
glEnableVertexAttribArray(positionLocation);
ASSERT_GL_NO_ERROR();
// Draw full screen quad and small size triangle with color red
// y <= 1.0f
glUniform4f(glGetUniformLocation(programRed, "u_plane[0]"), 0, -1, 0, 1);
// y >= 0.5f
glUniform4f(glGetUniformLocation(programRed, "u_plane[1]"), 0, 1, 0, -0.5);
// y >= 3x-0.5f
glUniform4f(glGetUniformLocation(programRed, "u_plane[2]"), -3, 1, 0, 0.5);
// y >= -3x-0.5f
glUniform4f(glGetUniformLocation(programRed, "u_plane[3]"), 3, 1, 0, 0.5);
EXPECT_GL_NO_ERROR();
glDrawArrays(GL_TRIANGLES, 0, kNumVertices);
EXPECT_GL_NO_ERROR();
const int windowWidth = getWindowWidth();
const int windowHeight = getWindowHeight();
auto checkLeftPlaneFunc = [windowWidth, windowHeight](int x, int y) -> float {
return (3 * (x - (windowWidth / 2 - 1)) - (windowHeight / 4 + 1) + y);
};
auto checkRightPlaneFunc = [windowWidth, windowHeight](int x, int y) -> float {
return (-3 * (x - (windowWidth / 2)) - (windowHeight / 4 + 1) + y);
};
// Only pixels in the triangle must be red
std::vector<GLColor> actualColors(getWindowWidth() * getWindowHeight());
glReadPixels(0, 0, getWindowWidth(), getWindowHeight(), GL_RGBA, GL_UNSIGNED_BYTE,
actualColors.data());
for (int x = 0; x < getWindowWidth(); ++x)
{
for (int y = 0; y < getWindowHeight(); ++y)
{
// The drawing method of Swiftshader and Native graphic card is different. So the
// compare function doesn't check the value on the line.
const int currentPosition = y * getWindowHeight() + x;
if (checkLeftPlaneFunc(x, y) > 0 && checkRightPlaneFunc(x, y) > 0)
{
EXPECT_EQ(GLColor::red, actualColors[currentPosition]);
}
else if (checkLeftPlaneFunc(x, y) < 0 || checkRightPlaneFunc(x, y) < 0)
{
EXPECT_EQ(GLColor::blue, actualColors[currentPosition]);
}
}
}
}
// Verify that EXT_clip_cull_distance works with EXT_geometry_shader
TEST_P(ClipCullDistanceTest, CullDistanceInteractWithGeometryShader)
{
ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled(kExtensionName) ||
!EnsureGLExtensionEnabled("GL_EXT_geometry_shader"));
std::string kVS = R"(#version 310 es
#extension )" + kExtensionName +
R"( : require
#extension GL_EXT_geometry_shader : require
in vec2 a_position;
uniform vec4 u_plane[4];
void main()
{
gl_Position = vec4(a_position, 0.0, 1.0);
gl_CullDistance[0] = dot(gl_Position, u_plane[0]);
gl_CullDistance[1] = dot(gl_Position, u_plane[1]);
gl_CullDistance[2] = dot(gl_Position, u_plane[2]);
gl_CullDistance[3] = dot(gl_Position, u_plane[3]);
})";
std::string kGS = R"(#version 310 es
#extension )" + kExtensionName +
R"( : require
#extension GL_EXT_geometry_shader : require
layout (triangles) in;
layout (triangle_strip, max_vertices = 3) out;
in gl_PerVertex {
highp vec4 gl_Position;
highp float gl_CullDistance[];
} gl_in[];
out gl_PerVertex {
highp vec4 gl_Position;
highp float gl_CullDistance[];
};
uniform vec4 u_plane[4];
void GetNewPosition(int i)
{
gl_Position = 2.0f * gl_in[i].gl_Position;
for (int index = 0 ; index < 4 ; index++)
{
if (gl_in[i].gl_CullDistance[index] < 0.0f)
{
gl_CullDistance[index] = dot(gl_Position, u_plane[index]);
}
}
EmitVertex();
}
void main()
{
for (int i = 0 ; i < 3 ; i++)
{
GetNewPosition(i);
}
EndPrimitive();
})";
GLProgram programRed;
programRed.makeRaster(kVS.c_str(), kGS.c_str(), essl3_shaders::fs::Red());
if (!mCullDistanceSupportRequired)
{
GLint maxCullDistances;
glGetIntegerv(GL_MAX_CULL_DISTANCES_EXT, &maxCullDistances);
if (maxCullDistances == 0)
{
ASSERT_FALSE(programRed.valid());
return;
}
}
glUseProgram(programRed);
ASSERT_GL_NO_ERROR();
// Clear to blue
glClearColor(0, 0, 1, 1);
glClear(GL_COLOR_BUFFER_BIT);
constexpr unsigned int kNumVertices = 12;
const std::array<Vector3, kNumVertices> quadVertices = {
{Vector3(-0.5f, 0.5f, 0.0f), Vector3(0.0f, 0.0f, 0.0f), Vector3(0.5f, 0.5f, 0.0f),
Vector3(0.5f, 0.5f, 0.0f), Vector3(0.0f, 0.0f, 0.0f), Vector3(0.5f, -0.5f, 0.0f),
Vector3(0.5f, -0.5f, 0.0f), Vector3(0.0f, 0.0f, 0.0f), Vector3(-0.5f, -0.5f, 0.0f),
Vector3(-0.5f, -0.5f, 0.0f), Vector3(0.0f, 0.0f, 0.0f), Vector3(-0.5f, 0.5f, 0.0f)}};
GLBuffer vertexBuffer;
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 3 * kNumVertices, quadVertices.data(),
GL_STATIC_DRAW);
ASSERT_GL_NO_ERROR();
GLint positionLocation = glGetAttribLocation(programRed, "a_position");
glVertexAttribPointer(positionLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
ASSERT_GL_NO_ERROR();
glEnableVertexAttribArray(positionLocation);
ASSERT_GL_NO_ERROR();
// Draw full screen quad and small size triangle with color red
// y <= 1.0f
glUniform4f(glGetUniformLocation(programRed, "u_plane[0]"), 0, -1, 0, 1);
// y >= 0.5f
glUniform4f(glGetUniformLocation(programRed, "u_plane[1]"), 0, 1, 0, -0.5);
// y >= 3x-0.5f
glUniform4f(glGetUniformLocation(programRed, "u_plane[2]"), -3, 1, 0, 0.5);
// y >= -3x-0.5f
glUniform4f(glGetUniformLocation(programRed, "u_plane[3]"), 3, 1, 0, 0.5);
EXPECT_GL_NO_ERROR();
glDrawArrays(GL_TRIANGLES, 0, kNumVertices);
EXPECT_GL_NO_ERROR();
// Only pixels in the triangle must be red
std::vector<GLColor> actualColors(getWindowWidth() * getWindowHeight());
glReadPixels(0, 0, getWindowWidth(), getWindowHeight(), GL_RGBA, GL_UNSIGNED_BYTE,
actualColors.data());
for (int x = 0; x < getWindowWidth(); ++x)
{
for (int y = 0; y < getWindowHeight(); ++y)
{
const int currentPosition = y * getWindowHeight() + x;
if (y > x || y >= -x + getWindowHeight() - 1)
{
EXPECT_EQ(GLColor::red, actualColors[currentPosition]);
}
else
{
EXPECT_EQ(GLColor::blue, actualColors[currentPosition]);
}
}
}
}
ANGLE_INSTANTIATE_TEST_ES2_AND_ES3(ClipDistanceAPPLETest);
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(ClipCullDistanceTest);
ANGLE_INSTANTIATE_TEST_COMBINE_1(ClipCullDistanceTest,
PrintToStringParamName,
testing::Bool(),
ANGLE_ALL_TEST_PLATFORMS_ES3,
ANGLE_ALL_TEST_PLATFORMS_ES31);