Edit
kc3-lang/angle/src/tests/gl_tests/PathRenderingTest.cpp
Branch :
-
Show log
Commit
-
Author :
Fredrik Hubinette
Date : 2016-12-13 14:08:44
Hash : 5714a202
Message : D3D11: Add RGB10_A2 as a supported EGL pbuffer config format. Update EGLWindow to select configs that exactly match the requested config. Too many tests make assumptions about the default framebuffer's format. BUG=angleproject:1662 Change-Id: I4cf8aedf51013ca0f3f40f6bbd40f24a4a90561f Reviewed-on: https://chromium-review.googlesource.com/419681 Reviewed-by: Jamie Madill <jmadill@chromium.org> Commit-Queue: Geoff Lang <geofflang@chromium.org>
- src/tests/gl_tests/PathRenderingTest.cpp
-
// // Copyright 2016 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. // // CHROMIUMPathRenderingTest // Test CHROMIUM subset of NV_path_rendering // This extension allows to render geometric paths as first class GL objects. #include "test_utils/ANGLETest.h" #include "shader_utils.h" #include "common/angleutils.h" #include <cmath> #include <cstring> #include <cstddef> #include <fstream> using namespace angle; namespace { bool CheckPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLint tolerance, const angle::GLColor &color) { for (GLint yy = 0; yy < height; ++yy) { for (GLint xx = 0; xx < width; ++xx) { const auto px = x + xx; const auto py = y + yy; EXPECT_PIXEL_NEAR(px, py, color.R, color.G, color.B, color.A, tolerance); } } return true; } void ExpectEqualMatrix(const GLfloat *expected, const GLfloat *actual) { for (size_t i = 0; i < 16; ++i) { EXPECT_EQ(expected[i], actual[i]); } } void ExpectEqualMatrix(const GLfloat *expected, const GLint *actual) { for (size_t i = 0; i < 16; ++i) { EXPECT_EQ(static_cast<GLint>(std::roundf(expected[i])), actual[i]); } } const int kResolution = 300; class CHROMIUMPathRenderingTest : public ANGLETest { protected: CHROMIUMPathRenderingTest() { setWindowWidth(kResolution); setWindowHeight(kResolution); setConfigRedBits(8); setConfigGreenBits(8); setConfigBlueBits(8); setConfigAlphaBits(8); setConfigDepthBits(24); setConfigStencilBits(8); } bool isApplicable() const { return extensionEnabled("GL_CHROMIUM_path_rendering"); } void tryAllDrawFunctions(GLuint path, GLenum err) { glStencilFillPathCHROMIUM(path, GL_COUNT_UP_CHROMIUM, 0x7F); EXPECT_GL_ERROR(err); glStencilFillPathCHROMIUM(path, GL_COUNT_DOWN_CHROMIUM, 0x7F); EXPECT_GL_ERROR(err); glStencilStrokePathCHROMIUM(path, 0x80, 0x80); EXPECT_GL_ERROR(err); glCoverFillPathCHROMIUM(path, GL_BOUNDING_BOX_CHROMIUM); EXPECT_GL_ERROR(err); glCoverStrokePathCHROMIUM(path, GL_BOUNDING_BOX_CHROMIUM); EXPECT_GL_ERROR(err); glStencilThenCoverStrokePathCHROMIUM(path, 0x80, 0x80, GL_BOUNDING_BOX_CHROMIUM); EXPECT_GL_ERROR(err); glStencilThenCoverFillPathCHROMIUM(path, GL_COUNT_UP_CHROMIUM, 0x7F, GL_BOUNDING_BOX_CHROMIUM); EXPECT_GL_ERROR(err); } }; // Test setting and getting of path rendering matrices. TEST_P(CHROMIUMPathRenderingTest, TestMatrix) { if (!isApplicable()) return; static const GLfloat kIdentityMatrix[16] = {1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f}; static const GLfloat kSeqMatrix[16] = {0.5f, -0.5f, -0.1f, -0.8f, 4.4f, 5.5f, 6.6f, 7.7f, 8.8f, 9.9f, 10.11f, 11.22f, 12.33f, 13.44f, 14.55f, 15.66f}; static const GLenum kMatrixModes[] = {GL_PATH_MODELVIEW_CHROMIUM, GL_PATH_PROJECTION_CHROMIUM}; static const GLenum kGetMatrixModes[] = {GL_PATH_MODELVIEW_MATRIX_CHROMIUM, GL_PATH_PROJECTION_MATRIX_CHROMIUM}; for (size_t i = 0; i < 2; ++i) { GLfloat mf[16]; GLint mi[16]; std::memset(mf, 0, sizeof(mf)); std::memset(mi, 0, sizeof(mi)); glGetFloatv(kGetMatrixModes[i], mf); glGetIntegerv(kGetMatrixModes[i], mi); ExpectEqualMatrix(kIdentityMatrix, mf); ExpectEqualMatrix(kIdentityMatrix, mi); glMatrixLoadfCHROMIUM(kMatrixModes[i], kSeqMatrix); std::memset(mf, 0, sizeof(mf)); std::memset(mi, 0, sizeof(mi)); glGetFloatv(kGetMatrixModes[i], mf); glGetIntegerv(kGetMatrixModes[i], mi); ExpectEqualMatrix(kSeqMatrix, mf); ExpectEqualMatrix(kSeqMatrix, mi); glMatrixLoadIdentityCHROMIUM(kMatrixModes[i]); std::memset(mf, 0, sizeof(mf)); std::memset(mi, 0, sizeof(mi)); glGetFloatv(kGetMatrixModes[i], mf); glGetIntegerv(kGetMatrixModes[i], mi); ExpectEqualMatrix(kIdentityMatrix, mf); ExpectEqualMatrix(kIdentityMatrix, mi); ASSERT_GL_NO_ERROR(); } } // Test that trying to set incorrect matrix target results // in a GL error. TEST_P(CHROMIUMPathRenderingTest, TestMatrixErrors) { if (!isApplicable()) return; GLfloat mf[16]; std::memset(mf, 0, sizeof(mf)); glMatrixLoadfCHROMIUM(GL_PATH_MODELVIEW_CHROMIUM, mf); ASSERT_GL_NO_ERROR(); glMatrixLoadIdentityCHROMIUM(GL_PATH_PROJECTION_CHROMIUM); ASSERT_GL_NO_ERROR(); // Test that invalid matrix targets fail. glMatrixLoadfCHROMIUM(GL_PATH_MODELVIEW_CHROMIUM - 1, mf); EXPECT_GL_ERROR(GL_INVALID_ENUM); // Test that invalid matrix targets fail. glMatrixLoadIdentityCHROMIUM(GL_PATH_PROJECTION_CHROMIUM + 1); EXPECT_GL_ERROR(GL_INVALID_ENUM); } // Test basic path create and delete. TEST_P(CHROMIUMPathRenderingTest, TestGenDelete) { if (!isApplicable()) return; // This is unspecified in NV_path_rendering. EXPECT_EQ(0u, glGenPathsCHROMIUM(0)); EXPECT_GL_ERROR(GL_INVALID_VALUE); GLuint path = glGenPathsCHROMIUM(1); EXPECT_NE(0u, path); glDeletePathsCHROMIUM(path, 1); ASSERT_GL_NO_ERROR(); GLuint first_path = glGenPathsCHROMIUM(5); EXPECT_NE(0u, first_path); glDeletePathsCHROMIUM(first_path, 5); ASSERT_GL_NO_ERROR(); // Test deleting paths that are not actually allocated: // "unused names in /paths/ are silently ignored". first_path = glGenPathsCHROMIUM(5); EXPECT_NE(0u, first_path); glDeletePathsCHROMIUM(first_path, 6); ASSERT_GL_NO_ERROR(); GLsizei big_range = 0xffff; first_path = glGenPathsCHROMIUM(big_range); EXPECT_NE(0u, first_path); glDeletePathsCHROMIUM(first_path, big_range); ASSERT_GL_NO_ERROR(); // Test glIsPathCHROMIUM(). A path object is not considered a path untill // it has actually been specified with a path data. path = glGenPathsCHROMIUM(1); ASSERT_TRUE(glIsPathCHROMIUM(path) == GL_FALSE); // specify the data. GLubyte commands[] = {GL_MOVE_TO_CHROMIUM, GL_CLOSE_PATH_CHROMIUM}; GLfloat coords[] = {50.0f, 50.0f}; glPathCommandsCHROMIUM(path, 2, commands, 2, GL_FLOAT, coords); ASSERT_TRUE(glIsPathCHROMIUM(path) == GL_TRUE); glDeletePathsCHROMIUM(path, 1); ASSERT_TRUE(glIsPathCHROMIUM(path) == GL_FALSE); } // Test incorrect path creation and deletion and expect GL errors. TEST_P(CHROMIUMPathRenderingTest, TestGenDeleteErrors) { if (!isApplicable()) return; // GenPaths / DeletePaths tests. // std::numeric_limits<GLuint>::max() is wrong for GLsizei. GLuint first_path = glGenPathsCHROMIUM(std::numeric_limits<GLuint>::max()); EXPECT_EQ(first_path, 0u); EXPECT_GL_ERROR(GL_INVALID_VALUE); first_path = glGenPathsCHROMIUM(-1); EXPECT_EQ(0u, first_path); EXPECT_GL_ERROR(GL_INVALID_VALUE); glDeletePathsCHROMIUM(1, -5); EXPECT_GL_ERROR(GL_INVALID_VALUE); first_path = glGenPathsCHROMIUM(-1); EXPECT_EQ(0u, first_path); EXPECT_GL_ERROR(GL_INVALID_VALUE); } // Test setting and getting path parameters. TEST_P(CHROMIUMPathRenderingTest, TestPathParameter) { if (!isApplicable()) return; GLuint path = glGenPathsCHROMIUM(1); // specify the data. GLubyte commands[] = {GL_MOVE_TO_CHROMIUM, GL_CLOSE_PATH_CHROMIUM}; GLfloat coords[] = {50.0f, 50.0f}; glPathCommandsCHROMIUM(path, 2, commands, 2, GL_FLOAT, coords); ASSERT_GL_NO_ERROR(); EXPECT_TRUE(glIsPathCHROMIUM(path) == GL_TRUE); static const GLenum kEndCaps[] = {GL_FLAT_CHROMIUM, GL_SQUARE_CHROMIUM, GL_ROUND_CHROMIUM}; for (std::size_t i = 0; i < 3; ++i) { GLint x; glPathParameteriCHROMIUM(path, GL_PATH_END_CAPS_CHROMIUM, static_cast<GLenum>(kEndCaps[i])); ASSERT_GL_NO_ERROR(); glGetPathParameterivCHROMIUM(path, GL_PATH_END_CAPS_CHROMIUM, &x); ASSERT_GL_NO_ERROR(); EXPECT_EQ(kEndCaps[i], static_cast<GLenum>(x)); GLfloat f; glPathParameterfCHROMIUM(path, GL_PATH_END_CAPS_CHROMIUM, static_cast<GLfloat>(kEndCaps[(i + 1) % 3])); glGetPathParameterfvCHROMIUM(path, GL_PATH_END_CAPS_CHROMIUM, &f); ASSERT_GL_NO_ERROR(); EXPECT_EQ(kEndCaps[(i + 1) % 3], static_cast<GLenum>(f)); } static const GLenum kJoinStyles[] = {GL_MITER_REVERT_CHROMIUM, GL_BEVEL_CHROMIUM, GL_ROUND_CHROMIUM}; for (std::size_t i = 0; i < 3; ++i) { GLint x; glPathParameteriCHROMIUM(path, GL_PATH_JOIN_STYLE_CHROMIUM, static_cast<GLenum>(kJoinStyles[i])); ASSERT_GL_NO_ERROR(); glGetPathParameterivCHROMIUM(path, GL_PATH_JOIN_STYLE_CHROMIUM, &x); ASSERT_GL_NO_ERROR(); EXPECT_EQ(kJoinStyles[i], static_cast<GLenum>(x)); GLfloat f; glPathParameterfCHROMIUM(path, GL_PATH_JOIN_STYLE_CHROMIUM, static_cast<GLfloat>(kJoinStyles[(i + 1) % 3])); ASSERT_GL_NO_ERROR(); glGetPathParameterfvCHROMIUM(path, GL_PATH_JOIN_STYLE_CHROMIUM, &f); ASSERT_GL_NO_ERROR(); EXPECT_EQ(kJoinStyles[(i + 1) % 3], static_cast<GLenum>(f)); } { glPathParameterfCHROMIUM(path, GL_PATH_STROKE_WIDTH_CHROMIUM, 5.0f); ASSERT_GL_NO_ERROR(); GLfloat f; glGetPathParameterfvCHROMIUM(path, GL_PATH_STROKE_WIDTH_CHROMIUM, &f); EXPECT_EQ(5.0f, f); } glDeletePathsCHROMIUM(path, 1); } // Test that setting incorrect path parameter generates GL error. TEST_P(CHROMIUMPathRenderingTest, TestPathParameterErrors) { if (!isApplicable()) return; GLuint path = glGenPathsCHROMIUM(1); // PathParameter*: Wrong value for the pname should fail. glPathParameteriCHROMIUM(path, GL_PATH_JOIN_STYLE_CHROMIUM, GL_FLAT_CHROMIUM); EXPECT_GL_ERROR(GL_INVALID_ENUM); glPathParameterfCHROMIUM(path, GL_PATH_END_CAPS_CHROMIUM, GL_MITER_REVERT_CHROMIUM); EXPECT_GL_ERROR(GL_INVALID_ENUM); // PathParameter*: Wrong floating-point value should fail. glPathParameterfCHROMIUM(path, GL_PATH_STROKE_WIDTH_CHROMIUM, -0.1f); EXPECT_GL_ERROR(GL_INVALID_VALUE); // PathParameter*: Wrong pname should fail. glPathParameteriCHROMIUM(path, GL_PATH_STROKE_WIDTH_CHROMIUM - 1, 5); EXPECT_GL_ERROR(GL_INVALID_ENUM); glDeletePathsCHROMIUM(path, 1); } // Test expected path object state. TEST_P(CHROMIUMPathRenderingTest, TestPathObjectState) { if (!isApplicable()) return; glViewport(0, 0, kResolution, kResolution); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glStencilMask(0xffffffff); glClearStencil(0); glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); glPathStencilFuncCHROMIUM(GL_ALWAYS, 0, 0xFF); glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO); ASSERT_GL_NO_ERROR(); // Test that trying to draw non-existing paths does not produce errors or results. GLuint non_existing_paths[] = {0, 55, 74744}; for (auto &p : non_existing_paths) { EXPECT_TRUE(glIsPathCHROMIUM(p) == GL_FALSE); ASSERT_GL_NO_ERROR(); tryAllDrawFunctions(p, GL_NO_ERROR); } // Path name marked as used but without path object state causes // a GL error upon any draw command. GLuint path = glGenPathsCHROMIUM(1); EXPECT_TRUE(glIsPathCHROMIUM(path) == GL_FALSE); tryAllDrawFunctions(path, GL_INVALID_OPERATION); glDeletePathsCHROMIUM(path, 1); // Document a bit of an inconsistency: path name marked as used but without // path object state causes a GL error upon any draw command (tested above). // Path name that had path object state, but then was "cleared", still has a // path object state, even though the state is empty. path = glGenPathsCHROMIUM(1); EXPECT_TRUE(glIsPathCHROMIUM(path) == GL_FALSE); GLubyte commands[] = {GL_MOVE_TO_CHROMIUM, GL_CLOSE_PATH_CHROMIUM}; GLfloat coords[] = {50.0f, 50.0f}; glPathCommandsCHROMIUM(path, 2, commands, 2, GL_FLOAT, coords); EXPECT_TRUE(glIsPathCHROMIUM(path) == GL_TRUE); glPathCommandsCHROMIUM(path, 0, NULL, 0, GL_FLOAT, NULL); EXPECT_TRUE(glIsPathCHROMIUM(path) == GL_TRUE); // The surprise. tryAllDrawFunctions(path, GL_NO_ERROR); glDeletePathsCHROMIUM(path, 1); // Make sure nothing got drawn by the drawing commands that should not produce // anything. const angle::GLColor black = {0, 0, 0, 0}; EXPECT_TRUE(CheckPixels(0, 0, kResolution, kResolution, 0, black)); } // Test that trying to use path object that doesn't exist generates // a GL error. TEST_P(CHROMIUMPathRenderingTest, TestUnnamedPathsErrors) { if (!isApplicable()) return; // Unnamed paths: Trying to create a path object with non-existing path name // produces error. (Not a error in real NV_path_rendering). ASSERT_GL_NO_ERROR(); GLubyte commands[] = {GL_MOVE_TO_CHROMIUM, GL_CLOSE_PATH_CHROMIUM}; GLfloat coords[] = {50.0f, 50.0f}; glPathCommandsCHROMIUM(555, 2, commands, 2, GL_FLOAT, coords); EXPECT_GL_ERROR(GL_INVALID_OPERATION); // PathParameter*: Using non-existing path object produces error. ASSERT_GL_NO_ERROR(); glPathParameterfCHROMIUM(555, GL_PATH_STROKE_WIDTH_CHROMIUM, 5.0f); EXPECT_GL_ERROR(GL_INVALID_OPERATION); ASSERT_GL_NO_ERROR(); glPathParameteriCHROMIUM(555, GL_PATH_JOIN_STYLE_CHROMIUM, GL_ROUND_CHROMIUM); EXPECT_GL_ERROR(GL_INVALID_OPERATION); } // Test that setting incorrect path data generates a GL error. TEST_P(CHROMIUMPathRenderingTest, TestPathCommandsErrors) { if (!isApplicable()) return; static const GLenum kInvalidCoordType = GL_NONE; GLuint path = glGenPathsCHROMIUM(1); GLubyte commands[] = {GL_MOVE_TO_CHROMIUM, GL_CLOSE_PATH_CHROMIUM}; GLfloat coords[] = {50.0f, 50.0f}; glPathCommandsCHROMIUM(path, 2, commands, -4, GL_FLOAT, coords); EXPECT_GL_ERROR(GL_INVALID_VALUE); glPathCommandsCHROMIUM(path, -1, commands, 2, GL_FLOAT, coords); EXPECT_GL_ERROR(GL_INVALID_VALUE); glPathCommandsCHROMIUM(path, 2, commands, 2, kInvalidCoordType, coords); EXPECT_GL_ERROR(GL_INVALID_ENUM); // incorrect number of coordinates glPathCommandsCHROMIUM(path, 2, commands, std::numeric_limits<GLsizei>::max(), GL_FLOAT, coords); EXPECT_GL_ERROR(GL_INVALID_VALUE); // This should fail due to cmd count + coord count * short size. glPathCommandsCHROMIUM(path, 2, commands, std::numeric_limits<GLsizei>::max(), GL_SHORT, coords); EXPECT_GL_ERROR(GL_INVALID_OPERATION); glDeletePathsCHROMIUM(path, 1); } // Test that trying to render a path with invalid arguments // generates a GL error. TEST_P(CHROMIUMPathRenderingTest, TestPathRenderingInvalidArgs) { if (!isApplicable()) return; GLuint path = glGenPathsCHROMIUM(1); glPathCommandsCHROMIUM(path, 0, NULL, 0, GL_FLOAT, NULL); // Verify that normal calls work. glStencilFillPathCHROMIUM(path, GL_COUNT_UP_CHROMIUM, 0x7F); ASSERT_GL_NO_ERROR(); glStencilThenCoverFillPathCHROMIUM(path, GL_COUNT_UP_CHROMIUM, 0x7F, GL_BOUNDING_BOX_CHROMIUM); ASSERT_GL_NO_ERROR(); // Using invalid fill mode causes INVALID_ENUM. glStencilFillPathCHROMIUM(path, GL_COUNT_UP_CHROMIUM - 1, 0x7F); EXPECT_GL_ERROR(GL_INVALID_ENUM); glStencilThenCoverFillPathCHROMIUM(path, GL_COUNT_UP_CHROMIUM - 1, 0x7F, GL_BOUNDING_BOX_CHROMIUM); EXPECT_GL_ERROR(GL_INVALID_ENUM); // Using invalid cover mode causes INVALID_ENUM. glCoverFillPathCHROMIUM(path, GL_CONVEX_HULL_CHROMIUM - 1); EXPECT_EQ(static_cast<GLenum>(GL_INVALID_ENUM), glGetError()); glStencilThenCoverFillPathCHROMIUM(path, GL_COUNT_UP_CHROMIUM, 0x7F, GL_BOUNDING_BOX_CHROMIUM + 1); EXPECT_GL_ERROR(GL_INVALID_ENUM); // Using mask+1 not being power of two causes INVALID_VALUE with up/down fill mode glStencilFillPathCHROMIUM(path, GL_COUNT_UP_CHROMIUM, 0x40); EXPECT_GL_ERROR(GL_INVALID_VALUE); glStencilThenCoverFillPathCHROMIUM(path, GL_COUNT_DOWN_CHROMIUM, 12, GL_BOUNDING_BOX_CHROMIUM); EXPECT_GL_ERROR(GL_INVALID_VALUE); // check incorrect instance parameters. // CoverFillPathInstanced { glCoverFillPathInstancedCHROMIUM(-1, GL_UNSIGNED_INT, &path, 0, GL_CONVEX_HULL_CHROMIUM, GL_NONE, NULL); EXPECT_GL_ERROR(GL_INVALID_VALUE); glCoverFillPathInstancedCHROMIUM(1, GL_FLOAT, &path, 0, GL_CONVEX_HULL_CHROMIUM, GL_NONE, NULL); EXPECT_GL_ERROR(GL_INVALID_ENUM); glCoverFillPathInstancedCHROMIUM(1, GL_UNSIGNED_INT, NULL, 0, GL_CONVEX_HULL_CHROMIUM, GL_NONE, NULL); EXPECT_GL_ERROR(GL_INVALID_VALUE); glCoverFillPathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, GL_UNSIGNED_INT, GL_NONE, NULL); EXPECT_GL_ERROR(GL_INVALID_ENUM); glCoverFillPathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, GL_CONVEX_HULL_CHROMIUM, GL_UNSIGNED_INT, NULL); EXPECT_GL_ERROR(GL_INVALID_ENUM); glCoverFillPathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, GL_CONVEX_HULL_CHROMIUM, GL_TRANSLATE_X_CHROMIUM, NULL); EXPECT_GL_ERROR(GL_INVALID_VALUE); } // CoverStrokePathInstanced { glCoverStrokePathInstancedCHROMIUM(-1, GL_UNSIGNED_INT, &path, 0, GL_CONVEX_HULL_CHROMIUM, GL_NONE, NULL); EXPECT_GL_ERROR(GL_INVALID_VALUE); glCoverStrokePathInstancedCHROMIUM(1, GL_FLOAT, &path, 0, GL_CONVEX_HULL_CHROMIUM, GL_NONE, NULL); EXPECT_GL_ERROR(GL_INVALID_ENUM); glCoverStrokePathInstancedCHROMIUM(1, GL_UNSIGNED_INT, NULL, 0, GL_CONVEX_HULL_CHROMIUM, GL_NONE, NULL); EXPECT_GL_ERROR(GL_INVALID_VALUE); glCoverStrokePathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, GL_UNSIGNED_INT, GL_NONE, NULL); EXPECT_GL_ERROR(GL_INVALID_ENUM); glCoverStrokePathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, GL_CONVEX_HULL_CHROMIUM, GL_UNSIGNED_INT, NULL); EXPECT_GL_ERROR(GL_INVALID_ENUM); glCoverStrokePathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, GL_CONVEX_HULL_CHROMIUM, GL_TRANSLATE_X_CHROMIUM, NULL); EXPECT_GL_ERROR(GL_INVALID_VALUE); } // StencilFillPathInstanced { glStencilFillPathInstancedCHROMIUM(-1, GL_UNSIGNED_INT, &path, 0, GL_COUNT_UP_CHROMIUM, 0x0, GL_NONE, NULL); EXPECT_GL_ERROR(GL_INVALID_VALUE); glStencilFillPathInstancedCHROMIUM(1, GL_FLOAT, &path, 0, GL_COUNT_UP_CHROMIUM, 0x0, GL_NONE, NULL); EXPECT_GL_ERROR(GL_INVALID_ENUM); glStencilFillPathInstancedCHROMIUM(1, GL_UNSIGNED_INT, NULL, 0, GL_COUNT_UP_CHROMIUM, 0x0, GL_NONE, NULL); EXPECT_GL_ERROR(GL_INVALID_VALUE); glStencilFillPathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, GL_UNSIGNED_INT, 0x0, GL_NONE, NULL); EXPECT_GL_ERROR(GL_INVALID_ENUM); glStencilFillPathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, GL_COUNT_UP_CHROMIUM, 0x2, GL_NONE, NULL); EXPECT_GL_ERROR(GL_INVALID_VALUE); glStencilFillPathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, GL_COUNT_UP_CHROMIUM, 0x0, GL_UNSIGNED_INT, NULL); EXPECT_GL_ERROR(GL_INVALID_ENUM); glStencilFillPathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, GL_COUNT_UP_CHROMIUM, 0x0, GL_TRANSLATE_X_CHROMIUM, NULL); EXPECT_GL_ERROR(GL_INVALID_VALUE); } // StencilStrokePathInstanced { glStencilStrokePathInstancedCHROMIUM(-1, GL_UNSIGNED_INT, &path, 0, 0x00, 0x00, GL_NONE, NULL); EXPECT_GL_ERROR(GL_INVALID_VALUE); glStencilStrokePathInstancedCHROMIUM(1, GL_FLOAT, &path, 0, 0x00, 0x00, GL_NONE, NULL); EXPECT_GL_ERROR(GL_INVALID_ENUM); glStencilStrokePathInstancedCHROMIUM(1, GL_UNSIGNED_INT, nullptr, 0, 0x00, 0x00, GL_NONE, NULL); EXPECT_GL_ERROR(GL_INVALID_VALUE); glStencilStrokePathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, 0x00, 0x00, GL_UNSIGNED_INT, NULL); EXPECT_GL_ERROR(GL_INVALID_ENUM); glStencilStrokePathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, 0x00, 0x00, GL_TRANSLATE_X_CHROMIUM, NULL); EXPECT_GL_ERROR(GL_INVALID_VALUE); } // StencilThenCoverFillPathInstanced { glStencilThenCoverFillPathInstancedCHROMIUM(-1, GL_UNSIGNED_INT, &path, 0, GL_COUNT_UP_CHROMIUM, 0, GL_COUNT_UP_CHROMIUM, GL_NONE, NULL); EXPECT_GL_ERROR(GL_INVALID_VALUE); glStencilThenCoverFillPathInstancedCHROMIUM(1, GL_FLOAT, &path, 0, GL_CONVEX_HULL_CHROMIUM, 0, GL_COUNT_UP_CHROMIUM, GL_NONE, NULL); EXPECT_GL_ERROR(GL_INVALID_ENUM); glStencilThenCoverFillPathInstancedCHROMIUM(1, GL_UNSIGNED_INT, NULL, 0, GL_CONVEX_HULL_CHROMIUM, 0, GL_COUNT_UP_CHROMIUM, GL_NONE, NULL); EXPECT_GL_ERROR(GL_INVALID_VALUE); glStencilThenCoverFillPathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, GL_UNSIGNED_INT, 0, GL_COUNT_UP_CHROMIUM, GL_NONE, NULL); EXPECT_GL_ERROR(GL_INVALID_ENUM); glStencilThenCoverFillPathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, GL_CONVEX_HULL_CHROMIUM, 0, GL_UNSIGNED_INT, GL_NONE, NULL); EXPECT_GL_ERROR(GL_INVALID_ENUM); glStencilThenCoverFillPathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, GL_CONVEX_HULL_CHROMIUM, 0, GL_COUNT_UP_CHROMIUM, GL_FLOAT, NULL); EXPECT_GL_ERROR(GL_INVALID_ENUM); glStencilThenCoverFillPathInstancedCHROMIUM( 1, GL_UNSIGNED_INT, &path, 0, GL_CONVEX_HULL_CHROMIUM, 0, GL_COUNT_UP_CHROMIUM, GL_TRANSLATE_X_CHROMIUM, NULL); EXPECT_GL_ERROR(GL_INVALID_VALUE); } // StencilThenCoverStrokePathInstanced { glStencilThenCoverStrokePathInstancedCHROMIUM(-1, GL_UNSIGNED_INT, &path, 0, 0x0, 0x0, GL_CONVEX_HULL_CHROMIUM, GL_NONE, NULL); EXPECT_GL_ERROR(GL_INVALID_VALUE); glStencilThenCoverStrokePathInstancedCHROMIUM(1, GL_FLOAT, &path, 0, 0x0, 0x0, GL_CONVEX_HULL_CHROMIUM, GL_NONE, NULL); EXPECT_GL_ERROR(GL_INVALID_ENUM); glStencilThenCoverStrokePathInstancedCHROMIUM(1, GL_UNSIGNED_INT, NULL, 0, 0x0, 0x0, GL_CONVEX_HULL_CHROMIUM, GL_NONE, NULL); EXPECT_GL_ERROR(GL_INVALID_VALUE); glStencilThenCoverStrokePathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, 0x0, 0x0, GL_FLOAT, GL_NONE, NULL); EXPECT_GL_ERROR(GL_INVALID_ENUM); glStencilThenCoverStrokePathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, 0x0, 0x0, GL_CONVEX_HULL_CHROMIUM, GL_FLOAT, NULL); EXPECT_GL_ERROR(GL_INVALID_ENUM); glStencilThenCoverStrokePathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, 0x0, 0x0, GL_CONVEX_HULL_CHROMIUM, GL_TRANSLATE_X_CHROMIUM, NULL); EXPECT_GL_ERROR(GL_INVALID_VALUE); } glDeletePathsCHROMIUM(path, 1); } const GLfloat kProjectionMatrix[16] = {2.0f / kResolution, 0.0f, 0.0f, 0.0f, 0.0f, 2.0f / kResolution, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, -1.0f, -1.0f, 0.0f, 1.0f}; class CHROMIUMPathRenderingDrawTest : public ANGLETest { protected: CHROMIUMPathRenderingDrawTest() { setWindowWidth(kResolution); setWindowHeight(kResolution); setConfigRedBits(8); setConfigGreenBits(8); setConfigBlueBits(8); setConfigAlphaBits(8); setConfigDepthBits(24); setConfigStencilBits(8); } bool isApplicable() const { return extensionEnabled("GL_CHROMIUM_path_rendering"); } void setupStateForTestPattern() { glViewport(0, 0, kResolution, kResolution); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glStencilMask(0xffffffff); glClearStencil(0); glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); glEnable(GL_STENCIL_TEST); static const char *kVertexShaderSource = "void main() {\n" " gl_Position = vec4(1.0); \n" "}"; static const char *kFragmentShaderSource = "precision mediump float;\n" "uniform vec4 color;\n" "void main() {\n" " gl_FragColor = color;\n" "}"; GLuint program = CompileProgram(kVertexShaderSource, kFragmentShaderSource); glUseProgram(program); mColorLoc = glGetUniformLocation(program, "color"); glDeleteProgram(program); // Set up orthogonal projection with near/far plane distance of 2. glMatrixLoadfCHROMIUM(GL_PATH_PROJECTION_CHROMIUM, kProjectionMatrix); glMatrixLoadIdentityCHROMIUM(GL_PATH_MODELVIEW_CHROMIUM); ASSERT_GL_NO_ERROR(); } void setupPathStateForTestPattern(GLuint path) { static const GLubyte kCommands[] = {GL_MOVE_TO_CHROMIUM, GL_LINE_TO_CHROMIUM, GL_QUADRATIC_CURVE_TO_CHROMIUM, GL_CUBIC_CURVE_TO_CHROMIUM, GL_CLOSE_PATH_CHROMIUM}; static const GLfloat kCoords[] = {50.0f, 50.0f, 75.0f, 75.0f, 100.0f, 62.5f, 50.0f, 25.5f, 0.0f, 62.5f, 50.0f, 50.0f, 25.0f, 75.0f}; glPathCommandsCHROMIUM(path, 5, kCommands, 14, GL_FLOAT, kCoords); glPathParameterfCHROMIUM(path, GL_PATH_STROKE_WIDTH_CHROMIUM, 5.0f); glPathParameterfCHROMIUM(path, GL_PATH_MITER_LIMIT_CHROMIUM, 1.0f); glPathParameterfCHROMIUM(path, GL_PATH_STROKE_BOUND_CHROMIUM, .02f); glPathParameteriCHROMIUM(path, GL_PATH_JOIN_STYLE_CHROMIUM, GL_ROUND_CHROMIUM); glPathParameteriCHROMIUM(path, GL_PATH_END_CAPS_CHROMIUM, GL_SQUARE_CHROMIUM); ASSERT_GL_NO_ERROR(); } void verifyTestPatternFill(GLfloat flx, GLfloat fly) { static const GLint kFillCoords[] = {55, 54, 50, 28, 66, 63}; static const angle::GLColor kBlue = {0, 0, 255, 255}; GLint x = static_cast<GLint>(flx); GLint y = static_cast<GLint>(fly); for (size_t i = 0; i < 6; i += 2) { GLint fx = kFillCoords[i]; GLint fy = kFillCoords[i + 1]; EXPECT_TRUE(CheckPixels(x + fx, y + fy, 1, 1, 0, kBlue)); } } void verifyTestPatternBg(GLfloat fx, GLfloat fy) { static const GLint kBackgroundCoords[] = {80, 80, 20, 20, 90, 1}; static const angle::GLColor kExpectedColor = {0, 0, 0, 0}; GLint x = static_cast<GLint>(fx); GLint y = static_cast<GLint>(fy); for (size_t i = 0; i < 6; i += 2) { GLint bx = kBackgroundCoords[i]; GLint by = kBackgroundCoords[i + 1]; EXPECT_TRUE(CheckPixels(x + bx, y + by, 1, 1, 0, kExpectedColor)); } } void verifyTestPatternStroke(GLfloat fx, GLfloat fy) { GLint x = static_cast<GLint>(fx); GLint y = static_cast<GLint>(fy); // Inside the stroke we should have green. static const angle::GLColor kGreen = {0, 255, 0, 255}; EXPECT_TRUE(CheckPixels(x + 50, y + 53, 1, 1, 0, kGreen)); EXPECT_TRUE(CheckPixels(x + 26, y + 76, 1, 1, 0, kGreen)); // Outside the path we should have black. static const angle::GLColor black = {0, 0, 0, 0}; EXPECT_TRUE(CheckPixels(x + 10, y + 10, 1, 1, 0, black)); EXPECT_TRUE(CheckPixels(x + 80, y + 80, 1, 1, 0, black)); } GLuint mColorLoc; }; // Tests that basic path rendering functions work. TEST_P(CHROMIUMPathRenderingDrawTest, TestPathRendering) { if (!isApplicable()) return; static const float kBlue[] = {0.0f, 0.0f, 1.0f, 1.0f}; static const float kGreen[] = {0.0f, 1.0f, 0.0f, 1.0f}; setupStateForTestPattern(); GLuint path = glGenPathsCHROMIUM(1); setupPathStateForTestPattern(path); // Do the stencil fill, cover fill, stencil stroke, cover stroke // in unconventional order: // 1) stencil the stroke in stencil high bit // 2) stencil the fill in low bits // 3) cover the fill // 4) cover the stroke // This is done to check that glPathStencilFunc works, eg the mask // goes through. Stencil func is not tested ATM, for simplicity. glPathStencilFuncCHROMIUM(GL_ALWAYS, 0, 0xFF); glStencilStrokePathCHROMIUM(path, 0x80, 0x80); glPathStencilFuncCHROMIUM(GL_ALWAYS, 0, 0x7F); glStencilFillPathCHROMIUM(path, GL_COUNT_UP_CHROMIUM, 0x7F); glStencilFunc(GL_LESS, 0, 0x7F); glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO); glUniform4fv(mColorLoc, 1, kBlue); glCoverFillPathCHROMIUM(path, GL_BOUNDING_BOX_CHROMIUM); glStencilFunc(GL_EQUAL, 0x80, 0x80); glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO); glUniform4fv(mColorLoc, 1, kGreen); glCoverStrokePathCHROMIUM(path, GL_CONVEX_HULL_CHROMIUM); glDeletePathsCHROMIUM(path, 1); ASSERT_GL_NO_ERROR(); // Verify the image. verifyTestPatternFill(0, 0); verifyTestPatternBg(0, 0); verifyTestPatternStroke(0, 0); } // Test that StencilThen{Stroke,Fill} path rendering functions work TEST_P(CHROMIUMPathRenderingDrawTest, TestPathRenderingThenFunctions) { if (!isApplicable()) return; static float kBlue[] = {0.0f, 0.0f, 1.0f, 1.0f}; static float kGreen[] = {0.0f, 1.0f, 0.0f, 1.0f}; setupStateForTestPattern(); GLuint path = glGenPathsCHROMIUM(1); setupPathStateForTestPattern(path); glPathStencilFuncCHROMIUM(GL_ALWAYS, 0, 0xFF); glStencilFunc(GL_EQUAL, 0x80, 0x80); glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO); glUniform4fv(mColorLoc, 1, kGreen); glStencilThenCoverStrokePathCHROMIUM(path, 0x80, 0x80, GL_BOUNDING_BOX_CHROMIUM); glPathStencilFuncCHROMIUM(GL_ALWAYS, 0, 0x7F); glStencilFunc(GL_LESS, 0, 0x7F); glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO); glUniform4fv(mColorLoc, 1, kBlue); glStencilThenCoverFillPathCHROMIUM(path, GL_COUNT_UP_CHROMIUM, 0x7F, GL_CONVEX_HULL_CHROMIUM); glDeletePathsCHROMIUM(path, 1); // Verify the image. verifyTestPatternFill(0, 0); verifyTestPatternBg(0, 0); verifyTestPatternStroke(0, 0); } // Tests that drawing with *Instanced functions work. TEST_P(CHROMIUMPathRenderingDrawTest, TestPathRenderingInstanced) { if (!isApplicable()) return; static const float kBlue[] = {0.0f, 0.0f, 1.0f, 1.0f}; static const float kGreen[] = {0.0f, 1.0f, 0.0f, 1.0f}; setupStateForTestPattern(); GLuint path = glGenPathsCHROMIUM(1); setupPathStateForTestPattern(path); const GLuint kPaths[] = {1, 1, 1, 1, 1}; const GLsizei kPathCount = 5; const GLfloat kShapeSize = 80.0f; static const GLfloat kTransforms[kPathCount * 12] = { 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, kShapeSize, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, kShapeSize * 2, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, kShapeSize, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, kShapeSize, kShapeSize, 0.0f}; // The test pattern is the same as in the simple draw case above, // except that the path is drawn kPathCount times with different offsets. glPathStencilFuncCHROMIUM(GL_ALWAYS, 0, 0xFF); glStencilStrokePathInstancedCHROMIUM(kPathCount, GL_UNSIGNED_INT, kPaths, path - 1, 0x80, 0x80, GL_AFFINE_3D_CHROMIUM, kTransforms); glPathStencilFuncCHROMIUM(GL_ALWAYS, 0, 0x7F); glUniform4fv(mColorLoc, 1, kBlue); glStencilFillPathInstancedCHROMIUM(kPathCount, GL_UNSIGNED_INT, kPaths, path - 1, GL_COUNT_UP_CHROMIUM, 0x7F, GL_AFFINE_3D_CHROMIUM, kTransforms); ASSERT_GL_NO_ERROR(); glStencilFunc(GL_LESS, 0, 0x7F); glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO); glCoverFillPathInstancedCHROMIUM(kPathCount, GL_UNSIGNED_INT, kPaths, path - 1, GL_BOUNDING_BOX_OF_BOUNDING_BOXES_CHROMIUM, GL_AFFINE_3D_CHROMIUM, kTransforms); ASSERT_GL_NO_ERROR(); glStencilFunc(GL_EQUAL, 0x80, 0x80); glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO); glUniform4fv(mColorLoc, 1, kGreen); glCoverStrokePathInstancedCHROMIUM(kPathCount, GL_UNSIGNED_INT, kPaths, path - 1, GL_BOUNDING_BOX_OF_BOUNDING_BOXES_CHROMIUM, GL_AFFINE_3D_CHROMIUM, kTransforms); ASSERT_GL_NO_ERROR(); glDeletePathsCHROMIUM(path, 1); // Verify the image. verifyTestPatternFill(0.0f, 0.0f); verifyTestPatternBg(0.0f, 0.0f); verifyTestPatternStroke(0.0f, 0.0f); verifyTestPatternFill(kShapeSize, 0.0f); verifyTestPatternBg(kShapeSize, 0.0f); verifyTestPatternStroke(kShapeSize, 0.0f); verifyTestPatternFill(kShapeSize * 2, 0.0f); verifyTestPatternBg(kShapeSize * 2, 0.0f); verifyTestPatternStroke(kShapeSize * 2, 0.0f); verifyTestPatternFill(0.0f, kShapeSize); verifyTestPatternBg(0.0f, kShapeSize); verifyTestPatternStroke(0.0f, kShapeSize); verifyTestPatternFill(kShapeSize, kShapeSize); verifyTestPatternBg(kShapeSize, kShapeSize); verifyTestPatternStroke(kShapeSize, kShapeSize); } // Test that instanced fill/stroke then cover functions work. TEST_P(CHROMIUMPathRenderingDrawTest, TestPathRenderingThenFunctionsInstanced) { if (!isApplicable()) return; static const float kBlue[] = {0.0f, 0.0f, 1.0f, 1.0f}; static const float kGreen[] = {0.0f, 1.0f, 0.0f, 1.0f}; setupStateForTestPattern(); GLuint path = glGenPathsCHROMIUM(1); setupPathStateForTestPattern(path); const GLuint kPaths[] = {1, 1, 1, 1, 1}; const GLsizei kPathCount = 5; const GLfloat kShapeSize = 80.0f; static const GLfloat kTransforms[] = { 0.0f, 0.0f, kShapeSize, 0.0f, kShapeSize * 2, 0.0f, 0.0f, kShapeSize, kShapeSize, kShapeSize, }; glPathStencilFuncCHROMIUM(GL_ALWAYS, 0, 0xFF); glStencilFunc(GL_EQUAL, 0x80, 0x80); glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO); glUniform4fv(mColorLoc, 1, kGreen); glStencilThenCoverStrokePathInstancedCHROMIUM( kPathCount, GL_UNSIGNED_INT, kPaths, path - 1, 0x80, 0x80, GL_BOUNDING_BOX_OF_BOUNDING_BOXES_CHROMIUM, GL_TRANSLATE_2D_CHROMIUM, kTransforms); ASSERT_GL_NO_ERROR(); glPathStencilFuncCHROMIUM(GL_ALWAYS, 0, 0x7F); glStencilFunc(GL_LESS, 0, 0x7F); glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO); glUniform4fv(mColorLoc, 1, kBlue); glStencilThenCoverFillPathInstancedCHROMIUM( kPathCount, GL_UNSIGNED_INT, kPaths, path - 1, GL_COUNT_UP_CHROMIUM, 0x7F, GL_BOUNDING_BOX_OF_BOUNDING_BOXES_CHROMIUM, GL_TRANSLATE_2D_CHROMIUM, kTransforms); ASSERT_GL_NO_ERROR(); glDeletePathsCHROMIUM(path, 1); // Verify the image. verifyTestPatternFill(0.0f, 0.0f); verifyTestPatternBg(0.0f, 0.0f); verifyTestPatternStroke(0.0f, 0.0f); verifyTestPatternFill(kShapeSize, 0.0f); verifyTestPatternBg(kShapeSize, 0.0f); verifyTestPatternStroke(kShapeSize, 0.0f); verifyTestPatternFill(kShapeSize * 2, 0.0f); verifyTestPatternBg(kShapeSize * 2, 0.0f); verifyTestPatternStroke(kShapeSize * 2, 0.0f); verifyTestPatternFill(0.0f, kShapeSize); verifyTestPatternBg(0.0f, kShapeSize); verifyTestPatternStroke(0.0f, kShapeSize); verifyTestPatternFill(kShapeSize, kShapeSize); verifyTestPatternBg(kShapeSize, kShapeSize); verifyTestPatternStroke(kShapeSize, kShapeSize); } // This class implements a test that draws a grid of v-shapes. The grid is // drawn so that even rows (from the bottom) are drawn with DrawArrays and odd // rows are drawn with path rendering. It can be used to test various texturing // modes, comparing how the fill would work in normal GL rendering and how to // setup same sort of fill with path rendering. // The texturing test is parametrized to run the test with and without // ANGLE name hashing. class CHROMIUMPathRenderingWithTexturingTest : public ANGLETest { protected: CHROMIUMPathRenderingWithTexturingTest() : mProgram(0) { setWindowWidth(kResolution); setWindowHeight(kResolution); setConfigRedBits(8); setConfigGreenBits(8); setConfigBlueBits(8); setConfigAlphaBits(8); setConfigDepthBits(24); setConfigStencilBits(8); } bool isApplicable() const { return extensionEnabled("GL_CHROMIUM_path_rendering"); } void TearDown() override { if (mProgram) { glDeleteProgram(mProgram); ASSERT_GL_NO_ERROR(); } ANGLETest::TearDown(); } void SetUp() override { ANGLETest::SetUp(); mBindUniformLocation = reinterpret_cast<PFNGLBINDUNIFORMLOCATIONCHROMIUMPROC>( eglGetProcAddress("glBindUniformLocationCHROMIUM")); } // Sets up the GL program state for the test. // Vertex shader needs at least following variables: // uniform mat4 view_matrix; // uniform mat? color_matrix; (accessible with kColorMatrixLocation) // uniform vec2 model_translate; // attribute vec2 position; // varying vec4 color; // // Fragment shader needs at least following variables: // varying vec4 color; // // (? can be anything) void compileProgram(const char *vertexShaderSource, const char *fragmentShaderSource) { glViewport(0, 0, kResolution, kResolution); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glStencilMask(0xffffffff); glClearStencil(0); glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); ASSERT_GL_NO_ERROR(); GLuint vShader = compileShader(GL_VERTEX_SHADER, vertexShaderSource); GLuint fShader = compileShader(GL_FRAGMENT_SHADER, fragmentShaderSource); ASSERT_NE(0u, vShader); ASSERT_NE(0u, fShader); mProgram = glCreateProgram(); glAttachShader(mProgram, vShader); glAttachShader(mProgram, fShader); glDeleteShader(vShader); glDeleteShader(fShader); ASSERT_GL_NO_ERROR(); } void bindProgram() { glBindAttribLocation(mProgram, kPositionLocation, "position"); mBindUniformLocation(mProgram, kViewMatrixLocation, "view_matrix"); mBindUniformLocation(mProgram, kColorMatrixLocation, "color_matrix"); mBindUniformLocation(mProgram, kModelTranslateLocation, "model_translate"); glBindFragmentInputLocationCHROMIUM(mProgram, kColorFragmentInputLocation, "color"); ASSERT_GL_NO_ERROR(); } bool linkProgram() { glLinkProgram(mProgram); GLint linked = 0; glGetProgramiv(mProgram, GL_LINK_STATUS, &linked); if (linked) { glUseProgram(mProgram); } return (linked == 1); } void drawTestPattern() { // This v-shape is used both for DrawArrays and path rendering. static const GLfloat kVertices[] = {75.0f, 75.0f, 50.0f, 25.5f, 50.0f, 50.0f, 25.0f, 75.0f}; GLuint vbo = 0; glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); glBufferData(GL_ARRAY_BUFFER, sizeof(kVertices), kVertices, GL_STATIC_DRAW); glEnableVertexAttribArray(kPositionLocation); glVertexAttribPointer(kPositionLocation, 2, GL_FLOAT, GL_FALSE, 0, 0); // Setup state for drawing the shape with path rendering. glPathStencilFuncCHROMIUM(GL_ALWAYS, 0, 0x7F); glStencilFunc(GL_LESS, 0, 0x7F); glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO); glMatrixLoadfCHROMIUM(GL_PATH_PROJECTION_CHROMIUM, kProjectionMatrix); glMatrixLoadIdentityCHROMIUM(GL_PATH_MODELVIEW_CHROMIUM); static const GLubyte kCommands[] = {GL_MOVE_TO_CHROMIUM, GL_LINE_TO_CHROMIUM, GL_LINE_TO_CHROMIUM, GL_LINE_TO_CHROMIUM, GL_CLOSE_PATH_CHROMIUM}; static const GLfloat kCoords[] = { kVertices[0], kVertices[1], kVertices[2], kVertices[3], kVertices[6], kVertices[7], kVertices[4], kVertices[5], }; GLuint path = glGenPathsCHROMIUM(1); glPathCommandsCHROMIUM(path, static_cast<GLsizei>(ArraySize(kCommands)), kCommands, static_cast<GLsizei>(ArraySize(kCoords)), GL_FLOAT, kCoords); ASSERT_GL_NO_ERROR(); GLfloat path_model_translate[16] = { 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, }; // Draws the shapes. Every even row from the bottom is drawn with // DrawArrays, odd row with path rendering. The shader program is // the same for the both draws. for (int j = 0; j < kTestRows; ++j) { for (int i = 0; i < kTestColumns; ++i) { if (j % 2 == 0) { glDisable(GL_STENCIL_TEST); glUniform2f(kModelTranslateLocation, static_cast<GLfloat>(i * kShapeWidth), static_cast<GLfloat>(j * kShapeHeight)); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); } else { glEnable(GL_STENCIL_TEST); path_model_translate[12] = static_cast<GLfloat>(i * kShapeWidth); path_model_translate[13] = static_cast<GLfloat>(j * kShapeHeight); glMatrixLoadfCHROMIUM(GL_PATH_MODELVIEW_CHROMIUM, path_model_translate); glStencilThenCoverFillPathCHROMIUM(path, GL_COUNT_UP_CHROMIUM, 0x7F, GL_BOUNDING_BOX_CHROMIUM); } } } ASSERT_GL_NO_ERROR(); glDisableVertexAttribArray(kPositionLocation); glDeleteBuffers(1, &vbo); glDeletePathsCHROMIUM(path, 1); ASSERT_GL_NO_ERROR(); } enum { kShapeWidth = 75, kShapeHeight = 75, kTestRows = kResolution / kShapeHeight, kTestColumns = kResolution / kShapeWidth, }; typedef void(GL_APIENTRYP PFNGLBINDUNIFORMLOCATIONCHROMIUMPROC)(GLuint mProgram, GLint location, const GLchar *name); PFNGLBINDUNIFORMLOCATIONCHROMIUMPROC mBindUniformLocation = nullptr; GLuint mProgram; // This uniform be can set by the test. It should be used to set the color for // drawing with DrawArrays. static const GLint kColorMatrixLocation = 4; // This fragment input can be set by the test. It should be used to set the // color for drawing with path rendering. static const GLint kColorFragmentInputLocation = 7; static const GLint kModelTranslateLocation = 3; static const GLint kPositionLocation = 0; static const GLint kViewMatrixLocation = 7; }; // Test success and error cases for binding fragment input location. TEST_P(CHROMIUMPathRenderingWithTexturingTest, TestBindFragmentInputLocation) { if (!isApplicable()) return; // original NV_path_rendering specification doesn't define whether the // fragment shader input variables should be defined in the vertex shader or // not. In fact it doesn't even require a vertex shader. // However the GLES3.1 spec basically says that fragment inputs are // either built-ins or come from the previous shader stage. // (ยง 14.1, Fragment Shader Variables). // Additionally there are many places that are based on the assumption of having // a vertex shader (command buffer, angle) so we're going to stick to the same // semantics and require a vertex shader and to have the vertex shader define the // varying fragment shader input. // clang-format off const char* kVertexShaderSource = "varying vec4 color;\n" "void main() {}\n"; const char* kFragmentShaderSource = "precision mediump float;\n" "varying vec4 color;\n" "void main() {\n" " gl_FragColor = vec4(1.0);\n" "}\n"; // clang-format on compileProgram(kVertexShaderSource, kFragmentShaderSource); enum kBindLocations { kColorLocation = 5, kFragColorLocation = 6 }; // successful bind. glBindFragmentInputLocationCHROMIUM(mProgram, kColorLocation, "color"); ASSERT_GL_NO_ERROR(); // any name can be bound and names that do not actually exist in the program after // linking are ignored. glBindFragmentInputLocationCHROMIUM(mProgram, kColorLocation, "doesnt_exist"); ASSERT_GL_NO_ERROR(); // illegal program glBindFragmentInputLocationCHROMIUM(mProgram + 1, kColorLocation, "color"); EXPECT_GL_ERROR(GL_INVALID_OPERATION); // illegal bind (built-in) glBindFragmentInputLocationCHROMIUM(mProgram, kFragColorLocation, "gl_FragColor"); EXPECT_GL_ERROR(GL_INVALID_OPERATION); glBindFragmentInputLocationCHROMIUM(mProgram, kFragColorLocation, NULL); EXPECT_GL_ERROR(GL_INVALID_VALUE); glBindFragmentInputLocationCHROMIUM(mProgram, 0xffffff, "color"); EXPECT_GL_ERROR(GL_INVALID_VALUE); ASSERT_TRUE(linkProgram() == true); const GLfloat kCoefficients16[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f}; glProgramPathFragmentInputGenCHROMIUM(mProgram, kColorLocation, GL_EYE_LINEAR_CHROMIUM, 4, kCoefficients16); ASSERT_GL_NO_ERROR(); glProgramPathFragmentInputGenCHROMIUM(mProgram, -1, GL_EYE_LINEAR_CHROMIUM, 4, kCoefficients16); ASSERT_GL_NO_ERROR(); } // Test fragment input interpolation in CHROMIUM_EYE coordinates. TEST_P(CHROMIUMPathRenderingWithTexturingTest, TestProgramPathFragmentInputGenCHROMIUM_EYE) { if (!isApplicable()) return; // clang-format off const char *kVertexShaderSource = "uniform mat4 view_matrix;\n" "uniform mat4 color_matrix;\n" "uniform vec2 model_translate;\n" "attribute vec2 position;\n" "varying vec3 color;\n" "void main() {\n" " vec4 p = vec4(model_translate + position, 1.0, 1.0);\n" " color = (color_matrix * p).rgb;\n" " gl_Position = view_matrix * p;\n" "}\n"; const char *kFragmentShaderSource = "precision mediump float;\n" "varying vec3 color;\n" "void main() {\n" " gl_FragColor = vec4(color, 1.0);\n" "}\n"; // clang-format on compileProgram(kVertexShaderSource, kFragmentShaderSource); bindProgram(); ASSERT_TRUE(linkProgram() == true); glUniformMatrix4fv(kViewMatrixLocation, 1, GL_FALSE, kProjectionMatrix); static const GLfloat kColorMatrix[16] = { 1.0f / kResolution, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f / kResolution, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}; glUniformMatrix4fv(kColorMatrixLocation, 1, GL_FALSE, kColorMatrix); // This is the functionality we are testing: ProgramPathFragmentInputGen // does the same work as the color transform in vertex shader. static const GLfloat kColorCoefficients[12] = { 1.0f / kResolution, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f / kResolution, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}; glProgramPathFragmentInputGenCHROMIUM(mProgram, kColorFragmentInputLocation, GL_EYE_LINEAR_CHROMIUM, 3, kColorCoefficients); ASSERT_GL_NO_ERROR(); drawTestPattern(); const GLfloat kFillCoords[6] = {59.0f, 50.0f, 50.0f, 28.0f, 66.0f, 63.0f}; for (int j = 0; j < kTestRows; ++j) { for (int i = 0; i < kTestColumns; ++i) { for (size_t k = 0; k < ArraySize(kFillCoords); k += 2) { const float fx = kFillCoords[k]; const float fy = kFillCoords[k + 1]; const float px = static_cast<float>(i * kShapeWidth); const float py = static_cast<float>(j * kShapeHeight); angle::GLColor color; color.R = static_cast<GLubyte>(std::roundf((px + fx) / kResolution * 255.0f)); color.G = static_cast<GLubyte>(std::roundf((py + fy) / kResolution * 255.0f)); color.B = 0; color.A = 255; CheckPixels(static_cast<GLint>(px + fx), static_cast<GLint>(py + fy), 1, 1, 2, color); } } } } // Test fragment input interpolation in CHROMIUM_OBJECT coordinates. TEST_P(CHROMIUMPathRenderingWithTexturingTest, TestProgramPathFragmentInputGenCHROMIUM_OBJECT) { if (!isApplicable()) return; // clang-format off const char *kVertexShaderSource = "uniform mat4 view_matrix;\n" "uniform mat4 color_matrix;\n" "uniform vec2 model_translate;\n" "attribute vec2 position;\n" "varying vec3 color;\n" "void main() {\n" " color = (color_matrix * vec4(position, 1.0, 1.0)).rgb;\n" " vec4 p = vec4(model_translate + position, 1.0, 1.0);\n" " gl_Position = view_matrix * p;\n" "}"; const char *kFragmentShaderSource = "precision mediump float;\n" "varying vec3 color;\n" "void main() {\n" " gl_FragColor = vec4(color.rgb, 1.0);\n" "}"; // clang-format on compileProgram(kVertexShaderSource, kFragmentShaderSource); bindProgram(); ASSERT_TRUE(linkProgram() == true); glUniformMatrix4fv(kViewMatrixLocation, 1, GL_FALSE, kProjectionMatrix); static const GLfloat kColorMatrix[16] = { 1.0f / kShapeWidth, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f / kShapeHeight, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f }; glUniformMatrix4fv(kColorMatrixLocation, 1, GL_FALSE, kColorMatrix); // This is the functionality we are testing: ProgramPathFragmentInputGen // does the same work as the color transform in vertex shader. static const GLfloat kColorCoefficients[9] = { 1.0f / kShapeWidth, 0.0f, 0.0f, 0.0f, 1.0f / kShapeHeight, 0.0f, 0.0f, 0.0f, 0.0f}; glProgramPathFragmentInputGenCHROMIUM(mProgram, kColorFragmentInputLocation, GL_OBJECT_LINEAR_CHROMIUM, 3, kColorCoefficients); ASSERT_GL_NO_ERROR(); drawTestPattern(); const GLfloat kFillCoords[6] = {59.0f, 50.0f, 50.0f, 28.0f, 66.0f, 63.0f}; for (int j = 0; j < kTestRows; ++j) { for (int i = 0; i < kTestColumns; ++i) { for (size_t k = 0; k < ArraySize(kFillCoords); k += 2) { const float fx = kFillCoords[k]; const float fy = kFillCoords[k + 1]; const float px = static_cast<float>(i * kShapeWidth); const float py = static_cast<float>(j * kShapeHeight); angle::GLColor color; color.R = static_cast<GLubyte>(std::roundf(fx / kShapeWidth * 255.0f)); color.G = static_cast<GLubyte>(std::roundf(fy / kShapeHeight * 255.0f)); color.B = 0; color.A = 255; CheckPixels(static_cast<GLint>(px + fx), static_cast<GLint>(py + fy), 1, 1, 2, color); } } } } // Test success and error cases for setting interpolation parameters. TEST_P(CHROMIUMPathRenderingWithTexturingTest, TestProgramPathFragmentInputGenArgs) { if (!isApplicable()) return; // clang-format off const char *kVertexShaderSource = "varying vec2 vec2_var;\n" "varying vec3 vec3_var;\n" "varying vec4 vec4_var;\n" "varying float float_var;\n" "varying mat2 mat2_var;\n" "varying mat3 mat3_var;\n" "varying mat4 mat4_var;\n" "attribute float avoid_opt;\n" "void main() {\n" " vec2_var = vec2(1.0, 2.0 + avoid_opt);\n" " vec3_var = vec3(1.0, 2.0, 3.0 + avoid_opt);\n" " vec4_var = vec4(1.0, 2.0, 3.0, 4.0 + avoid_opt);\n" " float_var = 5.0 + avoid_opt;\n" " mat2_var = mat2(2.0 + avoid_opt);\n" " mat3_var = mat3(3.0 + avoid_opt);\n" " mat4_var = mat4(4.0 + avoid_opt);\n" " gl_Position = vec4(1.0);\n" "}"; const char* kFragmentShaderSource = "precision mediump float;\n" "varying vec2 vec2_var;\n" "varying vec3 vec3_var;\n" "varying vec4 vec4_var;\n" "varying float float_var;\n" "varying mat2 mat2_var;\n" "varying mat3 mat3_var;\n" "varying mat4 mat4_var;\n" "void main() {\n" " gl_FragColor = vec4(vec2_var, 0, 0) + vec4(vec3_var, 0) + vec4_var + " " vec4(float_var) + " " vec4(mat2_var[0][0], mat3_var[1][1], mat4_var[2][2], 1);\n" "}"; // clang-format on enum { kVec2Location = 0, kVec3Location, kVec4Location, kFloatLocation, kMat2Location, kMat3Location, kMat4Location, }; struct { GLint location; const char *name; GLint components; } variables[] = { {kVec2Location, "vec2_var", 2}, {kVec3Location, "vec3_var", 3}, {kVec4Location, "vec4_var", 4}, {kFloatLocation, "float_var", 1}, // If a varying is not single-precision floating-point scalar or // vector, it always causes an invalid operation. {kMat2Location, "mat2_var", -1}, {kMat3Location, "mat3_var", -1}, {kMat4Location, "mat4_var", -1}, }; compileProgram(kVertexShaderSource, kFragmentShaderSource); for (size_t i = 0; i < ArraySize(variables); ++i) { glBindFragmentInputLocationCHROMIUM(mProgram, variables[i].location, variables[i].name); } // test that using invalid (not linked) program is an invalid operation. // See similar calls at the end of the test for discussion about the arguments. glProgramPathFragmentInputGenCHROMIUM(mProgram, -1, GL_NONE, 0, NULL); EXPECT_GL_ERROR(GL_INVALID_OPERATION); ASSERT_TRUE(linkProgram() == true); const GLfloat kCoefficients16[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f}; const GLenum kGenModes[] = {GL_NONE, GL_EYE_LINEAR_CHROMIUM, GL_OBJECT_LINEAR_CHROMIUM, GL_CONSTANT_CHROMIUM}; for (size_t variable = 0; variable < ArraySize(variables); ++variable) { for (GLint components = 0; components <= 4; ++components) { for (size_t genmode = 0; genmode < ArraySize(kGenModes); ++genmode) { glProgramPathFragmentInputGenCHROMIUM(mProgram, variables[variable].location, kGenModes[genmode], components, kCoefficients16); if (components == 0 && kGenModes[genmode] == GL_NONE) { if (variables[variable].components == -1) { // Clearing a fragment input that is not single-precision floating // point scalar or vector is an invalid operation. ASSERT_GL_ERROR(GL_INVALID_OPERATION); } else { // Clearing a valid fragment input is ok. ASSERT_GL_NO_ERROR(); } } else if (components == 0 || kGenModes[genmode] == GL_NONE) { ASSERT_GL_ERROR(GL_INVALID_VALUE); } else { if (components == variables[variable].components) { // Setting a generator for a single-precision floating point // scalar or vector fragment input is ok. ASSERT_GL_NO_ERROR(); } else { // Setting a generator when components do not match is an invalid operation. ASSERT_GL_ERROR(GL_INVALID_OPERATION); } } } } } enum { kValidGenMode = GL_CONSTANT_CHROMIUM, kValidComponents = 3, kInvalidGenMode = 0xAB, kInvalidComponents = 5, }; // The location == -1 would mean fragment input was optimized away. At the // time of writing, -1 can not happen because the only way to obtain the // location numbers is through bind. Test just to be consistent. glProgramPathFragmentInputGenCHROMIUM(mProgram, -1, kValidGenMode, kValidComponents, kCoefficients16); ASSERT_GL_NO_ERROR(); // Test that even though the spec says location == -1 causes the operation to // be skipped, the verification of other parameters is still done. This is a // GL policy. glProgramPathFragmentInputGenCHROMIUM(mProgram, -1, kInvalidGenMode, kValidComponents, kCoefficients16); ASSERT_GL_ERROR(GL_INVALID_ENUM); glProgramPathFragmentInputGenCHROMIUM(mProgram, -1, kInvalidGenMode, kInvalidComponents, kCoefficients16); ASSERT_GL_ERROR(GL_INVALID_ENUM); glProgramPathFragmentInputGenCHROMIUM(mProgram, -1, kValidGenMode, kInvalidComponents, kCoefficients16); ASSERT_GL_ERROR(GL_INVALID_VALUE); glDeleteProgram(mProgram); // Test that using invalid (deleted) program is an invalid operation. EXPECT_FALSE(glIsProgram(mProgram) == GL_FALSE); glProgramPathFragmentInputGenCHROMIUM(mProgram, -1, kValidGenMode, kValidComponents, kCoefficients16); ASSERT_GL_ERROR(GL_INVALID_OPERATION); glProgramPathFragmentInputGenCHROMIUM(mProgram, -1, kInvalidGenMode, kValidComponents, kCoefficients16); ASSERT_GL_ERROR(GL_INVALID_OPERATION); glProgramPathFragmentInputGenCHROMIUM(mProgram, -1, kInvalidGenMode, kInvalidComponents, kCoefficients16); ASSERT_GL_ERROR(GL_INVALID_OPERATION); glProgramPathFragmentInputGenCHROMIUM(mProgram, -1, kValidGenMode, kInvalidComponents, kCoefficients16); ASSERT_GL_ERROR(GL_INVALID_OPERATION); mProgram = 0u; } // Test that having input statically aliased fragment inputs the linking fails // and then succeeds when the conflict is resolved. TEST_P(CHROMIUMPathRenderingWithTexturingTest, TestConflictingBind) { if (!isApplicable()) return; // clang-format off const char* kVertexShaderSource = "attribute vec4 position;\n" "varying vec4 colorA;\n" "varying vec4 colorB;\n" "void main() {\n" " gl_Position = position;\n" " colorA = position + vec4(1);\n" " colorB = position + vec4(2);\n" "}"; const char* kFragmentShaderSource = "precision mediump float;\n" "varying vec4 colorA;\n" "varying vec4 colorB;\n" "void main() {\n" " gl_FragColor = colorA + colorB;\n" "}"; // clang-format on const GLint kColorALocation = 3; const GLint kColorBLocation = 4; compileProgram(kVertexShaderSource, kFragmentShaderSource); glBindFragmentInputLocationCHROMIUM(mProgram, kColorALocation, "colorA"); // Bind colorB to location a, causing conflicts. Linking should fail. glBindFragmentInputLocationCHROMIUM(mProgram, kColorALocation, "colorB"); // Should fail now. ASSERT_TRUE(linkProgram() == false); ASSERT_GL_NO_ERROR(); // Resolve the bind conflict. glBindFragmentInputLocationCHROMIUM(mProgram, kColorBLocation, "colorB"); ASSERT_TRUE(linkProgram() == true); ASSERT_GL_NO_ERROR(); } // Test binding with array variables, using zero indices. Tests that // binding colorA[0] with explicit "colorA[0]" as well as "colorA" produces // a correct location that can be used with PathProgramFragmentInputGen. // For path rendering, colorA[0] is bound to a location. The input generator for // the location is set to produce vec4(0, 0.1, 0, 0.1). // The default varying, color, is bound to a location and its generator // will produce vec4(10.0). The shader program produces green pixels. // For vertex-based rendering, the vertex shader produces the same effect as // the input generator for path rendering. TEST_P(CHROMIUMPathRenderingWithTexturingTest, BindFragmentInputArray) { if (!isApplicable()) return; //clang-format off const char* kVertexShaderSource = "uniform mat4 view_matrix;\n" "uniform mat4 color_matrix;\n" "uniform vec2 model_translate;\n" "attribute vec2 position;\n" "varying vec4 color;\n" "varying vec4 colorA[4];\n" "void main() {\n" " vec4 p = vec4(model_translate + position, 1, 1);\n" " gl_Position = view_matrix * p;\n" " colorA[0] = vec4(0.0, 0.1, 0, 0.1);\n" " colorA[1] = vec4(0.2);\n" " colorA[2] = vec4(0.3);\n" " colorA[3] = vec4(0.4);\n" " color = vec4(10.0);\n" "}"; const char* kFragmentShaderSource = "precision mediump float;\n" "varying vec4 color;\n" "varying vec4 colorA[4];\n" "void main() {\n" " gl_FragColor = colorA[0] * color;\n" "}"; // clang-format on const GLint kColorA0Location = 4; const GLint kUnusedLocation = 5; const GLfloat kColorA0[] = {0.0f, 0.1f, 0.0f, 0.1f}; const GLfloat kColor[] = {10.0f, 10.0f, 10.0f, 10.0f}; const GLfloat kFillCoords[6] = {59.0f, 50.0f, 50.0f, 28.0f, 66.0f, 63.0f}; for (int pass = 0; pass < 2; ++pass) { compileProgram(kVertexShaderSource, kFragmentShaderSource); if (pass == 0) { glBindFragmentInputLocationCHROMIUM(mProgram, kUnusedLocation, "colorA[0]"); glBindFragmentInputLocationCHROMIUM(mProgram, kColorA0Location, "colorA"); } else { glBindFragmentInputLocationCHROMIUM(mProgram, kUnusedLocation, "colorA"); glBindFragmentInputLocationCHROMIUM(mProgram, kColorA0Location, "colorA[0]"); } bindProgram(); ASSERT_TRUE(linkProgram() == true); glUniformMatrix4fv(kViewMatrixLocation, 1, GL_FALSE, kProjectionMatrix); glProgramPathFragmentInputGenCHROMIUM(mProgram, kColorA0Location, GL_CONSTANT_CHROMIUM, 4, kColorA0); glProgramPathFragmentInputGenCHROMIUM(mProgram, kColorFragmentInputLocation, GL_CONSTANT_CHROMIUM, 4, kColor); ASSERT_GL_NO_ERROR(); drawTestPattern(); for (int j = 0; j < kTestRows; ++j) { for (int i = 0; i < kTestColumns; ++i) { for (size_t k = 0; k < ArraySize(kFillCoords); k += 2) { const float fx = kFillCoords[k]; const float fy = kFillCoords[k + 1]; const float px = static_cast<float>(i * kShapeWidth); const float py = static_cast<float>(j * kShapeHeight); angle::GLColor color; color.R = 0; color.G = 255; color.B = 0; color.A = 255; CheckPixels(static_cast<GLint>(px + fx), static_cast<GLint>(py + fy), 1, 1, 2, color); } } } } } // Test binding array variables. This is like BindFragmentInputArray. // Currently disabled since it seems there's a driver bug with the // older drivers. This should work with driver >= 364.12 TEST_P(CHROMIUMPathRenderingWithTexturingTest, DISABLED_BindFragmentInputArrayNonZeroIndex) { if (!isApplicable()) return; // clang-format off const char* kVertexShaderSource = "uniform mat4 view_matrix;\n" "uniform mat4 color_matrix;\n" "uniform vec2 model_translate;\n" "attribute vec2 position;\n" "varying vec4 color;\n" "varying vec4 colorA[4];\n" "void main() {\n" " vec4 p = vec4(model_translate + position, 1, 1);\n" " gl_Position = view_matrix * p;\n" " colorA[0] = vec4(0, 0.1, 0, 0.1);\n" " colorA[1] = vec4(0, 1, 0, 1);\n" " colorA[2] = vec4(0, 0.8, 0, 0.8);\n" " colorA[3] = vec4(0, 0.5, 0, 0.5);\n" " color = vec4(0.2);\n" "}\n"; const char* kFragmentShaderSource = "precision mediump float;\n" "varying vec4 colorA[4];\n" "varying vec4 color;\n" "void main() {\n" " gl_FragColor = (colorA[0] * colorA[1]) +\n" " colorA[2] + (colorA[3] * color);\n" "}\n"; // clang-format on const GLint kColorA0Location = 4; const GLint kColorA1Location = 1; const GLint kColorA2Location = 2; const GLint kColorA3Location = 3; const GLint kUnusedLocation = 5; const GLfloat kColorA0[] = {0.0f, 0.1f, 0.0f, 0.1f}; const GLfloat kColorA1[] = {0.0f, 1.0f, 0.0f, 1.0f}; const GLfloat kColorA2[] = {0.0f, 0.8f, 0.0f, 0.8f}; const GLfloat kColorA3[] = {0.0f, 0.5f, 0.0f, 0.5f}; const GLfloat kColor[] = {0.2f, 0.2f, 0.2f, 0.2f}; const GLfloat kFillCoords[6] = {59.0f, 50.0f, 50.0f, 28.0f, 66.0f, 63.0f}; compileProgram(kVertexShaderSource, kFragmentShaderSource); glBindFragmentInputLocationCHROMIUM(mProgram, kUnusedLocation, "colorA[0]"); glBindFragmentInputLocationCHROMIUM(mProgram, kColorA1Location, "colorA[1]"); glBindFragmentInputLocationCHROMIUM(mProgram, kColorA2Location, "colorA[2]"); glBindFragmentInputLocationCHROMIUM(mProgram, kColorA3Location, "colorA[3]"); glBindFragmentInputLocationCHROMIUM(mProgram, kColorA0Location, "colorA"); ASSERT_GL_NO_ERROR(); bindProgram(); ASSERT_TRUE(linkProgram() == true); glUniformMatrix4fv(kViewMatrixLocation, 1, GL_FALSE, kProjectionMatrix); glProgramPathFragmentInputGenCHROMIUM(mProgram, kColorA0Location, GL_CONSTANT_CHROMIUM, 4, kColorA0); glProgramPathFragmentInputGenCHROMIUM(mProgram, kColorA1Location, GL_CONSTANT_CHROMIUM, 4, kColorA1); glProgramPathFragmentInputGenCHROMIUM(mProgram, kColorA2Location, GL_CONSTANT_CHROMIUM, 4, kColorA2); glProgramPathFragmentInputGenCHROMIUM(mProgram, kColorA3Location, GL_CONSTANT_CHROMIUM, 4, kColorA3); glProgramPathFragmentInputGenCHROMIUM(mProgram, kColorFragmentInputLocation, GL_CONSTANT_CHROMIUM, 4, kColor); ASSERT_GL_NO_ERROR(); drawTestPattern(); for (int j = 0; j < kTestRows; ++j) { for (int i = 0; i < kTestColumns; ++i) { for (size_t k = 0; k < ArraySize(kFillCoords); k += 2) { const float fx = kFillCoords[k]; const float fy = kFillCoords[k + 1]; const float px = static_cast<float>(i * kShapeWidth); const float py = static_cast<float>(j * kShapeHeight); angle::GLColor color; color.R = 0; color.G = 255; color.B = 0; color.A = 255; CheckPixels(static_cast<GLint>(px + fx), static_cast<GLint>(py + fy), 1, 1, 2, color); } } } } TEST_P(CHROMIUMPathRenderingWithTexturingTest, UnusedFragmentInputUpdate) { if (!isApplicable()) return; // clang-format off const char* kVertexShaderString = "attribute vec4 a_position;\n" "void main() {\n" " gl_Position = a_position;\n" "}"; const char* kFragmentShaderString = "precision mediump float;\n" "uniform vec4 u_colorA;\n" "uniform float u_colorU;\n" "uniform vec4 u_colorC;\n" "void main() {\n" " gl_FragColor = u_colorA + u_colorC;\n" "}"; // clang-format on const GLint kColorULocation = 1; const GLint kNonexistingLocation = 5; const GLint kUnboundLocation = 6; compileProgram(kVertexShaderString, kFragmentShaderString); glBindFragmentInputLocationCHROMIUM(mProgram, kColorULocation, "u_colorU"); // The non-existing input should behave like existing but optimized away input. glBindFragmentInputLocationCHROMIUM(mProgram, kNonexistingLocation, "nonexisting"); // Let A and C be assigned automatic locations. ASSERT_TRUE(linkProgram() == true); const GLfloat kColor[16] = {}; // No errors on bound locations, since caller does not know // if the driver optimizes them away or not. glProgramPathFragmentInputGenCHROMIUM(mProgram, kColorULocation, GL_CONSTANT_CHROMIUM, 1, kColor); ASSERT_GL_NO_ERROR(); // No errors on bound locations of names that do not exist // in the shader. Otherwise it would be inconsistent wrt the // optimization case. glProgramPathFragmentInputGenCHROMIUM(mProgram, kNonexistingLocation, GL_CONSTANT_CHROMIUM, 1, kColor); ASSERT_GL_NO_ERROR(); // The above are equal to updating -1. glProgramPathFragmentInputGenCHROMIUM(mProgram, -1, GL_CONSTANT_CHROMIUM, 1, kColor); ASSERT_GL_NO_ERROR(); // No errors when updating with other type either. // The type can not be known with the non-existing case. glProgramPathFragmentInputGenCHROMIUM(mProgram, kColorULocation, GL_CONSTANT_CHROMIUM, 4, kColor); ASSERT_GL_NO_ERROR(); glProgramPathFragmentInputGenCHROMIUM(mProgram, kNonexistingLocation, GL_CONSTANT_CHROMIUM, 4, kColor); ASSERT_GL_NO_ERROR(); glProgramPathFragmentInputGenCHROMIUM(mProgram, -1, GL_CONSTANT_CHROMIUM, 4, kColor); ASSERT_GL_NO_ERROR(); // Updating an unbound, non-existing location still causes an error. glProgramPathFragmentInputGenCHROMIUM(mProgram, kUnboundLocation, GL_CONSTANT_CHROMIUM, 4, kColor); ASSERT_GL_ERROR(GL_INVALID_OPERATION); } } // namespace ANGLE_INSTANTIATE_TEST(CHROMIUMPathRenderingTest, ES2_OPENGL(), ES2_OPENGLES(), ES3_OPENGL(), ES3_OPENGLES()); ANGLE_INSTANTIATE_TEST(CHROMIUMPathRenderingDrawTest, ES2_OPENGL(), ES2_OPENGLES(), ES3_OPENGL(), ES3_OPENGLES()); ANGLE_INSTANTIATE_TEST(CHROMIUMPathRenderingWithTexturingTest, ES2_OPENGL(), ES2_OPENGLES(), ES3_OPENGL(), ES3_OPENGLES());