kc3-lang/angle/src/tests/gl_tests/gles1/LightsTest.cpp

Branch - branch -main

• Show log

  Commit

• Hash : bc447ca4
  Author :
  Date : 2022-09-20T22:38:16
  

  GLES1: Move lighting to vertex shader
  
  In the spec, lighting is done as part of vertex processing, and results
  in a new vertex color.  Texturing is applied later.  ANGLE however did
  lighting in the fragment shader.
  
  With this change, lighting is moved to the vertex shader.  This fixes
  rendering of lit objects, as interpolation is done linearly or flat
  between the vertices per spec, instead of done precisely per fragment.
  While typically this is inferior to per-fragment lighting, it's what the
  spec mandates.
  
  On the dr_driving trace, this reduces the render pass time by ~20% on
  Pixel 6.
  
  Bug: angleproject:6201
  Bug: angleproject:6644
  Change-Id: I10e37df8c56c22d520a738af8f8630bc6a01ca7f
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3906394
  Reviewed-by: Constantine Shablya <constantine.shablya@collabora.com>
  Reviewed-by: Cody Northrop <cnorthrop@google.com>
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/tests/gl_tests/gles1/LightsTest.cpp

• //
  // Copyright 2018 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.
  //
  
  // LightsTest.cpp: Tests basic usage of glLight*.
  
  #include "test_utils/ANGLETest.h"
  #include "test_utils/gl_raii.h"
  
  #include "common/matrix_utils.h"
  #include "common/vector_utils.h"
  #include "util/random_utils.h"
  
  #include <stdint.h>
  
  #include <vector>
  
  using namespace angle;
  
  class LightsTest : public ANGLETest<>
  {
    protected:
      LightsTest()
      {
          setWindowWidth(32);
          setWindowHeight(32);
          setConfigRedBits(8);
          setConfigGreenBits(8);
          setConfigBlueBits(8);
          setConfigAlphaBits(8);
          setConfigDepthBits(24);
      }
  
      void drawTestQuad();
  };
  
  // Check that the initial lighting parameters state is correct,
  // including spec minimum for light count.
  TEST_P(LightsTest, InitialState)
  {
      const GLColor32F kAmbientInitial(0.2f, 0.2f, 0.2f, 1.0f);
      GLboolean kLightModelTwoSideInitial = GL_FALSE;
  
      GLColor32F lightModelAmbient;
      GLboolean lightModelTwoSide;
  
      glGetFloatv(GL_LIGHT_MODEL_AMBIENT, &lightModelAmbient.R);
      EXPECT_GL_NO_ERROR();
      EXPECT_EQ(kAmbientInitial, lightModelAmbient);
  
      glGetBooleanv(GL_LIGHT_MODEL_TWO_SIDE, &lightModelTwoSide);
      EXPECT_GL_NO_ERROR();
      EXPECT_EQ(kLightModelTwoSideInitial, lightModelTwoSide);
  
      EXPECT_GL_FALSE(glIsEnabled(GL_LIGHTING));
      EXPECT_GL_NO_ERROR();
      EXPECT_GL_FALSE(glIsEnabled(GL_NORMALIZE));
      EXPECT_GL_NO_ERROR();
      EXPECT_GL_FALSE(glIsEnabled(GL_RESCALE_NORMAL));
      EXPECT_GL_NO_ERROR();
      EXPECT_GL_FALSE(glIsEnabled(GL_COLOR_MATERIAL));
      EXPECT_GL_NO_ERROR();
  
      GLint maxLights = 0;
      glGetIntegerv(GL_MAX_LIGHTS, &maxLights);
      EXPECT_GL_NO_ERROR();
      EXPECT_GE(8, maxLights);
  
      const GLColor32F kLightnAmbient(0.0f, 0.0f, 0.0f, 1.0f);
      const GLColor32F kLightnDiffuse(0.0f, 0.0f, 0.0f, 1.0f);
      const GLColor32F kLightnSpecular(0.0f, 0.0f, 0.0f, 1.0f);
      const GLColor32F kLight0Diffuse(1.0f, 1.0f, 1.0f, 1.0f);
      const GLColor32F kLight0Specular(1.0f, 1.0f, 1.0f, 1.0f);
      const angle::Vector4 kLightnPosition(0.0f, 0.0f, 1.0f, 0.0f);
      const angle::Vector3 kLightnDirection(0.0f, 0.0f, -1.0f);
      const GLfloat kLightnSpotlightExponent    = 0.0f;
      const GLfloat kLightnSpotlightCutoffAngle = 180.0f;
      const GLfloat kLightnAttenuationConst     = 1.0f;
      const GLfloat kLightnAttenuationLinear    = 0.0f;
      const GLfloat kLightnAttenuationQuadratic = 0.0f;
  
      for (int i = 0; i < maxLights; i++)
      {
          EXPECT_GL_FALSE(glIsEnabled(GL_LIGHT0 + i));
          EXPECT_GL_NO_ERROR();
  
          GLColor32F actualColor;
          angle::Vector4 actualPosition;
          angle::Vector3 actualDirection;
          GLfloat actualFloatValue;
  
          glGetLightfv(GL_LIGHT0 + i, GL_AMBIENT, &actualColor.R);
          EXPECT_GL_NO_ERROR();
          EXPECT_EQ(kLightnAmbient, actualColor);
  
          glGetLightfv(GL_LIGHT0 + i, GL_DIFFUSE, &actualColor.R);
          EXPECT_GL_NO_ERROR();
          EXPECT_EQ(i == 0 ? kLight0Diffuse : kLightnDiffuse, actualColor);
  
          glGetLightfv(GL_LIGHT0 + i, GL_SPECULAR, &actualColor.R);
          EXPECT_GL_NO_ERROR();
          EXPECT_EQ(i == 0 ? kLight0Specular : kLightnSpecular, actualColor);
  
          glGetLightfv(GL_LIGHT0 + i, GL_POSITION, actualPosition.data());
          EXPECT_GL_NO_ERROR();
          EXPECT_EQ(kLightnPosition, actualPosition);
  
          glGetLightfv(GL_LIGHT0 + i, GL_SPOT_DIRECTION, actualDirection.data());
          EXPECT_GL_NO_ERROR();
          EXPECT_EQ(kLightnDirection, actualDirection);
  
          glGetLightfv(GL_LIGHT0 + i, GL_SPOT_EXPONENT, &actualFloatValue);
          EXPECT_GL_NO_ERROR();
          EXPECT_EQ(kLightnSpotlightExponent, actualFloatValue);
  
          glGetLightfv(GL_LIGHT0 + i, GL_SPOT_CUTOFF, &actualFloatValue);
          EXPECT_GL_NO_ERROR();
          EXPECT_EQ(kLightnSpotlightCutoffAngle, actualFloatValue);
  
          glGetLightfv(GL_LIGHT0 + i, GL_CONSTANT_ATTENUATION, &actualFloatValue);
          EXPECT_GL_NO_ERROR();
          EXPECT_EQ(kLightnAttenuationConst, actualFloatValue);
  
          glGetLightfv(GL_LIGHT0 + i, GL_LINEAR_ATTENUATION, &actualFloatValue);
          EXPECT_GL_NO_ERROR();
          EXPECT_EQ(kLightnAttenuationLinear, actualFloatValue);
  
          glGetLightfv(GL_LIGHT0 + i, GL_QUADRATIC_ATTENUATION, &actualFloatValue);
          EXPECT_GL_NO_ERROR();
          EXPECT_EQ(kLightnAttenuationQuadratic, actualFloatValue);
      }
  }
  
  // Negative test for invalid parameter names.
  TEST_P(LightsTest, NegativeInvalidEnum)
  {
      GLint maxLights = 0;
      glGetIntegerv(GL_MAX_LIGHTS, &maxLights);
  
      glIsEnabled(GL_LIGHT0 + maxLights);
      EXPECT_GL_ERROR(GL_INVALID_ENUM);
  
      glLightfv(GL_LIGHT0 + maxLights, GL_AMBIENT, nullptr);
      EXPECT_GL_ERROR(GL_INVALID_ENUM);
  
      glLightModelfv(GL_LIGHT0, nullptr);
      EXPECT_GL_ERROR(GL_INVALID_ENUM);
  
      glLightModelf(GL_LIGHT0, 0.0f);
      EXPECT_GL_ERROR(GL_INVALID_ENUM);
  
      for (int i = 0; i < maxLights; i++)
      {
          glLightf(GL_LIGHT0 + i, GL_TEXTURE_2D, 0.0f);
          EXPECT_GL_ERROR(GL_INVALID_ENUM);
  
          glLightfv(GL_LIGHT0 + i, GL_TEXTURE_2D, nullptr);
          EXPECT_GL_ERROR(GL_INVALID_ENUM);
      }
  }
  
  // Negative test for invalid parameter values.
  TEST_P(LightsTest, NegativeInvalidValue)
  {
      GLint maxLights = 0;
      glGetIntegerv(GL_MAX_LIGHTS, &maxLights);
  
      std::vector<GLenum> attenuationParams = {
          GL_CONSTANT_ATTENUATION,
          GL_LINEAR_ATTENUATION,
          GL_QUADRATIC_ATTENUATION,
      };
  
      for (int i = 0; i < maxLights; i++)
      {
          glLightf(GL_LIGHT0 + i, GL_SPOT_EXPONENT, -1.0f);
          EXPECT_GL_ERROR(GL_INVALID_VALUE);
          GLfloat previousVal = -1.0f;
          glGetLightfv(GL_LIGHT0 + i, GL_SPOT_EXPONENT, &previousVal);
          EXPECT_NE(-1.0f, previousVal);
  
          glLightf(GL_LIGHT0 + i, GL_SPOT_EXPONENT, 128.1f);
          EXPECT_GL_ERROR(GL_INVALID_VALUE);
          previousVal = 128.1f;
          glGetLightfv(GL_LIGHT0 + i, GL_SPOT_EXPONENT, &previousVal);
          EXPECT_NE(128.1f, previousVal);
  
          glLightf(GL_LIGHT0 + i, GL_SPOT_CUTOFF, -1.0f);
          EXPECT_GL_ERROR(GL_INVALID_VALUE);
          previousVal = -1.0f;
          glGetLightfv(GL_LIGHT0 + i, GL_SPOT_CUTOFF, &previousVal);
          EXPECT_NE(-1.0f, previousVal);
  
          glLightf(GL_LIGHT0 + i, GL_SPOT_CUTOFF, 90.1f);
          EXPECT_GL_ERROR(GL_INVALID_VALUE);
          previousVal = 90.1f;
          glGetLightfv(GL_LIGHT0 + i, GL_SPOT_CUTOFF, &previousVal);
          EXPECT_NE(90.1f, previousVal);
  
          for (GLenum pname : attenuationParams)
          {
              glLightf(GL_LIGHT0 + i, pname, -1.0f);
              EXPECT_GL_ERROR(GL_INVALID_VALUE);
              previousVal = -1.0f;
              glGetLightfv(GL_LIGHT0 + i, pname, &previousVal);
              EXPECT_NE(-1.0f, previousVal);
          }
      }
  }
  
  // Test to see if we can set and retrieve the light parameters.
  TEST_P(LightsTest, Set)
  {
      angle::RNG rng(0);
  
      GLint maxLights = 0;
      glGetIntegerv(GL_MAX_LIGHTS, &maxLights);
  
      constexpr int kNumTrials = 100;
  
      GLColor32F actualColor;
      angle::Vector4 actualPosition;
      angle::Vector3 actualDirection;
      GLfloat actualFloatValue;
      GLboolean actualBooleanValue;
  
      for (int k = 0; k < kNumTrials; ++k)
      {
          const GLColor32F lightModelAmbient(rng.randomFloat(), rng.randomFloat(), rng.randomFloat(),
                                             rng.randomFloat());
          const GLfloat lightModelTwoSide = rng.randomBool() ? 1.0f : 0.0f;
  
          glLightModelfv(GL_LIGHT_MODEL_AMBIENT, &lightModelAmbient.R);
          EXPECT_GL_NO_ERROR();
          glGetFloatv(GL_LIGHT_MODEL_AMBIENT, &actualColor.R);
          EXPECT_EQ(lightModelAmbient, actualColor);
  
          glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, lightModelTwoSide);
          EXPECT_GL_NO_ERROR();
          glGetFloatv(GL_LIGHT_MODEL_TWO_SIDE, &actualFloatValue);
          EXPECT_EQ(lightModelTwoSide, actualFloatValue);
          glGetBooleanv(GL_LIGHT_MODEL_TWO_SIDE, &actualBooleanValue);
          EXPECT_EQ(lightModelTwoSide == 1.0f ? GL_TRUE : GL_FALSE, actualBooleanValue);
  
          for (int i = 0; i < maxLights; i++)
          {
  
              const GLColor32F ambient(rng.randomFloat(), rng.randomFloat(), rng.randomFloat(),
                                       rng.randomFloat());
              const GLColor32F diffuse(rng.randomFloat(), rng.randomFloat(), rng.randomFloat(),
                                       rng.randomFloat());
              const GLColor32F specular(rng.randomFloat(), rng.randomFloat(), rng.randomFloat(),
                                        rng.randomFloat());
              const angle::Vector4 position(rng.randomFloat(), rng.randomFloat(), rng.randomFloat(),
                                            rng.randomFloat());
              const angle::Vector3 direction(rng.randomFloat(), rng.randomFloat(), rng.randomFloat());
              const GLfloat spotlightExponent = rng.randomFloatBetween(0.0f, 128.0f);
              const GLfloat spotlightCutoffAngle =
                  rng.randomBool() ? rng.randomFloatBetween(0.0f, 90.0f) : 180.0f;
              const GLfloat attenuationConst     = rng.randomFloatNonnegative();
              const GLfloat attenuationLinear    = rng.randomFloatNonnegative();
              const GLfloat attenuationQuadratic = rng.randomFloatNonnegative();
  
              glLightfv(GL_LIGHT0 + i, GL_AMBIENT, &ambient.R);
              EXPECT_GL_NO_ERROR();
              glGetLightfv(GL_LIGHT0 + i, GL_AMBIENT, &actualColor.R);
              EXPECT_EQ(ambient, actualColor);
  
              glLightfv(GL_LIGHT0 + i, GL_DIFFUSE, &diffuse.R);
              EXPECT_GL_NO_ERROR();
              glGetLightfv(GL_LIGHT0 + i, GL_DIFFUSE, &actualColor.R);
              EXPECT_EQ(diffuse, actualColor);
  
              glLightfv(GL_LIGHT0 + i, GL_SPECULAR, &specular.R);
              EXPECT_GL_NO_ERROR();
              glGetLightfv(GL_LIGHT0 + i, GL_SPECULAR, &actualColor.R);
              EXPECT_EQ(specular, actualColor);
  
              glLightfv(GL_LIGHT0 + i, GL_POSITION, position.data());
              EXPECT_GL_NO_ERROR();
              glGetLightfv(GL_LIGHT0 + i, GL_POSITION, actualPosition.data());
              EXPECT_EQ(position, actualPosition);
  
              glLightfv(GL_LIGHT0 + i, GL_SPOT_DIRECTION, direction.data());
              EXPECT_GL_NO_ERROR();
              glGetLightfv(GL_LIGHT0 + i, GL_SPOT_DIRECTION, actualDirection.data());
              EXPECT_EQ(direction, actualDirection);
  
              glLightfv(GL_LIGHT0 + i, GL_SPOT_EXPONENT, &spotlightExponent);
              EXPECT_GL_NO_ERROR();
              glGetLightfv(GL_LIGHT0 + i, GL_SPOT_EXPONENT, &actualFloatValue);
              EXPECT_EQ(spotlightExponent, actualFloatValue);
  
              glLightfv(GL_LIGHT0 + i, GL_SPOT_CUTOFF, &spotlightCutoffAngle);
              EXPECT_GL_NO_ERROR();
              glGetLightfv(GL_LIGHT0 + i, GL_SPOT_CUTOFF, &actualFloatValue);
              EXPECT_EQ(spotlightCutoffAngle, actualFloatValue);
  
              glLightfv(GL_LIGHT0 + i, GL_CONSTANT_ATTENUATION, &attenuationConst);
              EXPECT_GL_NO_ERROR();
              glGetLightfv(GL_LIGHT0 + i, GL_CONSTANT_ATTENUATION, &actualFloatValue);
              EXPECT_EQ(attenuationConst, actualFloatValue);
  
              glLightfv(GL_LIGHT0 + i, GL_LINEAR_ATTENUATION, &attenuationLinear);
              EXPECT_GL_NO_ERROR();
              glGetLightfv(GL_LIGHT0 + i, GL_LINEAR_ATTENUATION, &actualFloatValue);
              EXPECT_EQ(attenuationLinear, actualFloatValue);
  
              glLightfv(GL_LIGHT0 + i, GL_LINEAR_ATTENUATION, &attenuationQuadratic);
              EXPECT_GL_NO_ERROR();
              glGetLightfv(GL_LIGHT0 + i, GL_LINEAR_ATTENUATION, &actualFloatValue);
              EXPECT_EQ(attenuationQuadratic, actualFloatValue);
          }
      }
  }
  
  // Check a case that approximates the one caught in the wild
  TEST_P(LightsTest, DiffuseGradient)
  {
      GLTexture texture;
      glBindTexture(GL_TEXTURE_2D, texture);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  
      std::vector<GLColor> colors;
      for (uint32_t x = 0; x < 1024; x++)
      {
          for (uint32_t y = 0; y < 1024; y++)
          {
              float x_ratio = (float)x / 1024.0f;
              GLubyte v     = (GLubyte)(255u * x_ratio);
  
              GLColor color = {v, v, v, 255u};
              colors.push_back(color);
          }
      }
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1024, 1024, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                   colors.data());
  
      glMatrixMode(GL_PROJECTION);
  
      const GLfloat projectionMatrix[16] = {
          0.615385, 0, 0, 0, 0, 1.333333, 0, 0, 0, 0, 1, 1, 0, 0, -2, 0,
      };
      glLoadMatrixf(projectionMatrix);
  
      glEnable(GL_LIGHT0);
      glEnable(GL_TEXTURE_2D);
      glEnable(GL_LIGHTING);
  
      glEnableClientState(GL_VERTEX_ARRAY);
      glEnableClientState(GL_TEXTURE_COORD_ARRAY);
  
      glClearColor(1.0f / 255.0f, 1.0f / 255.0f, 1.0f / 255.0f, 1.0f);
      glClear(GL_COLOR_BUFFER_BIT);
  
      glViewport(0.0f, 0.0f, 32.0f, 32.0f);
  
      const GLfloat ambient[4]  = {2.0f, 2.0f, 2.0f, 1.0f};
      const GLfloat diffuse[4]  = {1.0f, 1.0f, 1.0f, 1.0f};
      const GLfloat position[4] = {0.0f, 0.0f, 0.0f, 1.0f};
  
      glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
      glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
      glLightfv(GL_LIGHT0, GL_POSITION, position);
  
      glMatrixMode(GL_MODELVIEW);
  
      const GLfloat modelMatrix[16] = {
          0.976656, 0.000000, -0.214807, 0.000000, 0.000000,   1.000000, 0.000000,   0.000000,
          0.214807, 0.000000, 0.976656,  0.000000, -96.007507, 0.000000, 200.000000, 1.000000,
      };
      glLoadMatrixf(modelMatrix);
  
      glBindTexture(GL_TEXTURE_2D, texture);
  
      std::vector<float> positions = {
          -64.0f, -89.0f, 1.0f, -64.0f, 89.0f, 1.0f, 64.0f, -89.0f, 1.0f, 64.0f, 89.0f, 1.0f,
      };
  
      std::vector<float> uvs = {
          0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f,
      };
  
      std::vector<float> normals = {
          1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
      };
  
      glVertexPointer(3, GL_FLOAT, 0, positions.data());
      glTexCoordPointer(2, GL_FLOAT, 0, uvs.data());
      glNormalPointer(GL_FLOAT, 0, normals.data());
  
      glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
  
      EXPECT_GL_NO_ERROR();
  
      EXPECT_PIXEL_COLOR_NEAR(11, 11, GLColor(29, 29, 29, 255), 1);
  }
  
  void LightsTest::drawTestQuad()
  {
      struct Vertex
      {
          GLfloat position[3];
          GLfloat normal[3];
      };
  
      glClearColor(0.4f, 0.4f, 0.4f, 1.0f);
      glClear(GL_COLOR_BUFFER_BIT);
  
      glMatrixMode(GL_PROJECTION);
      glLoadIdentity();
      glFrustumf(-1, 1, -1, 1, 5.0, 60.0);
  
      glMatrixMode(GL_MODELVIEW);
      glLoadIdentity();
      glTranslatef(0.0f, 0.0f, -8.0f);
      glRotatef(150, 0, 1, 0);
  
      glEnableClientState(GL_VERTEX_ARRAY);
      glEnableClientState(GL_NORMAL_ARRAY);
  
      {
          GLfloat ambientAndDiffuse[4] = {1.0f, 0.0f, 0.0f, 1.0f};
          GLfloat specular[4]          = {0.0f, 0.0f, 10.0f, 1.0f};
          GLfloat shininess            = 2.0f;
  
          glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, ambientAndDiffuse);
          glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular);
          glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shininess);
      }
  
      std::vector<Vertex> vertices = {
          {{-1.0f, -1.0f, 0.0f}, {0.0f, 0.0f, 1.0f}},
          {{-1.0f, 1.0f, 0.0f}, {0.0f, 0.0f, 1.0f}},
          {{1.0f, -1.0f, 0.0f}, {0.0f, 0.0f, 1.0f}},
          {{1.0f, 1.0f, 0.0f}, {0.0f, 0.0f, 1.0f}},
      };
      glVertexPointer(3, GL_FLOAT, sizeof vertices[0], &vertices[0].position);
      glNormalPointer(GL_FLOAT, sizeof vertices[0], &vertices[0].normal);
  
      glDrawArrays(GL_TRIANGLE_STRIP, 0, vertices.size());
  
      EXPECT_GL_NO_ERROR();
  }
  
  // Check smooth lighting
  TEST_P(LightsTest, SmoothLitMesh)
  {
      {
          GLfloat position[4] = {0.0f, 0.0f, -20.0f, 1.0f};
          GLfloat diffuse[4]  = {0.7f, 0.7f, 0.7f, 1.0f};
          GLfloat specular[4] = {0.1f, 0.1f, 1.0f, 1.0f};
  
          glEnable(GL_LIGHTING);
          glEnable(GL_LIGHT0);
          glLightfv(GL_LIGHT0, GL_POSITION, position);
          glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
          glLightfv(GL_LIGHT0, GL_SPECULAR, specular);
      }
  
      drawTestQuad();
      EXPECT_PIXEL_COLOR_NEAR(16, 16, GLColor(205, 0, 92, 255), 1);
  }
  
  // Check flat lighting
  TEST_P(LightsTest, FlatLitMesh)
  {
      {
          GLfloat position[4] = {0.0f, 0.0f, -20.0f, 1.0f};
          GLfloat diffuse[4]  = {0.7f, 0.7f, 0.7f, 1.0f};
          GLfloat specular[4] = {0.1f, 0.1f, 1.0f, 1.0f};
  
          glEnable(GL_LIGHTING);
          glShadeModel(GL_FLAT);
          glEnable(GL_LIGHT0);
          glLightfv(GL_LIGHT0, GL_POSITION, position);
          glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
          glLightfv(GL_LIGHT0, GL_SPECULAR, specular);
      }
  
      drawTestQuad();
      EXPECT_PIXEL_COLOR_NEAR(16, 16, GLColor(211, 0, 196, 255), 1);
  }
  
  ANGLE_INSTANTIATE_TEST_ES1(LightsTest);
  

Download