| // |
| // Copyright 2015 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. |
| // |
| |
| // WebGLCompatibilityTest.cpp : Tests of the GL_ANGLE_webgl_compatibility extension. |
| |
| #include "test_utils/ANGLETest.h" |
| |
| #include "common/mathutil.h" |
| #include "test_utils/gl_raii.h" |
| |
| namespace |
| { |
| |
| bool ConstantColorAndAlphaBlendFunctions(GLenum first, GLenum second) |
| { |
| return (first == GL_CONSTANT_COLOR || first == GL_ONE_MINUS_CONSTANT_COLOR) && |
| (second == GL_CONSTANT_ALPHA || second == GL_ONE_MINUS_CONSTANT_ALPHA); |
| } |
| |
| void CheckBlendFunctions(GLenum src, GLenum dst) |
| { |
| if (ConstantColorAndAlphaBlendFunctions(src, dst) || |
| ConstantColorAndAlphaBlendFunctions(dst, src)) |
| { |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| } |
| else |
| { |
| ASSERT_GL_NO_ERROR(); |
| } |
| } |
| |
| // Extensions that affect the ability to use floating point textures |
| constexpr const char *FloatingPointTextureExtensions[] = { |
| "", |
| "GL_EXT_texture_storage", |
| "GL_OES_texture_half_float", |
| "GL_OES_texture_half_float_linear", |
| "GL_EXT_color_buffer_half_float", |
| "GL_OES_texture_float", |
| "GL_OES_texture_float_linear", |
| "GL_EXT_color_buffer_float", |
| "GL_EXT_float_blend", |
| "GL_CHROMIUM_color_buffer_float_rgba", |
| "GL_CHROMIUM_color_buffer_float_rgb", |
| }; |
| |
| } // namespace |
| |
| namespace angle |
| { |
| |
| class WebGLCompatibilityTest : public ANGLETest |
| { |
| protected: |
| WebGLCompatibilityTest() |
| { |
| setWindowWidth(128); |
| setWindowHeight(128); |
| setConfigRedBits(8); |
| setConfigGreenBits(8); |
| setConfigBlueBits(8); |
| setConfigAlphaBits(8); |
| setWebGLCompatibilityEnabled(true); |
| } |
| |
| template <typename T> |
| void TestFloatTextureFormat(GLenum internalFormat, |
| GLenum format, |
| GLenum type, |
| bool texturingEnabled, |
| bool linearSamplingEnabled, |
| bool renderingEnabled, |
| const T textureData[4], |
| const float floatData[4]) |
| { |
| ASSERT_GL_NO_ERROR(); |
| |
| constexpr char kVS[] = |
| R"(attribute vec4 position; |
| varying vec2 texcoord; |
| void main() |
| { |
| gl_Position = vec4(position.xy, 0.0, 1.0); |
| texcoord = (position.xy * 0.5) + 0.5; |
| })"; |
| |
| constexpr char kFS[] = |
| R"(precision mediump float; |
| uniform sampler2D tex; |
| uniform vec4 subtractor; |
| varying vec2 texcoord; |
| void main() |
| { |
| vec4 color = texture2D(tex, texcoord); |
| if (abs(color.r - subtractor.r) + |
| abs(color.g - subtractor.g) + |
| abs(color.b - subtractor.b) + |
| abs(color.a - subtractor.a) < 8.0) |
| { |
| gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0); |
| } |
| else |
| { |
| gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); |
| } |
| })"; |
| |
| ANGLE_GL_PROGRAM(samplingProgram, kVS, kFS); |
| glUseProgram(samplingProgram.get()); |
| |
| // Need RGBA8 renderbuffers for enough precision on the readback |
| if (IsGLExtensionRequestable("GL_OES_rgb8_rgba8")) |
| { |
| glRequestExtensionANGLE("GL_OES_rgb8_rgba8"); |
| } |
| ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_OES_rgb8_rgba8") && |
| getClientMajorVersion() < 3); |
| ASSERT_GL_NO_ERROR(); |
| |
| GLRenderbuffer rbo; |
| glBindRenderbuffer(GL_RENDERBUFFER, rbo.get()); |
| glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, 1, 1); |
| |
| GLFramebuffer fbo; |
| glBindFramebuffer(GL_FRAMEBUFFER, fbo.get()); |
| glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo.get()); |
| |
| GLTexture texture; |
| glBindTexture(GL_TEXTURE_2D, texture.get()); |
| |
| if (internalFormat == format) |
| { |
| glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, 1, 1, 0, format, type, textureData); |
| } |
| else |
| { |
| if (getClientMajorVersion() >= 3) |
| { |
| glTexStorage2D(GL_TEXTURE_2D, 1, internalFormat, 1, 1); |
| } |
| else |
| { |
| ASSERT_TRUE(IsGLExtensionEnabled("GL_EXT_texture_storage")); |
| glTexStorage2DEXT(GL_TEXTURE_2D, 1, internalFormat, 1, 1); |
| } |
| glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 1, 1, format, type, textureData); |
| } |
| |
| if (!texturingEnabled) |
| { |
| // Depending on the entry point and client version, different errors may be generated |
| ASSERT_GLENUM_NE(GL_NO_ERROR, glGetError()); |
| |
| // Two errors may be generated in the glTexStorage + glTexSubImage case, clear the |
| // second error |
| glGetError(); |
| |
| return; |
| } |
| ASSERT_GL_NO_ERROR(); |
| |
| glUniform1i(glGetUniformLocation(samplingProgram.get(), "tex"), 0); |
| glUniform4fv(glGetUniformLocation(samplingProgram.get(), "subtractor"), 1, floatData); |
| |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); |
| drawQuad(samplingProgram.get(), "position", 0.5f, 1.0f, true); |
| EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green); |
| |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); |
| drawQuad(samplingProgram.get(), "position", 0.5f, 1.0f, true); |
| |
| if (linearSamplingEnabled) |
| { |
| EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green); |
| } |
| else |
| { |
| EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::red); |
| } |
| |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture.get(), |
| 0); |
| glBindTexture(GL_TEXTURE_2D, 0); |
| if (!renderingEnabled) |
| { |
| EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT, |
| glCheckFramebufferStatus(GL_FRAMEBUFFER)); |
| return; |
| } |
| |
| GLenum framebufferStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER); |
| if (framebufferStatus == GL_FRAMEBUFFER_UNSUPPORTED) |
| { |
| std::cout << "Framebuffer returned GL_FRAMEBUFFER_UNSUPPORTED, this is legal." |
| << std::endl; |
| return; |
| } |
| ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, framebufferStatus); |
| |
| ANGLE_GL_PROGRAM(renderingProgram, essl1_shaders::vs::Simple(), |
| essl1_shaders::fs::UniformColor()); |
| glUseProgram(renderingProgram.get()); |
| |
| glUniform4fv(glGetUniformLocation(renderingProgram.get(), essl1_shaders::ColorUniform()), 1, |
| floatData); |
| |
| drawQuad(renderingProgram.get(), essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true); |
| |
| EXPECT_PIXEL_COLOR32F_NEAR( |
| 0, 0, GLColor32F(floatData[0], floatData[1], floatData[2], floatData[3]), 1.0f); |
| } |
| |
| void TestExtFloatBlend(bool shouldBlend) |
| { |
| constexpr char kVS[] = |
| R"(void main() |
| { |
| gl_Position = vec4(0, 0, 0, 1); |
| })"; |
| |
| constexpr char kFS[] = |
| R"(void main() |
| { |
| gl_FragColor = vec4(0, 1, 0, 1); |
| })"; |
| |
| ANGLE_GL_PROGRAM(program, kVS, kFS); |
| glUseProgram(program); |
| |
| GLTexture texture; |
| glBindTexture(GL_TEXTURE_2D, texture); |
| glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, 1, 1, 0, GL_RGBA, GL_FLOAT, nullptr); |
| EXPECT_GL_NO_ERROR(); |
| |
| GLFramebuffer fbo; |
| glBindFramebuffer(GL_FRAMEBUFFER, fbo); |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); |
| ASSERT_EGLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER)); |
| |
| glDisable(GL_BLEND); |
| glDrawArrays(GL_POINTS, 0, 1); |
| EXPECT_GL_NO_ERROR(); |
| |
| glEnable(GL_BLEND); |
| glDrawArrays(GL_POINTS, 0, 1); |
| if (shouldBlend) |
| { |
| EXPECT_GL_NO_ERROR(); |
| } |
| else |
| { |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| } |
| } |
| |
| void TestDifferentStencilMaskAndRef(GLenum errIfMismatch); |
| |
| // Called from RenderingFeedbackLoopWithDrawBuffersEXT. |
| void drawBuffersEXTFeedbackLoop(GLuint program, |
| const std::array<GLenum, 2> &drawBuffers, |
| GLenum expectedError); |
| |
| // Called from RenderingFeedbackLoopWithDrawBuffers. |
| void drawBuffersFeedbackLoop(GLuint program, |
| const std::array<GLenum, 2> &drawBuffers, |
| GLenum expectedError); |
| |
| // Called from Enable[Compressed]TextureFormatExtensions |
| void validateTexImageExtensionFormat(GLenum format, const std::string &extName); |
| void validateCompressedTexImageExtensionFormat(GLenum format, |
| GLsizei width, |
| GLsizei height, |
| GLsizei blockSize, |
| const std::string &extName, |
| bool subImageAllowed); |
| }; |
| |
| class WebGL2CompatibilityTest : public WebGLCompatibilityTest |
| {}; |
| |
| // Context creation would fail if EGL_ANGLE_create_context_webgl_compatibility was not available so |
| // the GL extension should always be present |
| TEST_P(WebGLCompatibilityTest, ExtensionStringExposed) |
| { |
| EXPECT_TRUE(IsGLExtensionEnabled("GL_ANGLE_webgl_compatibility")); |
| } |
| |
| // Verify that all extension entry points are available |
| TEST_P(WebGLCompatibilityTest, EntryPoints) |
| { |
| if (IsGLExtensionEnabled("GL_ANGLE_request_extension")) |
| { |
| EXPECT_NE(nullptr, eglGetProcAddress("glRequestExtensionANGLE")); |
| } |
| } |
| |
| // WebGL 1 allows GL_DEPTH_STENCIL_ATTACHMENT as a valid binding point. Make sure it is usable, |
| // even in ES2 contexts. |
| TEST_P(WebGLCompatibilityTest, DepthStencilBindingPoint) |
| { |
| GLRenderbuffer renderbuffer; |
| glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer.get()); |
| glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 32, 32); |
| |
| GLFramebuffer framebuffer; |
| glBindFramebuffer(GL_FRAMEBUFFER, framebuffer.get()); |
| glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, |
| renderbuffer.get()); |
| |
| EXPECT_GL_NO_ERROR(); |
| } |
| |
| // Test that attempting to enable an extension that doesn't exist generates GL_INVALID_OPERATION |
| TEST_P(WebGLCompatibilityTest, EnableExtensionValidation) |
| { |
| glRequestExtensionANGLE("invalid_extension_string"); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| } |
| |
| // Test enabling the GL_OES_element_index_uint extension |
| TEST_P(WebGLCompatibilityTest, EnableExtensionUintIndices) |
| { |
| if (getClientMajorVersion() != 2) |
| { |
| // This test only works on ES2 where uint indices are not available by default |
| return; |
| } |
| |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_OES_element_index_uint")); |
| |
| GLBuffer indexBuffer; |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer.get()); |
| |
| GLuint data[] = {0, 1, 2, 1, 3, 2}; |
| glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(data), data, GL_STATIC_DRAW); |
| |
| ANGLE_GL_PROGRAM(program, "void main() { gl_Position = vec4(0, 0, 0, 1); }", |
| "void main() { gl_FragColor = vec4(0, 1, 0, 1); }"); |
| glUseProgram(program.get()); |
| |
| glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| |
| if (IsGLExtensionRequestable("GL_OES_element_index_uint")) |
| { |
| glRequestExtensionANGLE("GL_OES_element_index_uint"); |
| EXPECT_GL_NO_ERROR(); |
| EXPECT_TRUE(IsGLExtensionEnabled("GL_OES_element_index_uint")); |
| |
| glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr); |
| EXPECT_GL_NO_ERROR(); |
| } |
| } |
| |
| // Test enabling the GL_OES_standard_derivatives extension |
| TEST_P(WebGLCompatibilityTest, EnableExtensionStandardDerivitives) |
| { |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_OES_standard_derivatives")); |
| |
| constexpr char kFS[] = |
| R"(#extension GL_OES_standard_derivatives : require |
| void main() { gl_FragColor = vec4(dFdx(vec2(1.0, 1.0)).x, 1, 0, 1); })"; |
| ASSERT_EQ(0u, CompileShader(GL_FRAGMENT_SHADER, kFS)); |
| |
| if (IsGLExtensionRequestable("GL_OES_standard_derivatives")) |
| { |
| glRequestExtensionANGLE("GL_OES_standard_derivatives"); |
| EXPECT_GL_NO_ERROR(); |
| EXPECT_TRUE(IsGLExtensionEnabled("GL_OES_standard_derivatives")); |
| |
| GLuint shader = CompileShader(GL_FRAGMENT_SHADER, kFS); |
| ASSERT_NE(0u, shader); |
| glDeleteShader(shader); |
| } |
| } |
| |
| // Test enabling the GL_EXT_shader_texture_lod extension |
| TEST_P(WebGLCompatibilityTest, EnableExtensionTextureLOD) |
| { |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_EXT_shader_texture_lod")); |
| |
| constexpr char kFS[] = |
| R"(#extension GL_EXT_shader_texture_lod : require |
| uniform sampler2D u_texture; |
| void main() { |
| gl_FragColor = texture2DGradEXT(u_texture, vec2(0.0, 0.0), vec2(0.0, 0.0), vec2(0.0, |
| 0.0)); |
| })"; |
| ASSERT_EQ(0u, CompileShader(GL_FRAGMENT_SHADER, kFS)); |
| |
| if (IsGLExtensionRequestable("GL_EXT_shader_texture_lod")) |
| { |
| glRequestExtensionANGLE("GL_EXT_shader_texture_lod"); |
| EXPECT_GL_NO_ERROR(); |
| EXPECT_TRUE(IsGLExtensionEnabled("GL_EXT_shader_texture_lod")); |
| |
| GLuint shader = CompileShader(GL_FRAGMENT_SHADER, kFS); |
| ASSERT_NE(0u, shader); |
| glDeleteShader(shader); |
| } |
| } |
| |
| // Test enabling the GL_EXT_frag_depth extension |
| TEST_P(WebGLCompatibilityTest, EnableExtensionFragDepth) |
| { |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_EXT_frag_depth")); |
| |
| constexpr char kFS[] = |
| R"(#extension GL_EXT_frag_depth : require |
| void main() { |
| gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0); |
| gl_FragDepthEXT = 1.0; |
| })"; |
| ASSERT_EQ(0u, CompileShader(GL_FRAGMENT_SHADER, kFS)); |
| |
| if (IsGLExtensionRequestable("GL_EXT_frag_depth")) |
| { |
| glRequestExtensionANGLE("GL_EXT_frag_depth"); |
| EXPECT_GL_NO_ERROR(); |
| EXPECT_TRUE(IsGLExtensionEnabled("GL_EXT_frag_depth")); |
| |
| GLuint shader = CompileShader(GL_FRAGMENT_SHADER, kFS); |
| ASSERT_NE(0u, shader); |
| glDeleteShader(shader); |
| } |
| } |
| |
| // Test enabling the GL_EXT_texture_filter_anisotropic extension |
| TEST_P(WebGLCompatibilityTest, EnableExtensionTextureFilterAnisotropic) |
| { |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_EXT_texture_filter_anisotropic")); |
| |
| GLfloat maxAnisotropy = 0.0f; |
| glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &maxAnisotropy); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| |
| GLTexture texture; |
| glBindTexture(GL_TEXTURE_2D, texture.get()); |
| ASSERT_GL_NO_ERROR(); |
| |
| glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0f); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| |
| GLfloat currentAnisotropy = 0.0f; |
| glGetTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, ¤tAnisotropy); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| |
| if (IsGLExtensionRequestable("GL_EXT_texture_filter_anisotropic")) |
| { |
| glRequestExtensionANGLE("GL_EXT_texture_filter_anisotropic"); |
| EXPECT_GL_NO_ERROR(); |
| EXPECT_TRUE(IsGLExtensionEnabled("GL_EXT_texture_filter_anisotropic")); |
| |
| glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &maxAnisotropy); |
| ASSERT_GL_NO_ERROR(); |
| EXPECT_GE(maxAnisotropy, 2.0f); |
| |
| glGetTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, ¤tAnisotropy); |
| ASSERT_GL_NO_ERROR(); |
| EXPECT_EQ(1.0f, currentAnisotropy); |
| |
| glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 2.0f); |
| ASSERT_GL_NO_ERROR(); |
| } |
| } |
| |
| // Test enabling the EGL image extensions |
| TEST_P(WebGLCompatibilityTest, EnableExtensionEGLImage) |
| { |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_OES_EGL_image")); |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_OES_EGL_image_external")); |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_OES_EGL_image_external_essl3")); |
| EXPECT_FALSE(IsGLExtensionEnabled("NV_EGL_stream_consumer_external")); |
| |
| constexpr char kFSES2[] = |
| R"(#extension GL_OES_EGL_image_external : require |
| precision highp float; |
| uniform samplerExternalOES sampler; |
| void main() |
| { |
| gl_FragColor = texture2D(sampler, vec2(0, 0)); |
| })"; |
| EXPECT_EQ(0u, CompileShader(GL_FRAGMENT_SHADER, kFSES2)); |
| |
| constexpr char kFSES3[] = |
| R"(#version 300 es |
| #extension GL_OES_EGL_image_external : require |
| precision highp float; |
| uniform samplerExternalOES sampler; |
| void main() |
| { |
| gl_FragColor = texture(sampler, vec2(0, 0)); |
| })"; |
| if (getClientMajorVersion() > 3) |
| { |
| EXPECT_EQ(0u, CompileShader(GL_FRAGMENT_SHADER, kFSES3)); |
| } |
| |
| glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| |
| GLint result; |
| glGetIntegerv(GL_TEXTURE_BINDING_EXTERNAL_OES, &result); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| |
| if (IsGLExtensionRequestable("GL_OES_EGL_image_external")) |
| { |
| glRequestExtensionANGLE("GL_OES_EGL_image_external"); |
| EXPECT_GL_NO_ERROR(); |
| EXPECT_TRUE(IsGLExtensionEnabled("GL_OES_EGL_image_external")); |
| |
| EXPECT_NE(0u, CompileShader(GL_FRAGMENT_SHADER, kFSES2)); |
| |
| glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0); |
| EXPECT_GL_NO_ERROR(); |
| |
| glGetIntegerv(GL_TEXTURE_BINDING_EXTERNAL_OES, &result); |
| EXPECT_GL_NO_ERROR(); |
| |
| if (getClientMajorVersion() > 3 && |
| IsGLExtensionRequestable("GL_OES_EGL_image_external_essl3")) |
| { |
| glRequestExtensionANGLE("GL_OES_EGL_image_external_essl3"); |
| EXPECT_GL_NO_ERROR(); |
| EXPECT_TRUE(IsGLExtensionEnabled("GL_OES_EGL_image_external_essl3")); |
| |
| EXPECT_NE(0u, CompileShader(GL_FRAGMENT_SHADER, kFSES3)); |
| } |
| else |
| { |
| EXPECT_EQ(0u, CompileShader(GL_FRAGMENT_SHADER, kFSES3)); |
| } |
| } |
| } |
| |
| // Verify that shaders are of a compatible spec when the extension is enabled. |
| TEST_P(WebGLCompatibilityTest, ExtensionCompilerSpec) |
| { |
| EXPECT_TRUE(IsGLExtensionEnabled("GL_ANGLE_webgl_compatibility")); |
| |
| // Use of reserved _webgl prefix should fail when the shader specification is for WebGL. |
| constexpr char kVS[] = |
| R"(struct Foo { |
| int _webgl_bar; |
| }; |
| void main() |
| { |
| Foo foo = Foo(1); |
| })"; |
| |
| // Default fragement shader. |
| constexpr char kFS[] = |
| R"(void main() |
| { |
| gl_FragColor = vec4(1.0,0.0,0.0,1.0); |
| })"; |
| |
| GLuint program = CompileProgram(kVS, kFS); |
| EXPECT_EQ(0u, program); |
| glDeleteProgram(program); |
| } |
| |
| // Test enabling the GL_NV_pixel_buffer_object extension |
| TEST_P(WebGLCompatibilityTest, EnablePixelBufferObjectExtensions) |
| { |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_NV_pixel_buffer_object")); |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_OES_mapbuffer")); |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_EXT_map_buffer_range")); |
| |
| // These extensions become core in in ES3/WebGL2. |
| ANGLE_SKIP_TEST_IF(getClientMajorVersion() >= 3); |
| |
| GLBuffer buffer; |
| glBindBuffer(GL_PIXEL_PACK_BUFFER, buffer); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| |
| if (IsGLExtensionRequestable("GL_NV_pixel_buffer_object")) |
| { |
| glRequestExtensionANGLE("GL_NV_pixel_buffer_object"); |
| EXPECT_GL_NO_ERROR(); |
| |
| // Create a framebuffer to read from |
| GLRenderbuffer renderbuffer; |
| glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer); |
| glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA4, 1, 1); |
| |
| GLFramebuffer fbo; |
| glBindFramebuffer(GL_FRAMEBUFFER, fbo); |
| glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, |
| renderbuffer); |
| EXPECT_GL_NO_ERROR(); |
| |
| glBindBuffer(GL_PIXEL_PACK_BUFFER, buffer); |
| EXPECT_GL_NO_ERROR(); |
| |
| glBufferData(GL_PIXEL_PACK_BUFFER, 4, nullptr, GL_STATIC_DRAW); |
| glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); |
| EXPECT_GL_NO_ERROR(); |
| } |
| } |
| |
| // Test enabling the GL_EXT_texture_storage extension |
| TEST_P(WebGLCompatibilityTest, EnableTextureStorage) |
| { |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_EXT_texture_storage")); |
| |
| GLTexture texture; |
| glBindTexture(GL_TEXTURE_2D, texture); |
| |
| GLint result; |
| glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_IMMUTABLE_FORMAT, &result); |
| if (getClientMajorVersion() >= 3) |
| { |
| EXPECT_GL_NO_ERROR(); |
| } |
| else |
| { |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| } |
| |
| if (IsGLExtensionRequestable("GL_EXT_texture_storage")) |
| { |
| glRequestExtensionANGLE("GL_EXT_texture_storage"); |
| EXPECT_GL_NO_ERROR(); |
| EXPECT_TRUE(IsGLExtensionEnabled("GL_EXT_texture_storage")); |
| |
| glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_IMMUTABLE_FORMAT, &result); |
| EXPECT_GL_NO_ERROR(); |
| |
| const GLenum alwaysAcceptableFormats[] = { |
| GL_ALPHA8_EXT, |
| GL_LUMINANCE8_EXT, |
| GL_LUMINANCE8_ALPHA8_EXT, |
| }; |
| for (const auto &acceptableFormat : alwaysAcceptableFormats) |
| { |
| GLTexture localTexture; |
| glBindTexture(GL_TEXTURE_2D, localTexture); |
| glTexStorage2DEXT(GL_TEXTURE_2D, 1, acceptableFormat, 1, 1); |
| EXPECT_GL_NO_ERROR(); |
| } |
| } |
| } |
| |
| // Test enabling the GL_OES_mapbuffer and GL_EXT_map_buffer_range extensions |
| TEST_P(WebGLCompatibilityTest, EnableMapBufferExtensions) |
| { |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_OES_mapbuffer")); |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_EXT_map_buffer_range")); |
| |
| // These extensions become core in in ES3/WebGL2. |
| ANGLE_SKIP_TEST_IF(getClientMajorVersion() >= 3); |
| |
| GLBuffer buffer; |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer); |
| glBufferData(GL_ELEMENT_ARRAY_BUFFER, 4, nullptr, GL_STATIC_DRAW); |
| |
| glMapBufferOES(GL_ELEMENT_ARRAY_BUFFER, GL_WRITE_ONLY_OES); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| |
| glMapBufferRangeEXT(GL_ELEMENT_ARRAY_BUFFER, 0, 4, GL_MAP_WRITE_BIT); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| |
| GLint access = 0; |
| glGetBufferParameteriv(GL_ELEMENT_ARRAY_BUFFER, GL_BUFFER_ACCESS_OES, &access); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| |
| if (IsGLExtensionRequestable("GL_OES_mapbuffer")) |
| { |
| glRequestExtensionANGLE("GL_OES_mapbuffer"); |
| EXPECT_GL_NO_ERROR(); |
| |
| glMapBufferOES(GL_ELEMENT_ARRAY_BUFFER, GL_WRITE_ONLY_OES); |
| glUnmapBufferOES(GL_ELEMENT_ARRAY_BUFFER); |
| glGetBufferParameteriv(GL_ELEMENT_ARRAY_BUFFER, GL_BUFFER_ACCESS_OES, &access); |
| EXPECT_GL_NO_ERROR(); |
| } |
| |
| if (IsGLExtensionRequestable("GL_EXT_map_buffer_range")) |
| { |
| glRequestExtensionANGLE("GL_EXT_map_buffer_range"); |
| EXPECT_GL_NO_ERROR(); |
| |
| glMapBufferRangeEXT(GL_ELEMENT_ARRAY_BUFFER, 0, 4, GL_MAP_WRITE_BIT); |
| glUnmapBufferOES(GL_ELEMENT_ARRAY_BUFFER); |
| glGetBufferParameteriv(GL_ELEMENT_ARRAY_BUFFER, GL_BUFFER_ACCESS_OES, &access); |
| EXPECT_GL_NO_ERROR(); |
| } |
| } |
| |
| // Test enabling the GL_OES_fbo_render_mipmap extension |
| TEST_P(WebGLCompatibilityTest, EnableRenderMipmapExtension) |
| { |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_OES_fbo_render_mipmap")); |
| |
| // This extensions become core in in ES3/WebGL2. |
| ANGLE_SKIP_TEST_IF(getClientMajorVersion() >= 3); |
| |
| GLTexture texture; |
| glBindTexture(GL_TEXTURE_2D, texture); |
| glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); |
| glTexImage2D(GL_TEXTURE_2D, 1, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); |
| |
| GLFramebuffer fbo; |
| glBindFramebuffer(GL_FRAMEBUFFER, fbo); |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); |
| EXPECT_GL_NO_ERROR(); |
| |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 1); |
| EXPECT_GL_ERROR(GL_INVALID_VALUE); |
| |
| if (IsGLExtensionRequestable("GL_OES_fbo_render_mipmap")) |
| { |
| glRequestExtensionANGLE("GL_OES_fbo_render_mipmap"); |
| EXPECT_GL_NO_ERROR(); |
| |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 1); |
| EXPECT_GL_NO_ERROR(); |
| } |
| } |
| |
| // Test enabling the GL_EXT_blend_minmax extension |
| TEST_P(WebGLCompatibilityTest, EnableBlendMinMaxExtension) |
| { |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_EXT_blend_minmax")); |
| |
| // This extensions become core in in ES3/WebGL2. |
| ANGLE_SKIP_TEST_IF(getClientMajorVersion() >= 3); |
| |
| glBlendEquation(GL_MIN); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| |
| glBlendEquation(GL_MAX); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| |
| if (IsGLExtensionRequestable("GL_EXT_blend_minmax")) |
| { |
| glRequestExtensionANGLE("GL_EXT_blend_minmax"); |
| EXPECT_GL_NO_ERROR(); |
| |
| glBlendEquation(GL_MIN); |
| glBlendEquation(GL_MAX); |
| EXPECT_GL_NO_ERROR(); |
| } |
| } |
| |
| // Test enabling the query extensions |
| TEST_P(WebGLCompatibilityTest, EnableQueryExtensions) |
| { |
| // Seems to be causing a device lost. http://anglebug.com/2423 |
| ANGLE_SKIP_TEST_IF(IsAMD() && IsWindows() && IsOpenGL()); |
| |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_EXT_occlusion_query_boolean")); |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_EXT_disjoint_timer_query")); |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_CHROMIUM_sync_query")); |
| |
| // This extensions become core in in ES3/WebGL2. |
| ANGLE_SKIP_TEST_IF(getClientMajorVersion() >= 3); |
| |
| GLQueryEXT badQuery; |
| |
| glBeginQueryEXT(GL_ANY_SAMPLES_PASSED_EXT, badQuery); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| |
| glBeginQueryEXT(GL_ANY_SAMPLES_PASSED_CONSERVATIVE, badQuery); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| |
| glBeginQueryEXT(GL_TIME_ELAPSED_EXT, badQuery); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| |
| glQueryCounterEXT(GL_TIMESTAMP_EXT, badQuery); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| |
| glBeginQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM, badQuery); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| |
| if (IsGLExtensionRequestable("GL_EXT_occlusion_query_boolean")) |
| { |
| glRequestExtensionANGLE("GL_EXT_occlusion_query_boolean"); |
| EXPECT_GL_NO_ERROR(); |
| |
| GLQueryEXT query; |
| glBeginQueryEXT(GL_ANY_SAMPLES_PASSED_EXT, query); |
| glEndQueryEXT(GL_ANY_SAMPLES_PASSED_EXT); |
| EXPECT_GL_NO_ERROR(); |
| } |
| |
| if (IsGLExtensionRequestable("GL_EXT_disjoint_timer_query")) |
| { |
| glRequestExtensionANGLE("GL_EXT_disjoint_timer_query"); |
| EXPECT_GL_NO_ERROR(); |
| |
| GLQueryEXT query1; |
| glBeginQueryEXT(GL_TIME_ELAPSED_EXT, query1); |
| glEndQueryEXT(GL_TIME_ELAPSED_EXT); |
| EXPECT_GL_NO_ERROR(); |
| |
| GLQueryEXT query2; |
| glQueryCounterEXT(query2, GL_TIMESTAMP_EXT); |
| EXPECT_GL_NO_ERROR(); |
| } |
| |
| if (IsGLExtensionRequestable("GL_CHROMIUM_sync_query")) |
| { |
| glRequestExtensionANGLE("GL_CHROMIUM_sync_query"); |
| EXPECT_GL_NO_ERROR(); |
| |
| GLQueryEXT query; |
| glBeginQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM, query); |
| glEndQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM); |
| EXPECT_GL_NO_ERROR(); |
| } |
| } |
| |
| // Test enabling the GL_ANGLE_framebuffer_multisample extension |
| TEST_P(WebGLCompatibilityTest, EnableFramebufferMultisampleExtension) |
| { |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_ANGLE_framebuffer_multisample")); |
| |
| // This extensions become core in in ES3/WebGL2. |
| ANGLE_SKIP_TEST_IF(getClientMajorVersion() >= 3); |
| |
| GLint maxSamples = 0; |
| glGetIntegerv(GL_MAX_SAMPLES, &maxSamples); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| |
| GLRenderbuffer renderbuffer; |
| glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer); |
| glRenderbufferStorageMultisampleANGLE(GL_RENDERBUFFER, 1, GL_RGBA4, 1, 1); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| |
| if (IsGLExtensionRequestable("GL_ANGLE_framebuffer_multisample")) |
| { |
| glRequestExtensionANGLE("GL_ANGLE_framebuffer_multisample"); |
| EXPECT_GL_NO_ERROR(); |
| |
| glGetIntegerv(GL_MAX_SAMPLES, &maxSamples); |
| EXPECT_GL_NO_ERROR(); |
| |
| glRenderbufferStorageMultisampleANGLE(GL_RENDERBUFFER, maxSamples, GL_RGBA4, 1, 1); |
| EXPECT_GL_NO_ERROR(); |
| } |
| } |
| |
| // Test enabling the GL_ANGLE_instanced_arrays extension |
| TEST_P(WebGLCompatibilityTest, EnableInstancedArraysExtensionANGLE) |
| { |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_ANGLE_instanced_arrays")); |
| |
| // This extensions become core in in ES3/WebGL2. |
| ANGLE_SKIP_TEST_IF(getClientMajorVersion() >= 3); |
| |
| GLint divisor = 0; |
| glGetVertexAttribiv(0, GL_VERTEX_ATTRIB_ARRAY_DIVISOR, &divisor); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| |
| glVertexAttribDivisorANGLE(0, 1); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| |
| if (IsGLExtensionRequestable("GL_ANGLE_instanced_arrays")) |
| { |
| glRequestExtensionANGLE("GL_ANGLE_instanced_arrays"); |
| EXPECT_GL_NO_ERROR(); |
| |
| glGetVertexAttribiv(0, GL_VERTEX_ATTRIB_ARRAY_DIVISOR, &divisor); |
| glVertexAttribDivisorANGLE(0, 1); |
| EXPECT_GL_NO_ERROR(); |
| } |
| } |
| |
| // Test enabling the GL_EXT_instanced_arrays extension |
| TEST_P(WebGLCompatibilityTest, EnableInstancedArraysExtensionEXT) |
| { |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_EXT_instanced_arrays")); |
| |
| // This extensions become core in in ES3/WebGL2. |
| ANGLE_SKIP_TEST_IF(getClientMajorVersion() >= 3); |
| |
| GLint divisor = 0; |
| glGetVertexAttribiv(0, GL_VERTEX_ATTRIB_ARRAY_DIVISOR, &divisor); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| |
| glVertexAttribDivisorEXT(0, 1); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| |
| if (IsGLExtensionRequestable("GL_EXT_instanced_arrays")) |
| { |
| glRequestExtensionANGLE("GL_EXT_instanced_arrays"); |
| EXPECT_GL_NO_ERROR(); |
| |
| glGetVertexAttribiv(0, GL_VERTEX_ATTRIB_ARRAY_DIVISOR, &divisor); |
| glVertexAttribDivisorEXT(0, 1); |
| EXPECT_GL_NO_ERROR(); |
| } |
| } |
| |
| // Test enabling the GL_ANGLE_pack_reverse_row_order extension |
| TEST_P(WebGLCompatibilityTest, EnablePackReverseRowOrderExtension) |
| { |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_ANGLE_pack_reverse_row_order")); |
| |
| GLint result = 0; |
| glGetIntegerv(GL_PACK_REVERSE_ROW_ORDER_ANGLE, &result); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| |
| glPixelStorei(GL_PACK_REVERSE_ROW_ORDER_ANGLE, GL_TRUE); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| |
| if (IsGLExtensionRequestable("GL_ANGLE_pack_reverse_row_order")) |
| { |
| glRequestExtensionANGLE("GL_ANGLE_pack_reverse_row_order"); |
| EXPECT_GL_NO_ERROR(); |
| |
| glGetIntegerv(GL_PACK_REVERSE_ROW_ORDER_ANGLE, &result); |
| glPixelStorei(GL_PACK_REVERSE_ROW_ORDER_ANGLE, GL_TRUE); |
| EXPECT_GL_NO_ERROR(); |
| } |
| } |
| |
| // Test enabling the GL_EXT_unpack_subimage extension |
| TEST_P(WebGLCompatibilityTest, EnablePackUnpackSubImageExtension) |
| { |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_EXT_unpack_subimage")); |
| |
| // This extensions become core in in ES3/WebGL2. |
| ANGLE_SKIP_TEST_IF(getClientMajorVersion() >= 3); |
| |
| constexpr GLenum parameters[] = { |
| GL_UNPACK_ROW_LENGTH_EXT, |
| GL_UNPACK_SKIP_ROWS_EXT, |
| GL_UNPACK_SKIP_PIXELS_EXT, |
| }; |
| |
| for (GLenum param : parameters) |
| { |
| GLint resultI = 0; |
| glGetIntegerv(param, &resultI); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| |
| GLfloat resultF = 0.0f; |
| glGetFloatv(param, &resultF); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| |
| glPixelStorei(param, 0); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| } |
| |
| if (IsGLExtensionRequestable("GL_EXT_unpack_subimage")) |
| { |
| glRequestExtensionANGLE("GL_EXT_unpack_subimage"); |
| EXPECT_GL_NO_ERROR(); |
| |
| for (GLenum param : parameters) |
| { |
| GLint resultI = 0; |
| glGetIntegerv(param, &resultI); |
| |
| GLfloat resultF = 0.0f; |
| glGetFloatv(param, &resultF); |
| |
| glPixelStorei(param, 0); |
| |
| EXPECT_GL_NO_ERROR(); |
| } |
| } |
| } |
| |
| TEST_P(WebGLCompatibilityTest, EnableTextureRectangle) |
| { |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_ANGLE_texture_rectangle")); |
| |
| GLTexture texture; |
| glBindTexture(GL_TEXTURE_RECTANGLE_ANGLE, texture); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| |
| GLint minFilter = 0; |
| glGetTexParameteriv(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_MIN_FILTER, &minFilter); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| |
| if (IsGLExtensionRequestable("GL_ANGLE_texture_rectangle")) |
| { |
| glRequestExtensionANGLE("GL_ANGLE_texture_rectangle"); |
| EXPECT_GL_NO_ERROR(); |
| |
| EXPECT_TRUE(IsGLExtensionEnabled("GL_ANGLE_texture_rectangle")); |
| |
| glBindTexture(GL_TEXTURE_RECTANGLE_ANGLE, texture); |
| EXPECT_GL_NO_ERROR(); |
| |
| glTexImage2D(GL_TEXTURE_RECTANGLE_ANGLE, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, |
| nullptr); |
| EXPECT_GL_NO_ERROR(); |
| |
| glDisableExtensionANGLE("GL_ANGLE_texture_rectangle"); |
| EXPECT_GL_NO_ERROR(); |
| |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_ANGLE_texture_rectangle")); |
| |
| glBindTexture(GL_TEXTURE_RECTANGLE_ANGLE, texture); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| } |
| } |
| |
| // Test enabling the GL_NV_pack_subimage extension |
| TEST_P(WebGLCompatibilityTest, EnablePackPackSubImageExtension) |
| { |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_NV_pack_subimage")); |
| |
| // This extensions become core in in ES3/WebGL2. |
| ANGLE_SKIP_TEST_IF(getClientMajorVersion() >= 3); |
| |
| constexpr GLenum parameters[] = { |
| GL_PACK_ROW_LENGTH, |
| GL_PACK_SKIP_ROWS, |
| GL_PACK_SKIP_PIXELS, |
| }; |
| |
| for (GLenum param : parameters) |
| { |
| GLint resultI = 0; |
| glGetIntegerv(param, &resultI); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| |
| GLfloat resultF = 0.0f; |
| glGetFloatv(param, &resultF); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| |
| glPixelStorei(param, 0); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| } |
| |
| if (IsGLExtensionRequestable("GL_NV_pack_subimage")) |
| { |
| glRequestExtensionANGLE("GL_NV_pack_subimage"); |
| EXPECT_GL_NO_ERROR(); |
| |
| for (GLenum param : parameters) |
| { |
| GLint resultI = 0; |
| glGetIntegerv(param, &resultI); |
| |
| GLfloat resultF = 0.0f; |
| glGetFloatv(param, &resultF); |
| |
| glPixelStorei(param, 0); |
| |
| EXPECT_GL_NO_ERROR(); |
| } |
| } |
| } |
| |
| TEST_P(WebGLCompatibilityTest, EnableRGB8RGBA8Extension) |
| { |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_OES_rgb8_rgba8")); |
| |
| // This extensions become core in in ES3/WebGL2. |
| ANGLE_SKIP_TEST_IF(getClientMajorVersion() >= 3); |
| |
| GLRenderbuffer renderbuffer; |
| glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer); |
| EXPECT_GL_NO_ERROR(); |
| |
| glRenderbufferStorage(GL_RENDERBUFFER, GL_RGB8_OES, 1, 1); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| |
| glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8_OES, 1, 1); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| |
| if (IsGLExtensionRequestable("GL_OES_rgb8_rgba8")) |
| { |
| glRequestExtensionANGLE("GL_OES_rgb8_rgba8"); |
| EXPECT_GL_NO_ERROR(); |
| |
| EXPECT_TRUE(IsGLExtensionEnabled("GL_OES_rgb8_rgba8")); |
| |
| glRenderbufferStorage(GL_RENDERBUFFER, GL_RGB8_OES, 1, 1); |
| EXPECT_GL_NO_ERROR(); |
| |
| glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8_OES, 1, 1); |
| EXPECT_GL_NO_ERROR(); |
| } |
| } |
| |
| // Test enabling the GL_ANGLE_framebuffer_blit extension |
| TEST_P(WebGLCompatibilityTest, EnableFramebufferBlitExtension) |
| { |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_ANGLE_framebuffer_blit")); |
| |
| // This extensions become core in in ES3/WebGL2. |
| ANGLE_SKIP_TEST_IF(getClientMajorVersion() >= 3); |
| |
| GLFramebuffer fbo; |
| |
| glBindFramebuffer(GL_READ_FRAMEBUFFER_ANGLE, fbo); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| |
| GLint result; |
| glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING_ANGLE, &result); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| |
| glBlitFramebufferANGLE(0, 0, 1, 1, 0, 0, 1, 1, GL_COLOR_BUFFER_BIT, GL_NEAREST); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| |
| if (IsGLExtensionRequestable("GL_ANGLE_framebuffer_blit")) |
| { |
| glRequestExtensionANGLE("GL_ANGLE_framebuffer_blit"); |
| EXPECT_GL_NO_ERROR(); |
| |
| glBindFramebuffer(GL_READ_FRAMEBUFFER_ANGLE, fbo); |
| glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING_ANGLE, &result); |
| EXPECT_GL_NO_ERROR(); |
| } |
| } |
| |
| // Test enabling the GL_OES_get_program_binary extension |
| TEST_P(WebGLCompatibilityTest, EnableProgramBinaryExtension) |
| { |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_OES_get_program_binary")); |
| |
| // This extensions become core in in ES3/WebGL2. |
| ANGLE_SKIP_TEST_IF(getClientMajorVersion() >= 3); |
| |
| GLint result = 0; |
| glGetIntegerv(GL_NUM_PROGRAM_BINARY_FORMATS, &result); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| |
| glGetIntegerv(GL_PROGRAM_BINARY_FORMATS, &result); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| |
| constexpr char kVS[] = |
| R"(void main() |
| { |
| gl_Position = vec4(0.0, 0.0, 0.0, 1.0); |
| })"; |
| constexpr char kFS[] = |
| R"(precision highp float; |
| void main() |
| { |
| gl_FragColor = vec4(1.0); |
| })"; |
| ANGLE_GL_PROGRAM(program, kVS, kFS); |
| |
| glGetProgramiv(program, GL_PROGRAM_BINARY_LENGTH, &result); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| |
| uint8_t tempArray[512]; |
| GLenum tempFormat = 0; |
| GLsizei tempLength = 0; |
| glGetProgramBinaryOES(program, static_cast<GLsizei>(ArraySize(tempArray)), &tempLength, |
| &tempFormat, tempArray); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| |
| if (IsGLExtensionRequestable("GL_OES_get_program_binary")) |
| { |
| glRequestExtensionANGLE("GL_OES_get_program_binary"); |
| EXPECT_GL_NO_ERROR(); |
| |
| glGetIntegerv(GL_NUM_PROGRAM_BINARY_FORMATS, &result); |
| glGetIntegerv(GL_PROGRAM_BINARY_FORMATS, &result); |
| EXPECT_GL_NO_ERROR(); |
| |
| GLint binaryLength = 0; |
| glGetProgramiv(program, GL_PROGRAM_BINARY_LENGTH, &binaryLength); |
| EXPECT_GL_NO_ERROR(); |
| |
| GLenum binaryFormat; |
| GLsizei writeLength = 0; |
| std::vector<uint8_t> binary(binaryLength); |
| glGetProgramBinaryOES(program, binaryLength, &writeLength, &binaryFormat, binary.data()); |
| EXPECT_GL_NO_ERROR(); |
| |
| glProgramBinaryOES(program, binaryFormat, binary.data(), binaryLength); |
| EXPECT_GL_NO_ERROR(); |
| } |
| } |
| |
| // Test enabling the GL_OES_vertex_array_object extension |
| TEST_P(WebGLCompatibilityTest, EnableVertexArrayExtension) |
| { |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_OES_vertex_array_object")); |
| |
| // This extensions become core in in ES3/WebGL2. |
| ANGLE_SKIP_TEST_IF(getClientMajorVersion() >= 3); |
| |
| GLint result = 0; |
| glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &result); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| |
| // Expect that GL_OES_vertex_array_object is always available. It is implemented in the GL |
| // frontend. |
| EXPECT_TRUE(IsGLExtensionRequestable("GL_OES_vertex_array_object")); |
| |
| glRequestExtensionANGLE("GL_OES_vertex_array_object"); |
| EXPECT_GL_NO_ERROR(); |
| |
| EXPECT_TRUE(IsGLExtensionEnabled("GL_OES_vertex_array_object")); |
| |
| glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &result); |
| EXPECT_GL_NO_ERROR(); |
| |
| GLuint vao = 0; |
| glGenVertexArraysOES(0, &vao); |
| EXPECT_GL_NO_ERROR(); |
| |
| glBindVertexArrayOES(vao); |
| EXPECT_GL_NO_ERROR(); |
| |
| glDeleteVertexArraysOES(1, &vao); |
| EXPECT_GL_NO_ERROR(); |
| } |
| |
| // Verify that the context generates the correct error when the framebuffer attachments are |
| // different sizes |
| TEST_P(WebGLCompatibilityTest, FramebufferAttachmentSizeMismatch) |
| { |
| GLFramebuffer fbo; |
| glBindFramebuffer(GL_FRAMEBUFFER, fbo); |
| |
| GLTexture textures[2]; |
| glBindTexture(GL_TEXTURE_2D, textures[0]); |
| glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textures[0], 0); |
| |
| ASSERT_GL_NO_ERROR(); |
| ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER)); |
| |
| GLRenderbuffer renderbuffer; |
| glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer); |
| glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, 3, 3); |
| glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, renderbuffer); |
| |
| ASSERT_GL_NO_ERROR(); |
| ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS, |
| glCheckFramebufferStatus(GL_FRAMEBUFFER)); |
| |
| if (IsGLExtensionRequestable("GL_EXT_draw_buffers")) |
| { |
| glRequestExtensionANGLE("GL_EXT_draw_buffers"); |
| EXPECT_GL_NO_ERROR(); |
| EXPECT_TRUE(IsGLExtensionEnabled("GL_EXT_draw_buffers")); |
| |
| glBindTexture(GL_TEXTURE_2D, textures[1]); |
| glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D, textures[1], 0); |
| ASSERT_GL_NO_ERROR(); |
| |
| ASSERT_GL_NO_ERROR(); |
| ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS, |
| glCheckFramebufferStatus(GL_FRAMEBUFFER)); |
| |
| glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, 0); |
| |
| ASSERT_GL_NO_ERROR(); |
| ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER)); |
| |
| glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 3, 3, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); |
| |
| ASSERT_GL_NO_ERROR(); |
| ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS, |
| glCheckFramebufferStatus(GL_FRAMEBUFFER)); |
| } |
| } |
| |
| // Test that client-side array buffers are forbidden in WebGL mode |
| TEST_P(WebGLCompatibilityTest, ForbidsClientSideArrayBuffer) |
| { |
| constexpr char kVS[] = |
| R"(attribute vec3 a_pos; |
| void main() |
| { |
| gl_Position = vec4(a_pos, 1.0); |
| })"; |
| |
| constexpr char kFS[] = |
| R"(precision highp float; |
| void main() |
| { |
| gl_FragColor = vec4(1.0); |
| })"; |
| |
| ANGLE_GL_PROGRAM(program, kVS, kFS); |
| |
| GLint posLocation = glGetAttribLocation(program.get(), "a_pos"); |
| ASSERT_NE(-1, posLocation); |
| glUseProgram(program.get()); |
| |
| const auto &vertices = GetQuadVertices(); |
| glVertexAttribPointer(posLocation, 3, GL_FLOAT, GL_FALSE, 4, vertices.data()); |
| glEnableVertexAttribArray(posLocation); |
| |
| ASSERT_GL_NO_ERROR(); |
| glDrawArrays(GL_TRIANGLES, 0, 6); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| } |
| |
| // Test that client-side element array buffers are forbidden in WebGL mode |
| TEST_P(WebGLCompatibilityTest, ForbidsClientSideElementBuffer) |
| { |
| constexpr char kVS[] = |
| R"(attribute vec3 a_pos; |
| void main() |
| { |
| gl_Position = vec4(a_pos, 1.0); |
| })"; |
| |
| constexpr char kFS[] = |
| R"(precision highp float; |
| void main() |
| { |
| gl_FragColor = vec4(1.0); |
| })"; |
| |
| ANGLE_GL_PROGRAM(program, kVS, kFS); |
| |
| GLint posLocation = glGetAttribLocation(program.get(), "a_pos"); |
| ASSERT_NE(-1, posLocation); |
| glUseProgram(program.get()); |
| |
| const auto &vertices = GetQuadVertices(); |
| |
| GLBuffer vertexBuffer; |
| glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer.get()); |
| glBufferData(GL_ARRAY_BUFFER, sizeof(vertices[0]) * vertices.size(), vertices.data(), |
| GL_STATIC_DRAW); |
| |
| glVertexAttribPointer(posLocation, 3, GL_FLOAT, GL_FALSE, 0, 0); |
| glEnableVertexAttribArray(posLocation); |
| |
| ASSERT_GL_NO_ERROR(); |
| |
| // Use the pointer with value of 1 for indices instead of an actual pointer because WebGL also |
| // enforces that the top bit of indices must be 0 (i.e. offset >= 0) and would generate |
| // GL_INVALID_VALUE in that case. Using a null pointer gets caught by another check. |
| glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, reinterpret_cast<const void *>(intptr_t(1))); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| } |
| |
| // Test that client-side array buffers are forbidden even if the program doesn't use the attribute |
| TEST_P(WebGLCompatibilityTest, ForbidsClientSideArrayBufferEvenNotUsedOnes) |
| { |
| constexpr char kVS[] = |
| R"(void main() |
| { |
| gl_Position = vec4(1.0); |
| })"; |
| |
| constexpr char kFS[] = |
| R"(precision highp float; |
| void main() |
| { |
| gl_FragColor = vec4(1.0); |
| })"; |
| |
| ANGLE_GL_PROGRAM(program, kVS, kFS); |
| |
| glUseProgram(program.get()); |
| |
| const auto &vertices = GetQuadVertices(); |
| glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 4, vertices.data()); |
| glEnableVertexAttribArray(0); |
| |
| ASSERT_GL_NO_ERROR(); |
| glDrawArrays(GL_TRIANGLES, 0, 6); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| } |
| |
| // Test that passing a null pixel data pointer to TexSubImage calls generates an INVALID_VALUE error |
| TEST_P(WebGLCompatibilityTest, NullPixelDataForSubImage) |
| { |
| // glTexSubImage2D |
| { |
| GLTexture texture; |
| glBindTexture(GL_TEXTURE_2D, texture); |
| |
| // TexImage with null data - OK |
| glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); |
| EXPECT_GL_NO_ERROR(); |
| |
| // TexSubImage with zero size and null data - OK |
| glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); |
| EXPECT_GL_NO_ERROR(); |
| |
| // TexSubImage with non-zero size and null data - Invalid value |
| glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); |
| EXPECT_GL_ERROR(GL_INVALID_VALUE); |
| } |
| |
| // glTexSubImage3D |
| if (getClientMajorVersion() >= 3) |
| { |
| GLTexture texture; |
| glBindTexture(GL_TEXTURE_3D, texture); |
| |
| // TexImage with null data - OK |
| glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); |
| EXPECT_GL_NO_ERROR(); |
| |
| // TexSubImage with zero size and null data - OK |
| glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); |
| EXPECT_GL_NO_ERROR(); |
| |
| // TexSubImage with non-zero size and null data - Invalid value |
| glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 1, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); |
| EXPECT_GL_ERROR(GL_INVALID_VALUE); |
| } |
| } |
| |
| // Tests the WebGL requirement of having the same stencil mask, writemask and ref for front and back |
| // (when stencil testing is enabled) |
| void WebGLCompatibilityTest::TestDifferentStencilMaskAndRef(GLenum errIfMismatch) |
| { |
| // Run the test in an FBO to make sure we have some stencil bits. |
| GLRenderbuffer renderbuffer; |
| glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer.get()); |
| glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 32, 32); |
| |
| GLFramebuffer framebuffer; |
| glBindFramebuffer(GL_FRAMEBUFFER, framebuffer.get()); |
| glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, |
| renderbuffer.get()); |
| |
| ANGLE_GL_PROGRAM(program, "void main() { gl_Position = vec4(0, 0, 0, 1); }", |
| "void main() { gl_FragColor = vec4(0, 1, 0, 1); }"); |
| glUseProgram(program.get()); |
| ASSERT_GL_NO_ERROR(); |
| |
| // Having ref and mask the same for front and back is valid. |
| glStencilMask(255); |
| glStencilFunc(GL_ALWAYS, 0, 255); |
| glDrawArrays(GL_TRIANGLES, 0, 6); |
| ASSERT_GL_NO_ERROR(); |
| |
| // Having a different front - back write mask generates an error. |
| glStencilMaskSeparate(GL_FRONT, 1); |
| glDrawArrays(GL_TRIANGLES, 0, 6); |
| EXPECT_GL_ERROR(errIfMismatch); |
| |
| // Setting both write masks separately to the same value is valid. |
| glStencilMaskSeparate(GL_BACK, 1); |
| glDrawArrays(GL_TRIANGLES, 0, 6); |
| ASSERT_GL_NO_ERROR(); |
| |
| // Having a different stencil front - back mask generates an error |
| glStencilFuncSeparate(GL_FRONT, GL_ALWAYS, 0, 1); |
| glDrawArrays(GL_TRIANGLES, 0, 6); |
| EXPECT_GL_ERROR(errIfMismatch); |
| |
| // Setting both masks separately to the same value is valid. |
| glStencilFuncSeparate(GL_BACK, GL_ALWAYS, 0, 1); |
| glDrawArrays(GL_TRIANGLES, 0, 6); |
| ASSERT_GL_NO_ERROR(); |
| |
| // Having a different stencil front - back reference generates an error |
| glStencilFuncSeparate(GL_FRONT, GL_ALWAYS, 255, 1); |
| glDrawArrays(GL_TRIANGLES, 0, 6); |
| EXPECT_GL_ERROR(errIfMismatch); |
| |
| // Setting both references separately to the same value is valid. |
| glStencilFuncSeparate(GL_BACK, GL_ALWAYS, 255, 1); |
| glDrawArrays(GL_TRIANGLES, 0, 6); |
| ASSERT_GL_NO_ERROR(); |
| |
| // Using different stencil funcs, everything being equal is valid. |
| glStencilFuncSeparate(GL_BACK, GL_NEVER, 255, 1); |
| glDrawArrays(GL_TRIANGLES, 0, 6); |
| ASSERT_GL_NO_ERROR(); |
| } |
| |
| TEST_P(WebGLCompatibilityTest, StencilTestEnabledDisallowsDifferentStencilMaskAndRef) |
| { |
| glEnable(GL_STENCIL_TEST); |
| TestDifferentStencilMaskAndRef(GL_INVALID_OPERATION); |
| } |
| |
| TEST_P(WebGLCompatibilityTest, StencilTestDisabledAllowsDifferentStencilMaskAndRef) |
| { |
| glDisable(GL_STENCIL_TEST); |
| TestDifferentStencilMaskAndRef(GL_NO_ERROR); |
| } |
| |
| // Test that GL_FIXED is forbidden |
| TEST_P(WebGLCompatibilityTest, ForbidsGLFixed) |
| { |
| GLBuffer buffer; |
| glBindBuffer(GL_ARRAY_BUFFER, buffer.get()); |
| glBufferData(GL_ARRAY_BUFFER, 16, nullptr, GL_STATIC_DRAW); |
| |
| glVertexAttribPointer(0, 1, GL_FLOAT, GL_FALSE, 0, nullptr); |
| ASSERT_GL_NO_ERROR(); |
| |
| glVertexAttribPointer(0, 1, GL_FIXED, GL_FALSE, 0, nullptr); |
| EXPECT_GL_ERROR(GL_INVALID_ENUM); |
| } |
| |
| // Test the WebGL limit of 255 for the attribute stride |
| TEST_P(WebGLCompatibilityTest, MaxStride) |
| { |
| GLBuffer buffer; |
| glBindBuffer(GL_ARRAY_BUFFER, buffer.get()); |
| glBufferData(GL_ARRAY_BUFFER, 1024, nullptr, GL_STATIC_DRAW); |
| |
| glVertexAttribPointer(0, 1, GL_UNSIGNED_BYTE, GL_FALSE, 255, nullptr); |
| ASSERT_GL_NO_ERROR(); |
| |
| glVertexAttribPointer(0, 1, GL_UNSIGNED_BYTE, GL_FALSE, 256, nullptr); |
| EXPECT_GL_ERROR(GL_INVALID_VALUE); |
| } |
| |
| // Test the checks for OOB reads in the vertex buffers, non-instanced version |
| TEST_P(WebGLCompatibilityTest, DrawArraysBufferOutOfBoundsNonInstanced) |
| { |
| constexpr char kVS[] = |
| R"(attribute float a_pos; |
| void main() |
| { |
| gl_Position = vec4(a_pos, a_pos, a_pos, 1.0); |
| })"; |
| |
| ANGLE_GL_PROGRAM(program, kVS, essl1_shaders::fs::Red()); |
| GLint posLocation = glGetAttribLocation(program.get(), "a_pos"); |
| ASSERT_NE(-1, posLocation); |
| glUseProgram(program.get()); |
| |
| GLBuffer buffer; |
| glBindBuffer(GL_ARRAY_BUFFER, buffer.get()); |
| glBufferData(GL_ARRAY_BUFFER, 16, nullptr, GL_STATIC_DRAW); |
| |
| glEnableVertexAttribArray(posLocation); |
| |
| const uint8_t *zeroOffset = nullptr; |
| |
| // Test touching the last element is valid. |
| glVertexAttribPointer(posLocation, 1, GL_UNSIGNED_BYTE, GL_FALSE, 0, zeroOffset + 12); |
| glDrawArrays(GL_POINTS, 0, 4); |
| ASSERT_GL_NO_ERROR(); |
| |
| // Test touching the last element + 1 is invalid. |
| glVertexAttribPointer(posLocation, 1, GL_UNSIGNED_BYTE, GL_FALSE, 0, zeroOffset + 13); |
| glDrawArrays(GL_POINTS, 0, 4); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| |
| // Test touching the last element is valid, using a stride. |
| glVertexAttribPointer(posLocation, 1, GL_UNSIGNED_BYTE, GL_FALSE, 2, zeroOffset + 9); |
| glDrawArrays(GL_POINTS, 0, 4); |
| ASSERT_GL_NO_ERROR(); |
| |
| // Test touching the last element + 1 is invalid, using a stride. |
| glVertexAttribPointer(posLocation, 1, GL_UNSIGNED_BYTE, GL_FALSE, 2, zeroOffset + 10); |
| glDrawArrays(GL_POINTS, 0, 4); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| |
| // Test any offset is valid if no vertices are drawn. |
| glVertexAttribPointer(posLocation, 1, GL_UNSIGNED_BYTE, GL_FALSE, 0, zeroOffset + 32); |
| glDrawArrays(GL_POINTS, 0, 0); |
| ASSERT_GL_NO_ERROR(); |
| |
| // Test a case of overflow that could give a max vertex that's negative |
| constexpr GLint kIntMax = std::numeric_limits<GLint>::max(); |
| glVertexAttribPointer(posLocation, 1, GL_UNSIGNED_BYTE, GL_FALSE, 0, zeroOffset + 0); |
| glDrawArrays(GL_POINTS, kIntMax, kIntMax); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| } |
| |
| // Test that index values outside of the 32-bit integer range do not read out of bounds |
| TEST_P(WebGLCompatibilityTest, LargeIndexRange) |
| { |
| ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_OES_element_index_uint")); |
| |
| constexpr char kVS[] = |
| R"(attribute vec4 a_Position; |
| void main() |
| { |
| gl_Position = a_Position; |
| })"; |
| |
| ANGLE_GL_PROGRAM(program, kVS, essl1_shaders::fs::Red()); |
| glUseProgram(program.get()); |
| |
| glEnableVertexAttribArray(glGetAttribLocation(program, "a_Position")); |
| |
| constexpr float kVertexData[] = { |
| 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, |
| }; |
| |
| GLBuffer vertexBuffer; |
| glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer); |
| glBufferData(GL_ARRAY_BUFFER, sizeof(kVertexData), kVertexData, GL_STREAM_DRAW); |
| |
| constexpr GLuint kMaxIntAsGLuint = static_cast<GLuint>(std::numeric_limits<GLint>::max()); |
| constexpr GLuint kIndexData[] = { |
| kMaxIntAsGLuint, |
| kMaxIntAsGLuint + 1, |
| kMaxIntAsGLuint + 2, |
| kMaxIntAsGLuint + 3, |
| }; |
| |
| GLBuffer indexBuffer; |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vertexBuffer); |
| glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(kIndexData), kIndexData, GL_DYNAMIC_DRAW); |
| |
| EXPECT_GL_NO_ERROR(); |
| |
| // First index is representable as 32-bit int but second is not |
| glDrawElements(GL_LINES, 2, GL_UNSIGNED_INT, 0); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| |
| // Neither index is representable as 32-bit int |
| glDrawElements(GL_LINES, 2, GL_UNSIGNED_INT, reinterpret_cast<void *>(sizeof(GLuint) * 2)); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| } |
| |
| // Test for drawing with a null index buffer |
| TEST_P(WebGLCompatibilityTest, NullIndexBuffer) |
| { |
| constexpr char kVS[] = |
| R"(attribute float a_pos; |
| void main() |
| { |
| gl_Position = vec4(a_pos, a_pos, a_pos, 1.0); |
| })"; |
| |
| ANGLE_GL_PROGRAM(program, kVS, essl1_shaders::fs::Red()); |
| glUseProgram(program.get()); |
| |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); |
| glEnableVertexAttribArray(0); |
| |
| glDrawElements(GL_TRIANGLES, 0, GL_UNSIGNED_BYTE, 0); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| } |
| |
| // Test the checks for OOB reads in the vertex buffers, instanced version |
| TEST_P(WebGL2CompatibilityTest, DrawArraysBufferOutOfBoundsInstanced) |
| { |
| constexpr char kVS[] = |
| R"(attribute float a_pos; |
| attribute float a_w; |
| void main() |
| { |
| gl_Position = vec4(a_pos, a_pos, a_pos, a_w); |
| })"; |
| |
| ANGLE_GL_PROGRAM(program, kVS, essl1_shaders::fs::Red()); |
| GLint posLocation = glGetAttribLocation(program.get(), "a_pos"); |
| GLint wLocation = glGetAttribLocation(program.get(), "a_w"); |
| ASSERT_NE(-1, posLocation); |
| ASSERT_NE(-1, wLocation); |
| glUseProgram(program.get()); |
| |
| GLBuffer buffer; |
| glBindBuffer(GL_ARRAY_BUFFER, buffer.get()); |
| glBufferData(GL_ARRAY_BUFFER, 16, nullptr, GL_STATIC_DRAW); |
| |
| glEnableVertexAttribArray(posLocation); |
| glVertexAttribPointer(posLocation, 1, GL_UNSIGNED_BYTE, GL_FALSE, 0, 0); |
| glVertexAttribDivisor(posLocation, 0); |
| |
| glEnableVertexAttribArray(wLocation); |
| glVertexAttribDivisor(wLocation, 1); |
| |
| const uint8_t *zeroOffset = nullptr; |
| |
| // Test touching the last element is valid. |
| glVertexAttribPointer(wLocation, 1, GL_UNSIGNED_BYTE, GL_FALSE, 0, zeroOffset + 12); |
| glDrawArraysInstanced(GL_POINTS, 0, 1, 4); |
| ASSERT_GL_NO_ERROR(); |
| |
| // Test touching the last element + 1 is invalid. |
| glVertexAttribPointer(wLocation, 1, GL_UNSIGNED_BYTE, GL_FALSE, 0, zeroOffset + 13); |
| glDrawArraysInstanced(GL_POINTS, 0, 1, 4); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| |
| // Test touching the last element is valid, using a stride. |
| glVertexAttribPointer(wLocation, 1, GL_UNSIGNED_BYTE, GL_FALSE, 2, zeroOffset + 9); |
| glDrawArraysInstanced(GL_POINTS, 0, 1, 4); |
| ASSERT_GL_NO_ERROR(); |
| |
| // Test touching the last element + 1 is invalid, using a stride. |
| glVertexAttribPointer(wLocation, 1, GL_UNSIGNED_BYTE, GL_FALSE, 2, zeroOffset + 10); |
| glDrawArraysInstanced(GL_POINTS, 0, 1, 4); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| |
| // Test any offset is valid if no vertices are drawn. |
| glVertexAttribPointer(wLocation, 1, GL_UNSIGNED_BYTE, GL_FALSE, 0, zeroOffset + 32); |
| glDrawArraysInstanced(GL_POINTS, 0, 0, 1); |
| ASSERT_GL_NO_ERROR(); |
| |
| // Test any offset is valid if no primitives are drawn. |
| glVertexAttribPointer(wLocation, 1, GL_UNSIGNED_BYTE, GL_FALSE, 0, zeroOffset + 32); |
| glDrawArraysInstanced(GL_POINTS, 0, 1, 0); |
| ASSERT_GL_NO_ERROR(); |
| } |
| |
| // Test the checks for OOB reads in the vertex buffers, ANGLE_instanced_arrays version |
| TEST_P(WebGLCompatibilityTest, DrawArraysBufferOutOfBoundsInstancedANGLE) |
| { |
| ANGLE_SKIP_TEST_IF(!IsGLExtensionRequestable("GL_ANGLE_instanced_arrays")); |
| glRequestExtensionANGLE("GL_ANGLE_instanced_arrays"); |
| EXPECT_GL_NO_ERROR(); |
| |
| constexpr char kVS[] = |
| R"(attribute float a_pos; |
| attribute float a_w; |
| void main() |
| { |
| gl_Position = vec4(a_pos, a_pos, a_pos, a_w); |
| })"; |
| |
| ANGLE_GL_PROGRAM(program, kVS, essl1_shaders::fs::Red()); |
| GLint posLocation = glGetAttribLocation(program.get(), "a_pos"); |
| GLint wLocation = glGetAttribLocation(program.get(), "a_w"); |
| ASSERT_NE(-1, posLocation); |
| ASSERT_NE(-1, wLocation); |
| glUseProgram(program.get()); |
| |
| GLBuffer buffer; |
| glBindBuffer(GL_ARRAY_BUFFER, buffer.get()); |
| glBufferData(GL_ARRAY_BUFFER, 16, nullptr, GL_STATIC_DRAW); |
| |
| glEnableVertexAttribArray(posLocation); |
| glVertexAttribPointer(posLocation, 1, GL_UNSIGNED_BYTE, GL_FALSE, 0, 0); |
| glVertexAttribDivisorANGLE(posLocation, 0); |
| |
| glEnableVertexAttribArray(wLocation); |
| glVertexAttribDivisorANGLE(wLocation, 1); |
| |
| const uint8_t *zeroOffset = nullptr; |
| |
| // Test touching the last element is valid. |
| glVertexAttribPointer(wLocation, 1, GL_UNSIGNED_BYTE, GL_FALSE, 0, zeroOffset + 12); |
| glDrawArraysInstancedANGLE(GL_POINTS, 0, 1, 4); |
| ASSERT_GL_NO_ERROR() << "touching the last element."; |
| |
| // Test touching the last element + 1 is invalid. |
| glVertexAttribPointer(wLocation, 1, GL_UNSIGNED_BYTE, GL_FALSE, 0, zeroOffset + 13); |
| glDrawArraysInstancedANGLE(GL_POINTS, 0, 1, 4); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION) << "touching the last element + 1."; |
| |
| // Test touching the last element is valid, using a stride. |
| glVertexAttribPointer(wLocation, 1, GL_UNSIGNED_BYTE, GL_FALSE, 2, zeroOffset + 9); |
| glDrawArraysInstancedANGLE(GL_POINTS, 0, 1, 4); |
| ASSERT_GL_NO_ERROR() << "touching the last element using a stride."; |
| |
| // Test touching the last element + 1 is invalid, using a stride. |
| glVertexAttribPointer(wLocation, 1, GL_UNSIGNED_BYTE, GL_FALSE, 2, zeroOffset + 10); |
| glDrawArraysInstancedANGLE(GL_POINTS, 0, 1, 4); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION) << "touching the last element + 1 using a stride."; |
| |
| // Test any offset is valid if no vertices are drawn. |
| glVertexAttribPointer(wLocation, 1, GL_UNSIGNED_BYTE, GL_FALSE, 0, zeroOffset + 32); |
| glDrawArraysInstancedANGLE(GL_POINTS, 0, 0, 1); |
| ASSERT_GL_NO_ERROR() << "any offset with no vertices."; |
| |
| // Test any offset is valid if no primitives are drawn. |
| glVertexAttribPointer(wLocation, 1, GL_UNSIGNED_BYTE, GL_FALSE, 0, zeroOffset + 32); |
| glDrawArraysInstancedANGLE(GL_POINTS, 0, 1, 0); |
| ASSERT_GL_NO_ERROR() << "any offset with primitives."; |
| } |
| |
| // Test the checks for OOB reads in the index buffer |
| TEST_P(WebGLCompatibilityTest, DrawElementsBufferOutOfBoundsInIndexBuffer) |
| { |
| constexpr char kVS[] = |
| R"(attribute float a_pos; |
| void main() |
| { |
| gl_Position = vec4(a_pos, a_pos, a_pos, 1.0); |
| })"; |
| |
| ANGLE_GL_PROGRAM(program, kVS, essl1_shaders::fs::Red()); |
| GLint posLocation = glGetAttribLocation(program.get(), "a_pos"); |
| ASSERT_NE(-1, posLocation); |
| glUseProgram(program.get()); |
| |
| GLBuffer vertexBuffer; |
| glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer.get()); |
| glBufferData(GL_ARRAY_BUFFER, 16, nullptr, GL_STATIC_DRAW); |
| |
| glEnableVertexAttribArray(posLocation); |
| glVertexAttribPointer(posLocation, 1, GL_UNSIGNED_BYTE, GL_FALSE, 0, nullptr); |
| |
| const uint8_t *zeroOffset = nullptr; |
| const uint8_t zeroIndices[] = {0, 0, 0, 0, 0, 0, 0, 0}; |
| |
| GLBuffer indexBuffer; |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer.get()); |
| glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(zeroIndices), zeroIndices, GL_STATIC_DRAW); |
| ASSERT_GL_NO_ERROR(); |
| |
| // Test touching the last index is valid |
| glDrawElements(GL_POINTS, 4, GL_UNSIGNED_BYTE, zeroOffset + 4); |
| ASSERT_GL_NO_ERROR(); |
| |
| // Test touching the last + 1 element is invalid |
| glDrawElements(GL_POINTS, 4, GL_UNSIGNED_BYTE, zeroOffset + 5); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| |
| // Test any offset if valid if count is zero |
| glDrawElements(GL_POINTS, 0, GL_UNSIGNED_BYTE, zeroOffset + 42); |
| ASSERT_GL_NO_ERROR(); |
| |
| // Test touching the first index is valid |
| glDrawElements(GL_POINTS, 4, GL_UNSIGNED_BYTE, zeroOffset + 4); |
| ASSERT_GL_NO_ERROR(); |
| |
| // Test touching the first - 1 index is invalid |
| // The error ha been specified to be INVALID_VALUE instead of INVALID_OPERATION because it was |
| // the historic behavior of WebGL implementations |
| glDrawElements(GL_POINTS, 4, GL_UNSIGNED_BYTE, zeroOffset - 1); |
| EXPECT_GL_ERROR(GL_INVALID_VALUE); |
| } |
| |
| // Test the checks for OOB in vertex buffers caused by indices, non-instanced version |
| TEST_P(WebGLCompatibilityTest, DrawElementsBufferOutOfBoundsInVertexBuffer) |
| { |
| constexpr char kVS[] = |
| R"(attribute float a_pos; |
| void main() |
| { |
| gl_Position = vec4(a_pos, a_pos, a_pos, 1.0); |
| })"; |
| |
| ANGLE_GL_PROGRAM(program, kVS, essl1_shaders::fs::Red()); |
| GLint posLocation = glGetAttribLocation(program.get(), "a_pos"); |
| ASSERT_NE(-1, posLocation); |
| glUseProgram(program.get()); |
| |
| GLBuffer vertexBuffer; |
| glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer.get()); |
| glBufferData(GL_ARRAY_BUFFER, 8, nullptr, GL_STATIC_DRAW); |
| |
| glEnableVertexAttribArray(posLocation); |
| glVertexAttribPointer(posLocation, 1, GL_UNSIGNED_BYTE, GL_FALSE, 0, nullptr); |
| |
| const uint8_t *zeroOffset = nullptr; |
| const uint8_t testIndices[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 255}; |
| |
| GLBuffer indexBuffer; |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer.get()); |
| glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(testIndices), testIndices, GL_STATIC_DRAW); |
| ASSERT_GL_NO_ERROR(); |
| |
| // Test touching the end of the vertex buffer is valid |
| glDrawElements(GL_POINTS, 1, GL_UNSIGNED_BYTE, zeroOffset + 7); |
| ASSERT_GL_NO_ERROR(); |
| |
| // Test touching just after the end of the vertex buffer is invalid |
| glDrawElements(GL_POINTS, 1, GL_UNSIGNED_BYTE, zeroOffset + 8); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| |
| // Test touching the whole vertex buffer is valid |
| glDrawElements(GL_POINTS, 8, GL_UNSIGNED_BYTE, zeroOffset + 0); |
| ASSERT_GL_NO_ERROR(); |
| |
| // Test an index that would be negative |
| glDrawElements(GL_POINTS, 1, GL_UNSIGNED_BYTE, zeroOffset + 9); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| } |
| |
| // Test depth range with 'near' more or less than 'far.' |
| TEST_P(WebGLCompatibilityTest, DepthRange) |
| { |
| glDepthRangef(0, 1); |
| ASSERT_GL_NO_ERROR(); |
| |
| glDepthRangef(.5, .5); |
| ASSERT_GL_NO_ERROR(); |
| |
| glDepthRangef(1, 0); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| } |
| |
| // Test all blend function combinations. |
| // In WebGL it is invalid to combine constant color with constant alpha. |
| TEST_P(WebGLCompatibilityTest, BlendWithConstantColor) |
| { |
| constexpr GLenum srcFunc[] = { |
| GL_ZERO, |
| GL_ONE, |
| GL_SRC_COLOR, |
| GL_ONE_MINUS_SRC_COLOR, |
| GL_DST_COLOR, |
| GL_ONE_MINUS_DST_COLOR, |
| GL_SRC_ALPHA, |
| GL_ONE_MINUS_SRC_ALPHA, |
| GL_DST_ALPHA, |
| GL_ONE_MINUS_DST_ALPHA, |
| GL_CONSTANT_COLOR, |
| GL_ONE_MINUS_CONSTANT_COLOR, |
| GL_CONSTANT_ALPHA, |
| GL_ONE_MINUS_CONSTANT_ALPHA, |
| GL_SRC_ALPHA_SATURATE, |
| }; |
| |
| constexpr GLenum dstFunc[] = { |
| GL_ZERO, GL_ONE, |
| GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, |
| GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR, |
| GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, |
| GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA, |
| GL_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_COLOR, |
| GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA, |
| }; |
| |
| for (GLenum src : srcFunc) |
| { |
| for (GLenum dst : dstFunc) |
| { |
| glBlendFunc(src, dst); |
| CheckBlendFunctions(src, dst); |
| glBlendFuncSeparate(src, dst, GL_ONE, GL_ONE); |
| CheckBlendFunctions(src, dst); |
| } |
| } |
| } |
| |
| // Test that binding/querying uniforms and attributes with invalid names generates errors |
| TEST_P(WebGLCompatibilityTest, InvalidAttributeAndUniformNames) |
| { |
| const std::string validAttribName = |
| "abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890"; |
| const std::string validUniformName = |
| "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_1234567890"; |
| std::vector<char> invalidSet = {'"', '$', '`', '@', '\''}; |
| if (getClientMajorVersion() < 3) |
| { |
| invalidSet.push_back('\\'); |
| } |
| |
| std::string vert = "attribute float "; |
| vert += validAttribName; |
| vert += |
| R"(; |
| void main() |
| { |
| gl_Position = vec4(1.0); |
| })"; |
| |
| std::string frag = |
| R"(precision highp float; |
| uniform vec4 )"; |
| frag += validUniformName; |
| // Insert illegal characters into comments |
| frag += |
| R"(; |
| // $ \" @ /* |
| void main() |
| {/* |
| ` @ $ |
| */gl_FragColor = vec4(1.0); |
| })"; |
| |
| ANGLE_GL_PROGRAM(program, vert.c_str(), frag.c_str()); |
| EXPECT_GL_NO_ERROR(); |
| |
| for (char invalidChar : invalidSet) |
| { |
| std::string invalidName = validAttribName + invalidChar; |
| glGetAttribLocation(program, invalidName.c_str()); |
| EXPECT_GL_ERROR(GL_INVALID_VALUE) |
| << "glGetAttribLocation unexpectedly succeeded for name \"" << invalidName << "\"."; |
| |
| glBindAttribLocation(program, 0, invalidName.c_str()); |
| EXPECT_GL_ERROR(GL_INVALID_VALUE) |
| << "glBindAttribLocation unexpectedly succeeded for name \"" << invalidName << "\"."; |
| } |
| |
| for (char invalidChar : invalidSet) |
| { |
| std::string invalidName = validUniformName + invalidChar; |
| glGetUniformLocation(program, invalidName.c_str()); |
| EXPECT_GL_ERROR(GL_INVALID_VALUE) |
| << "glGetUniformLocation unexpectedly succeeded for name \"" << invalidName << "\"."; |
| } |
| |
| for (char invalidChar : invalidSet) |
| { |
| std::string invalidAttribName = validAttribName + invalidChar; |
| const char *invalidVert[] = { |
| "attribute float ", |
| invalidAttribName.c_str(), |
| R"(;, |
| void main(), |
| {, |
| gl_Position = vec4(1.0);, |
| })", |
| }; |
| |
| GLuint shader = glCreateShader(GL_VERTEX_SHADER); |
| glShaderSource(shader, static_cast<GLsizei>(ArraySize(invalidVert)), invalidVert, nullptr); |
| EXPECT_GL_ERROR(GL_INVALID_VALUE); |
| glDeleteShader(shader); |
| } |
| } |
| |
| // Test that line continuation is handled correctly when valdiating shader source |
| TEST_P(WebGLCompatibilityTest, ShaderSourceLineContinuation) |
| { |
| // Verify that a line continuation character (i.e. backslash) cannot be used |
| // within a preprocessor directive in a ES2 context. |
| ANGLE_SKIP_TEST_IF(getClientMajorVersion() >= 3); |
| |
| const char *validVert = |
| R"(#define foo this is a test |
| precision mediump float; |
| void main() |
| { |
| gl_Position = vec4(1.0); |
| })"; |
| |
| const char *invalidVert = |
| R"(#define foo this \ |
| is a test |
| precision mediump float; |
| void main() |
| { |
| gl_Position = vec4(1.0); |
| })"; |
| |
| GLuint shader = glCreateShader(GL_VERTEX_SHADER); |
| glShaderSource(shader, 1, &validVert, nullptr); |
| EXPECT_GL_NO_ERROR(); |
| |
| glShaderSource(shader, 1, &invalidVert, nullptr); |
| EXPECT_GL_ERROR(GL_INVALID_VALUE); |
| glDeleteShader(shader); |
| } |
| |
| // Test that line continuation is handled correctly when valdiating shader source |
| TEST_P(WebGL2CompatibilityTest, ShaderSourceLineContinuation) |
| { |
| const char *validVert = |
| R"(#version 300 es |
| precision mediump float; |
| |
| void main () |
| { |
| float f\ |
| oo = 1.0; |
| gl_Position = vec4(foo); |
| })"; |
| |
| const char *invalidVert = |
| R"(#version 300 es |
| precision mediump float; |
| |
| void main () |
| { |
| float f\$ |
| oo = 1.0; |
| gl_Position = vec4(foo); |
| })"; |
| |
| GLuint shader = glCreateShader(GL_VERTEX_SHADER); |
| glShaderSource(shader, 1, &validVert, nullptr); |
| EXPECT_GL_NO_ERROR(); |
| glShaderSource(shader, 1, &invalidVert, nullptr); |
| EXPECT_GL_ERROR(GL_INVALID_VALUE); |
| glDeleteShader(shader); |
| } |
| |
| // Tests bindAttribLocations for reserved prefixes and length limits |
| TEST_P(WebGLCompatibilityTest, BindAttribLocationLimitation) |
| { |
| constexpr int maxLocStringLength = 256; |
| const std::string tooLongString(maxLocStringLength + 1, '_'); |
| |
| glBindAttribLocation(0, 0, "_webgl_var"); |
| |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| |
| glBindAttribLocation(0, 0, static_cast<const GLchar *>(tooLongString.c_str())); |
| |
| EXPECT_GL_ERROR(GL_INVALID_VALUE); |
| } |
| |
| // Test that having no attributes with a zero divisor is valid in WebGL2 |
| TEST_P(WebGL2CompatibilityTest, InstancedDrawZeroDivisor) |
| { |
| constexpr char kVS[] = |
| R"(attribute float a_pos; |
| void main() |
| { |
| gl_Position = vec4(a_pos, a_pos, a_pos, 1.0); |
| })"; |
| |
| ANGLE_GL_PROGRAM(program, kVS, essl1_shaders::fs::Red()); |
| |
| GLint posLocation = glGetAttribLocation(program.get(), "a_pos"); |
| ASSERT_NE(-1, posLocation); |
| |
| glUseProgram(program.get()); |
| |
| GLBuffer buffer; |
| glBindBuffer(GL_ARRAY_BUFFER, buffer.get()); |
| glBufferData(GL_ARRAY_BUFFER, 16, nullptr, GL_STATIC_DRAW); |
| |
| glEnableVertexAttribArray(posLocation); |
| glVertexAttribDivisor(posLocation, 1); |
| |
| glVertexAttribPointer(0, 1, GL_UNSIGNED_BYTE, GL_FALSE, 0, nullptr); |
| glDrawArraysInstanced(GL_POINTS, 0, 1, 4); |
| ASSERT_GL_NO_ERROR(); |
| } |
| |
| // Tests that NPOT is not enabled by default in WebGL 1 and that it can be enabled |
| TEST_P(WebGLCompatibilityTest, NPOT) |
| { |
| EXPECT_FALSE(IsGLExtensionEnabled("GL_OES_texture_npot")); |
| |
| // Create a texture and set an NPOT mip 0, should always be acceptable. |
| GLTexture texture; |
| glBindTexture(GL_TEXTURE_2D, texture.get()); |
| glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 10, 10, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); |
| ASSERT_GL_NO_ERROR(); |
| |
| // Try setting an NPOT mip 1 and verify the error if WebGL 1 |
| glTexImage2D(GL_TEXTURE_2D, 1, GL_RGBA, 5, 5, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); |
| if (getClientMajorVersion() < 3) |
| { |
| ASSERT_GL_ERROR(GL_INVALID_VALUE); |
| } |
| else |
| { |
| ASSERT_GL_NO_ERROR(); |
| } |
| |
| if (IsGLExtensionRequestable("GL_OES_texture_npot")) |
| { |
| glRequestExtensionANGLE("GL_OES_texture_npot"); |
| ASSERT_GL_NO_ERROR(); |
| |
| // Try again to set NPOT mip 1 |
| glTexImage2D(GL_TEXTURE_2D, 1, GL_RGBA, 5, 5, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); |
| ASSERT_GL_NO_ERROR(); |
| } |
| } |
| |
| template <typename T> |
| void FillTexture2D(GLuint texture, |
| GLsizei width, |
| GLsizei height, |
| const T &onePixelData, |
| GLint level, |
| GLint internalFormat, |
| GLenum format, |
| GLenum type) |
| { |
| std::vector<T> allPixelsData(width * height, onePixelData); |
| |
| glBindTexture(GL_TEXTURE_2D, texture); |
| glTexImage2D(GL_TEXTURE_2D, level, internalFormat, width, height, 0, format, type, |
| allPixelsData.data()); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); |
| } |
| |
| // Test that unset gl_Position defaults to (0,0,0,0). |
| TEST_P(WebGLCompatibilityTest, DefaultPosition) |
| { |
| // Draw a quad where each vertex is red if gl_Position is (0,0,0,0) before it is set, |
| // and green otherwise. The center of each quadrant will be red if and only if all |
| // four corners are red. |
| constexpr char kVS[] = |
| R"(attribute vec3 pos; |
| varying vec4 color; |
| void main() { |
| if (gl_Position == vec4(0,0,0,0)) { |
| color = vec4(1,0,0,1); |
| } else { |
| color = vec4(0,1,0,1); |
| } |
| gl_Position = vec4(pos,1); |
| })"; |
| |
| constexpr char kFS[] = |
| R"(precision mediump float; |
| varying vec4 color; |
| void main() { |
| gl_FragColor = color; |
| })"; |
| |
| ANGLE_GL_PROGRAM(program, kVS, kFS); |
| drawQuad(program.get(), "pos", 0.0f, 1.0f, true); |
| EXPECT_PIXEL_COLOR_EQ(getWindowWidth() * 1 / 4, getWindowHeight() * 1 / 4, GLColor::red); |
| EXPECT_PIXEL_COLOR_EQ(getWindowWidth() * 1 / 4, getWindowHeight() * 3 / 4, GLColor::red); |
| EXPECT_PIXEL_COLOR_EQ(getWindowWidth() * 3 / 4, getWindowHeight() * 1 / 4, GLColor::red); |
| EXPECT_PIXEL_COLOR_EQ(getWindowWidth() * 3 / 4, getWindowHeight() * 3 / 4, GLColor::red); |
| } |
| |
| // Tests that a rendering feedback loop triggers a GL error under WebGL. |
| // Based on WebGL test conformance/renderbuffers/feedback-loop.html. |
| TEST_P(WebGLCompatibilityTest, RenderingFeedbackLoop) |
| { |
| constexpr char kVS[] = |
| R"(attribute vec4 a_position; |
| varying vec2 v_texCoord; |
| void main() { |
| gl_Position = a_position; |
| v_texCoord = (a_position.xy * 0.5) + 0.5; |
| })"; |
| |
| constexpr char kFS[] = |
| R"(precision mediump float; |
| varying vec2 v_texCoord; |
| uniform sampler2D u_texture; |
| void main() { |
| // Shader swizzles color channels so we can tell if the draw succeeded. |
| gl_FragColor = texture2D(u_texture, v_texCoord).gbra; |
| })"; |
| |
| GLTexture texture; |
| FillTexture2D(texture.get(), 1, 1, GLColor::red, 0, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE); |
| |
| ASSERT_GL_NO_ERROR(); |
| |
| GLFramebuffer framebuffer; |
| glBindFramebuffer(GL_FRAMEBUFFER, framebuffer.get()); |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture.get(), 0); |
| |
| ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER)); |
| |
| ANGLE_GL_PROGRAM(program, kVS, kFS); |
| |
| GLint uniformLoc = glGetUniformLocation(program.get(), "u_texture"); |
| ASSERT_NE(-1, uniformLoc); |
| |
| glUseProgram(program.get()); |
| glUniform1i(uniformLoc, 0); |
| glDisable(GL_BLEND); |
| glDisable(GL_DEPTH_TEST); |
| ASSERT_GL_NO_ERROR(); |
| |
| // Drawing with a texture that is also bound to the current framebuffer should fail |
| glBindTexture(GL_TEXTURE_2D, texture.get()); |
| drawQuad(program.get(), "a_position", 0.5f, 1.0f, true); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| |
| // Ensure that the texture contents did not change after the previous render |
| glBindFramebuffer(GL_FRAMEBUFFER, 0); |
| drawQuad(program.get(), "a_position", 0.5f, 1.0f, true); |
| ASSERT_GL_NO_ERROR(); |
| EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::blue); |
| |
| // Drawing when texture is bound to an inactive uniform should succeed |
| GLTexture texture2; |
| FillTexture2D(texture2.get(), 1, 1, GLColor::green, 0, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE); |
| |
| glBindFramebuffer(GL_FRAMEBUFFER, framebuffer.get()); |
| glActiveTexture(GL_TEXTURE1); |
| glBindTexture(GL_TEXTURE_2D, texture.get()); |
| drawQuad(program.get(), "a_position", 0.5f, 1.0f, true); |
| ASSERT_GL_NO_ERROR(); |
| EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::red); |
| } |
| |
| // Test for the max draw buffers and color attachments. |
| TEST_P(WebGLCompatibilityTest, MaxDrawBuffersAttachmentPoints) |
| { |
| // This test only applies to ES2. |
| if (getClientMajorVersion() != 2) |
| { |
| return; |
| } |
| |
| GLFramebuffer fbo[2]; |
| glBindFramebuffer(GL_FRAMEBUFFER, fbo[0].get()); |
| |
| // Test that is valid when we bind with a single attachment point. |
| GLTexture texture; |
| glBindTexture(GL_TEXTURE_2D, texture.get()); |
| glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture.get(), 0); |
| ASSERT_GL_NO_ERROR(); |
| |
| // Test that enabling the draw buffers extension will allow us to bind with a non-zero |
| // attachment point. |
| if (IsGLExtensionRequestable("GL_EXT_draw_buffers")) |
| { |
| glRequestExtensionANGLE("GL_EXT_draw_buffers"); |
| EXPECT_GL_NO_ERROR(); |
| EXPECT_TRUE(IsGLExtensionEnabled("GL_EXT_draw_buffers")); |
| |
| glBindFramebuffer(GL_FRAMEBUFFER, fbo[1].get()); |
| |
| GLTexture texture2; |
| glBindTexture(GL_TEXTURE_2D, texture2.get()); |
| glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D, texture2.get(), |
| 0); |
| ASSERT_GL_NO_ERROR(); |
| } |
| } |
| |
| // Test that the offset in the index buffer is forced to be a multiple of the element size |
| TEST_P(WebGLCompatibilityTest, DrawElementsOffsetRestriction) |
| { |
| constexpr char kVS[] = |
| R"(attribute vec3 a_pos; |
| void main() |
| { |
| gl_Position = vec4(a_pos, 1.0); |
| })"; |
| |
| ANGLE_GL_PROGRAM(program, kVS, essl1_shaders::fs::Red()); |
| |
| GLint posLocation = glGetAttribLocation(program.get(), "a_pos"); |
| ASSERT_NE(-1, posLocation); |
| glUseProgram(program.get()); |
| |
| const auto &vertices = GetQuadVertices(); |
| |
| GLBuffer vertexBuffer; |
| glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer.get()); |
| glBufferData(GL_ARRAY_BUFFER, sizeof(vertices[0]) * vertices.size(), vertices.data(), |
| GL_STATIC_DRAW); |
| |
| glVertexAttribPointer(posLocation, 3, GL_FLOAT, GL_FALSE, 0, 0); |
| glEnableVertexAttribArray(posLocation); |
| |
| GLBuffer indexBuffer; |
| const GLubyte indices[] = {0, 0, 0, 0, 0, 0, 0, 0}; |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer.get()); |
| glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW); |
| |
| ASSERT_GL_NO_ERROR(); |
| |
| const char *zeroIndices = nullptr; |
| |
| glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, zeroIndices); |
| ASSERT_GL_NO_ERROR(); |
| |
| glDrawElements(GL_TRIANGLES, 4, GL_UNSIGNED_SHORT, zeroIndices); |
| ASSERT_GL_NO_ERROR(); |
| |
| glDrawElements(GL_TRIANGLES, 4, GL_UNSIGNED_SHORT, zeroIndices + 1); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| } |
| |
| // Test that the offset and stride in the vertex buffer is forced to be a multiple of the element |
| // size |
| TEST_P(WebGLCompatibilityTest, VertexAttribPointerOffsetRestriction) |
| { |
| const char *zeroOffset = nullptr; |
| |
| // Base case, vector of two floats |
| glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, zeroOffset); |
| ASSERT_GL_NO_ERROR(); |
| |
| // Test setting a non-multiple offset |
| glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, zeroOffset + 1); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, zeroOffset + 2); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, zeroOffset + 3); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| |
| // Test setting a non-multiple stride |
| glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 1, zeroOffset); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2, zeroOffset); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 3, zeroOffset); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| } |
| |
| void WebGLCompatibilityTest::drawBuffersEXTFeedbackLoop(GLuint program, |
| const std::array<GLenum, 2> &drawBuffers, |
| GLenum expectedError) |
| { |
| glDrawBuffersEXT(2, drawBuffers.data()); |
| |
| // Make sure framebuffer is complete before feedback loop detection |
| ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER)); |
| |
| drawQuad(program, "aPosition", 0.5f, 1.0f, true); |
| |
| // "Rendering to a texture where it samples from should geneates INVALID_OPERATION. Otherwise, |
| // it should be NO_ERROR" |
| EXPECT_GL_ERROR(expectedError); |
| } |
| |
| // This tests that rendering feedback loops works as expected with GL_EXT_draw_buffers. |
| // Based on WebGL test conformance/extensions/webgl-draw-buffers-feedback-loop.html |
| TEST_P(WebGLCompatibilityTest, RenderingFeedbackLoopWithDrawBuffersEXT) |
| { |
| constexpr char kVS[] = |
| R"(attribute vec4 aPosition; |
| varying vec2 texCoord; |
| void main() { |
| gl_Position = aPosition; |
| texCoord = (aPosition.xy * 0.5) + 0.5; |
| })"; |
| |
| constexpr char kFS[] = |
| R"(#extension GL_EXT_draw_buffers : require |
| precision mediump float; |
| uniform sampler2D tex; |
| varying vec2 texCoord; |
| void main() { |
| gl_FragData[0] = texture2D(tex, texCoord); |
| gl_FragData[1] = texture2D(tex, texCoord); |
| })"; |
| |
| GLsizei width = 8; |
| GLsizei height = 8; |
| |
| // This shader cannot be run in ES3, because WebGL 2 does not expose the draw buffers |
| // extension and gl_FragData semantics are changed to enforce indexing by zero always. |
| // TODO(jmadill): This extension should be disabled in WebGL 2 contexts. |
| if (/*!IsGLExtensionEnabled("GL_EXT_draw_buffers")*/ getClientMajorVersion() != 2) |
| { |
| // No WEBGL_draw_buffers support -- this is legal. |
| return; |
| } |
| |
| GLint maxDrawBuffers = 0; |
| glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers); |
| |
| // Test skipped because MAX_DRAW_BUFFERS is too small. |
| ANGLE_SKIP_TEST_IF(maxDrawBuffers < 2); |
| |
| ANGLE_GL_PROGRAM(program, kVS, kFS); |
| glUseProgram(program.get()); |
| glViewport(0, 0, width, height); |
| |
| GLTexture tex0; |
| GLTexture tex1; |
| GLFramebuffer fbo; |
| FillTexture2D(tex0.get(), width, height, GLColor::red, 0, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE); |
| FillTexture2D(tex1.get(), width, height, GLColor::green, 0, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE); |
| ASSERT_GL_NO_ERROR(); |
| |
| glBindTexture(GL_TEXTURE_2D, tex1.get()); |
| GLint texLoc = glGetUniformLocation(program.get(), "tex"); |
| ASSERT_NE(-1, texLoc); |
| glUniform1i(texLoc, 0); |
| ASSERT_GL_NO_ERROR(); |
| |
| // The sampling texture is bound to COLOR_ATTACHMENT1 during resource allocation |
| glBindFramebuffer(GL_FRAMEBUFFER, fbo.get()); |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex0.get(), 0); |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D, tex1.get(), 0); |
| |
| drawBuffersEXTFeedbackLoop(program.get(), {{GL_NONE, GL_COLOR_ATTACHMENT1}}, |
| GL_INVALID_OPERATION); |
| drawBuffersEXTFeedbackLoop(program.get(), {{GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1}}, |
| GL_INVALID_OPERATION); |
| // A feedback loop is formed regardless of drawBuffers settings. |
| drawBuffersEXTFeedbackLoop(program.get(), {{GL_COLOR_ATTACHMENT0, GL_NONE}}, |
| GL_INVALID_OPERATION); |
| } |
| |
| // Test tests that texture copying feedback loops are properly rejected in WebGL. |
| // Based on the WebGL test conformance/textures/misc/texture-copying-feedback-loops.html |
| TEST_P(WebGLCompatibilityTest, TextureCopyingFeedbackLoops) |
| { |
| // Vulkan does not support copying from a texture to itself. http://anglebug.com/2914 |
| ANGLE_SKIP_TEST_IF(IsVulkan()); |
| |
| GLTexture texture; |
| glBindTexture(GL_TEXTURE_2D, texture.get()); |
| glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); |
| |
| GLTexture texture2; |
| glBindTexture(GL_TEXTURE_2D, texture2.get()); |
| glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); |
| |
| GLFramebuffer framebuffer; |
| glBindFramebuffer(GL_FRAMEBUFFER, framebuffer.get()); |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture.get(), 0); |
| |
| // framebuffer should be FRAMEBUFFER_COMPLETE. |
| ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER)); |
| ASSERT_GL_NO_ERROR(); |
| |
| // testing copyTexImage2D |
| |
| // copyTexImage2D to same texture but different level |
| glBindTexture(GL_TEXTURE_2D, texture.get()); |
| glCopyTexImage2D(GL_TEXTURE_2D, 1, GL_RGBA, 0, 0, 2, 2, 0); |
| EXPECT_GL_NO_ERROR(); |
| |
| // copyTexImage2D to same texture same level, invalid feedback loop |
| glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 0, 0, 2, 2, 0); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| |
| // copyTexImage2D to different texture |
| glBindTexture(GL_TEXTURE_2D, texture2.get()); |
| glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 0, 0, 2, 2, 0); |
| EXPECT_GL_NO_ERROR(); |
| |
| // testing copyTexSubImage2D |
| |
| // copyTexSubImage2D to same texture but different level |
| glBindTexture(GL_TEXTURE_2D, texture.get()); |
| glCopyTexSubImage2D(GL_TEXTURE_2D, 1, 0, 0, 0, 0, 1, 1); |
| EXPECT_GL_NO_ERROR(); |
| |
| // copyTexSubImage2D to same texture same level, invalid feedback loop |
| glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 1, 1); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| |
| // copyTexSubImage2D to different texture |
| glBindTexture(GL_TEXTURE_2D, texture2.get()); |
| glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 1, 1); |
| EXPECT_GL_NO_ERROR(); |
| } |
| |
| void WebGLCompatibilityTest::drawBuffersFeedbackLoop(GLuint program, |
| const std::array<GLenum, 2> &drawBuffers, |
| GLenum expectedError) |
| { |
| glDrawBuffers(2, drawBuffers.data()); |
| |
| // Make sure framebuffer is complete before feedback loop detection |
| ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER)); |
| |
| drawQuad(program, "aPosition", 0.5f, 1.0f, true); |
| |
| // "Rendering to a texture where it samples from should geneates INVALID_OPERATION. Otherwise, |
| // it should be NO_ERROR" |
| EXPECT_GL_ERROR(expectedError); |
| } |
| |
| // Tests invariance matching rules between built in varyings. |
| // Based on WebGL test conformance/glsl/misc/shaders-with-invariance.html. |
| TEST_P(WebGLCompatibilityTest, BuiltInInvariant) |
| { |
| constexpr char kVS[] = |
| R"(varying vec4 v_varying; |
| void main() |
| { |
| gl_PointSize = 1.0; |
| gl_Position = v_varying; |
| })"; |
| constexpr char kFSInvariantGlFragCoord[] = |
| R"(invariant gl_FragCoord; |
| void main() |
| { |
| gl_FragColor = gl_FragCoord; |
| })"; |
| constexpr char kFSInvariantGlPointCoord[] = |
| R"(invariant gl_PointCoord; |
| void main() |
| { |
| gl_FragColor = vec4(gl_PointCoord, 0.0, 0.0); |
| })"; |
| |
| GLuint program = CompileProgram(kVS, kFSInvariantGlFragCoord); |
| EXPECT_EQ(0u, program); |
| |
| program = CompileProgram(kVS, kFSInvariantGlPointCoord); |
| EXPECT_EQ(0u, program); |
| } |
| |
| // Tests global namespace conflicts between uniforms and attributes. |
| // Based on WebGL test conformance/glsl/misc/shaders-with-name-conflicts.html. |
| TEST_P(WebGLCompatibilityTest, GlobalNamesConflict) |
| { |
| constexpr char kVS[] = |
| R"(attribute vec4 foo; |
| void main() |
| { |
| gl_Position = foo; |
| })"; |
| constexpr char kFS[] = |
| R"(precision mediump float; |
| uniform vec4 foo; |
| void main() |
| { |
| gl_FragColor = foo; |
| })"; |
| |
| GLuint program = CompileProgram(kVS, kFS); |
| EXPECT_EQ(0u, program); |
| } |
| |
| // Test dimension and image size validation of compressed textures |
| TEST_P(WebGLCompatibilityTest, CompressedTextureS3TC) |
| { |
| if (IsGLExtensionRequestable("GL_EXT_texture_compression_dxt1")) |
| { |
| glRequestExtensionANGLE("GL_EXT_texture_compression_dxt1"); |
| } |
| |
| ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_EXT_texture_compression_dxt1")); |
| |
| constexpr uint8_t CompressedImageDXT1[] = {0x00, 0xf8, 0x00, 0xf8, 0xaa, 0xaa, 0xaa, 0xaa}; |
| |
| GLTexture texture; |
| glBindTexture(GL_TEXTURE_2D, texture); |
| |
| // Regular case, verify that it works |
| glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 4, 4, 0, |
| sizeof(CompressedImageDXT1), CompressedImageDXT1); |
| ASSERT_GL_NO_ERROR(); |
| |
| // Test various dimensions that are not valid |
| glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 3, 4, 0, |
| sizeof(CompressedImageDXT1), CompressedImageDXT1); |
| ASSERT_GL_ERROR(GL_INVALID_OPERATION); |
| |
| glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 4, 3, 0, |
| sizeof(CompressedImageDXT1), CompressedImageDXT1); |
| ASSERT_GL_ERROR(GL_INVALID_OPERATION); |
| |
| glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 2, 2, 0, |
| sizeof(CompressedImageDXT1), CompressedImageDXT1); |
| ASSERT_GL_ERROR(GL_INVALID_OPERATION); |
| |
| glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 1, 1, 0, |
| sizeof(CompressedImageDXT1), CompressedImageDXT1); |
| ASSERT_GL_ERROR(GL_INVALID_OPERATION); |
| |
| // Test various image sizes that are not valid |
| glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 4, 4, 0, |
| sizeof(CompressedImageDXT1) - 1, CompressedImageDXT1); |
| ASSERT_GL_ERROR(GL_INVALID_VALUE); |
| |
| glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 4, 4, 0, |
| sizeof(CompressedImageDXT1) + 1, CompressedImageDXT1); |
| ASSERT_GL_ERROR(GL_INVALID_VALUE); |
| |
| glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 4, 4, 0, 0, |
| CompressedImageDXT1); |
| ASSERT_GL_ERROR(GL_INVALID_VALUE); |
| |
| glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 0, 0, 0, |
| sizeof(CompressedImageDXT1), CompressedImageDXT1); |
| ASSERT_GL_ERROR(GL_INVALID_VALUE); |
| |
| // Fill a full mip chain and verify that it works |
| glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 4, 4, 0, |
| sizeof(CompressedImageDXT1), CompressedImageDXT1); |
| glCompressedTexImage2D(GL_TEXTURE_2D, 1, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 2, 2, 0, |
| sizeof(CompressedImageDXT1), CompressedImageDXT1); |
| glCompressedTexImage2D(GL_TEXTURE_2D, 2, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 1, 1, 0, |
| sizeof(CompressedImageDXT1), CompressedImageDXT1); |
| ASSERT_GL_NO_ERROR(); |
| |
| glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, |
| sizeof(CompressedImageDXT1), CompressedImageDXT1); |
| ASSERT_GL_NO_ERROR(); |
| |
| // Test that non-block size sub-uploads are not valid for the 0 mip |
| glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 2, 2, 2, 2, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, |
| sizeof(CompressedImageDXT1), CompressedImageDXT1); |
| ASSERT_GL_ERROR(GL_INVALID_OPERATION); |
| |
| // Test that non-block size sub-uploads are valid for if they fill the whole mip |
| glCompressedTexSubImage2D(GL_TEXTURE_2D, 1, 0, 0, 2, 2, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, |
| sizeof(CompressedImageDXT1), CompressedImageDXT1); |
| glCompressedTexSubImage2D(GL_TEXTURE_2D, 2, 0, 0, 1, 1, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, |
| sizeof(CompressedImageDXT1), CompressedImageDXT1); |
| ASSERT_GL_NO_ERROR(); |
| |
| // Test that if the format miss-matches the texture, an error is generated |
| glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 2, 2, 2, 2, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, |
| sizeof(CompressedImageDXT1), CompressedImageDXT1); |
| ASSERT_GL_ERROR(GL_INVALID_OPERATION); |
| } |
| |
| TEST_P(WebGLCompatibilityTest, L32FTextures) |
| { |
| constexpr float textureData[] = {15.1f, 0.0f, 0.0f, 0.0f}; |
| constexpr float readPixelData[] = {textureData[0], textureData[0], textureData[0], 1.0f}; |
| |
| for (auto extension : FloatingPointTextureExtensions) |
| { |
| if (strlen(extension) > 0 && IsGLExtensionRequestable(extension)) |
| { |
| glRequestExtensionANGLE(extension); |
| ASSERT_GL_NO_ERROR(); |
| } |
| |
| // Unsized L 32F |
| { |
| bool texture = IsGLExtensionEnabled("GL_OES_texture_float"); |
| bool filter = IsGLExtensionEnabled("GL_OES_texture_float_linear"); |
| bool render = false; |
| TestFloatTextureFormat(GL_LUMINANCE, GL_LUMINANCE, GL_FLOAT, texture, filter, render, |
| textureData, readPixelData); |
| } |
| |
| if (getClientMajorVersion() >= 3 || IsGLExtensionEnabled("GL_EXT_texture_storage")) |
| { |
| // Sized L 32F |
| bool texture = IsGLExtensionEnabled("GL_OES_texture_float") && |
| IsGLExtensionEnabled("GL_EXT_texture_storage"); |
| bool filter = IsGLExtensionEnabled("GL_OES_texture_float_linear"); |
| bool render = false; |
| TestFloatTextureFormat(GL_LUMINANCE32F_EXT, GL_LUMINANCE, GL_FLOAT, texture, filter, |
| render, textureData, readPixelData); |
| } |
| } |
| } |
| |
| TEST_P(WebGLCompatibilityTest, A32FTextures) |
| { |
| constexpr float textureData[] = {33.33f, 0.0f, 0.0f, 0.0f}; |
| constexpr float readPixelData[] = {0.0f, 0.0f, 0.0f, textureData[0]}; |
| |
| for (auto extension : FloatingPointTextureExtensions) |
| { |
| if (strlen(extension) > 0 && IsGLExtensionRequestable(extension)) |
| { |
| glRequestExtensionANGLE(extension); |
| ASSERT_GL_NO_ERROR(); |
| } |
| |
| // Unsized A 32F |
| { |
| bool texture = IsGLExtensionEnabled("GL_OES_texture_float"); |
| bool filter = IsGLExtensionEnabled("GL_OES_texture_float_linear"); |
| bool render = false; |
| TestFloatTextureFormat(GL_ALPHA, GL_ALPHA, GL_FLOAT, texture, filter, render, |
| textureData, readPixelData); |
| } |
| |
| if (getClientMajorVersion() >= 3 || IsGLExtensionEnabled("GL_EXT_texture_storage")) |
| { |
| // Sized A 32F |
| bool texture = IsGLExtensionEnabled("GL_OES_texture_float") && |
| IsGLExtensionEnabled("GL_EXT_texture_storage"); |
| bool filter = IsGLExtensionEnabled("GL_OES_texture_float_linear"); |
| bool render = false; |
| TestFloatTextureFormat(GL_ALPHA32F_EXT, GL_ALPHA, GL_FLOAT, texture, filter, render, |
| textureData, readPixelData); |
| } |
| } |
| } |
| |
| TEST_P(WebGLCompatibilityTest, LA32FTextures) |
| { |
| constexpr float textureData[] = {-0.21f, 15.1f, 0.0f, 0.0f}; |
| constexpr float readPixelData[] = {textureData[0], textureData[0], textureData[0], |
| textureData[1]}; |
| |
| for (auto extension : FloatingPointTextureExtensions) |
| { |
| if (strlen(extension) > 0 && IsGLExtensionRequestable(extension)) |
| { |
| glRequestExtensionANGLE(extension); |
| ASSERT_GL_NO_ERROR(); |
| } |
| |
| // Unsized LA 32F |
| { |
| bool texture = IsGLExtensionEnabled("GL_OES_texture_float"); |
| bool filter = IsGLExtensionEnabled("GL_OES_texture_float_linear"); |
| bool render = false; |
| TestFloatTextureFormat(GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, GL_FLOAT, texture, |
| filter, render, textureData, readPixelData); |
| } |
| |
| if (getClientMajorVersion() >= 3 || IsGLExtensionEnabled("GL_EXT_texture_storage")) |
| { |
| // Sized LA 32F |
| bool texture = IsGLExtensionEnabled("GL_OES_texture_float") && |
| IsGLExtensionEnabled("GL_EXT_texture_storage"); |
| bool filter = IsGLExtensionEnabled("GL_OES_texture_float_linear"); |
| bool render = false; |
| TestFloatTextureFormat(GL_LUMINANCE_ALPHA32F_EXT, GL_LUMINANCE_ALPHA, GL_FLOAT, texture, |
| filter, render, textureData, readPixelData); |
| } |
| } |
| } |
| |
| TEST_P(WebGLCompatibilityTest, R32FTextures) |
| { |
| constexpr float data[] = {1000.0f, 0.0f, 0.0f, 1.0f}; |
| |
| for (auto extension : FloatingPointTextureExtensions) |
| { |
| if (strlen(extension) > 0 && IsGLExtensionRequestable(extension)) |
| { |
| glRequestExtensionANGLE(extension); |
| ASSERT_GL_NO_ERROR(); |
| } |
| |
| // Unsized R 32F |
| { |
| bool texture = IsGLExtensionEnabled("GL_OES_texture_float") && |
| IsGLExtensionEnabled("GL_EXT_texture_rg"); |
| bool filter = IsGLExtensionEnabled("GL_OES_texture_float_linear"); |
| bool render = IsGLExtensionEnabled("GL_EXT_color_buffer_float"); |
| TestFloatTextureFormat(GL_RED, GL_RED, GL_FLOAT, texture, filter, render, data, data); |
| } |
| |
| if (getClientMajorVersion() >= 3 || IsGLExtensionEnabled("GL_EXT_texture_storage")) |
| { |
| // Sized R 32F |
| bool texture = |
| (getClientMajorVersion() >= 3) || (IsGLExtensionEnabled("GL_OES_texture_float") && |
| IsGLExtensionEnabled("GL_EXT_texture_rg") && |
| IsGLExtensionEnabled("GL_EXT_texture_storage")); |
| bool filter = IsGLExtensionEnabled("GL_OES_texture_float_linear"); |
| bool render = IsGLExtensionEnabled("GL_EXT_color_buffer_float"); |
| TestFloatTextureFormat(GL_R32F, GL_RED, GL_FLOAT, texture, filter, render, data, data); |
| } |
| } |
| } |
| |
| TEST_P(WebGLCompatibilityTest, RG32FTextures) |
| { |
| constexpr float data[] = {1000.0f, -0.001f, 0.0f, 1.0f}; |
| |
| for (auto extension : FloatingPointTextureExtensions) |
| { |
| if (strlen(extension) > 0 && IsGLExtensionRequestable(extension)) |
| { |
| glRequestExtensionANGLE(extension); |
| ASSERT_GL_NO_ERROR(); |
| } |
| |
| // Unsized RG 32F |
| { |
| bool texture = (IsGLExtensionEnabled("GL_OES_texture_float") && |
| IsGLExtensionEnabled("GL_EXT_texture_rg")); |
| bool filter = IsGLExtensionEnabled("GL_OES_texture_float_linear"); |
| bool render = IsGLExtensionEnabled("GL_EXT_color_buffer_float"); |
| TestFloatTextureFormat(GL_RG, GL_RG, GL_FLOAT, texture, filter, render, data, data); |
| } |
| |
| if (getClientMajorVersion() >= 3 || IsGLExtensionEnabled("GL_EXT_texture_storage")) |
| { |
| // Sized RG 32F |
| bool texture = |
| (getClientMajorVersion() >= 3) || (IsGLExtensionEnabled("GL_OES_texture_float") && |
| IsGLExtensionEnabled("GL_EXT_texture_rg") && |
| IsGLExtensionEnabled("GL_EXT_texture_storage")); |
| bool filter = IsGLExtensionEnabled("GL_OES_texture_float_linear"); |
| bool render = IsGLExtensionEnabled("GL_EXT_color_buffer_float"); |
| TestFloatTextureFormat(GL_RG32F, GL_RG, GL_FLOAT, texture, filter, render, data, data); |
| } |
| } |
| } |
| |
| TEST_P(WebGLCompatibilityTest, RGB32FTextures) |
| { |
| // TODO(syoussefi): Missing format support. http://anglebug.com/2898 |
| ANGLE_SKIP_TEST_IF(IsVulkan()); |
| |
| constexpr float data[] = {1000.0f, -500.0f, 10.0f, 1.0f}; |
| |
| for (auto extension : FloatingPointTextureExtensions) |
| { |
| if (strlen(extension) > 0 && IsGLExtensionRequestable(extension)) |
| { |
| glRequestExtensionANGLE(extension); |
| ASSERT_GL_NO_ERROR(); |
| } |
| |
| // Unsized RGB 32F |
| { |
| bool texture = IsGLExtensionEnabled("GL_OES_texture_float"); |
| bool filter = IsGLExtensionEnabled("GL_OES_texture_float_linear"); |
| bool render = false; |
| TestFloatTextureFormat(GL_RGB, GL_RGB, GL_FLOAT, texture, filter, render, data, data); |
| } |
| |
| if (getClientMajorVersion() >= 3 || IsGLExtensionEnabled("GL_EXT_texture_storage")) |
| { |
| // Sized RGB 32F |
| bool texture = |
| (getClientMajorVersion() >= 3) || (IsGLExtensionEnabled("GL_OES_texture_float") && |
| IsGLExtensionEnabled("GL_EXT_texture_storage")); |
| bool filter = IsGLExtensionEnabled("GL_OES_texture_float_linear"); |
| bool render = IsGLExtensionEnabled("GL_CHROMIUM_color_buffer_float_rgb"); |
| TestFloatTextureFormat(GL_RGB32F, GL_RGB, GL_FLOAT, texture, filter, render, data, |
| data); |
| } |
| } |
| } |
| |
| TEST_P(WebGLCompatibilityTest, RGBA32FTextures) |
| { |
| // TODO(syoussefi): Missing format support. http://anglebug.com/2898 |
| ANGLE_SKIP_TEST_IF(IsVulkan()); |
| |
| constexpr float data[] = {7000.0f, 100.0f, 33.0f, -1.0f}; |
| |
| for (auto extension : FloatingPointTextureExtensions) |
| { |
| if (strlen(extension) > 0 && IsGLExtensionRequestable(extension)) |
| { |
| glRequestExtensionANGLE(extension); |
| ASSERT_GL_NO_ERROR(); |
| } |
| |
| // Unsized RGBA 32F |
| { |
| bool texture = IsGLExtensionEnabled("GL_OES_texture_float"); |
| bool filter = IsGLExtensionEnabled("GL_OES_texture_float_linear"); |
| bool render = false; |
| TestFloatTextureFormat(GL_RGBA, GL_RGBA, GL_FLOAT, texture, filter, render, data, data); |
| } |
| |
| if (getClientMajorVersion() >= 3 || IsGLExtensionEnabled("GL_EXT_texture_storage")) |
| { |
| // Sized RGBA 32F |
| bool texture = |
| (getClientMajorVersion() >= 3) || (IsGLExtensionEnabled("GL_OES_texture_float") && |
| IsGLExtensionEnabled("GL_EXT_texture_storage")); |
| bool filter = IsGLExtensionEnabled("GL_OES_texture_float_linear"); |
| bool render = IsGLExtensionEnabled("GL_EXT_color_buffer_float") || |
| IsGLExtensionEnabled("GL_CHROMIUM_color_buffer_float_rgba"); |
| TestFloatTextureFormat(GL_RGBA32F, GL_RGBA, GL_FLOAT, texture, filter, render, data, |
| data); |
| } |
| } |
| } |
| |
| // Test that has float color attachment caching works when color attachments change, by calling draw |
| // command when blending is enabled |
| TEST_P(WebGLCompatibilityTest, FramebufferFloatColorAttachment) |
| { |
| if (getClientMajorVersion() >= 3) |
| { |
| ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_EXT_color_buffer_float")); |
| } |
| else |
| { |
| ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_OES_texture_float")); |
| ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_CHROMIUM_color_buffer_float_rgba")); |
| } |
| |
| constexpr char kVS[] = |
| R"(void main() |
| { |
| gl_Position = vec4(0, 0, 0, 1); |
| })"; |
| |
| constexpr char kFS[] = |
| R"(void main() |
| { |
| gl_FragColor = vec4(0, 1, 0, 1); |
| })"; |
| |
| ANGLE_GL_PROGRAM(program, kVS, kFS); |
| glUseProgram(program); |
| |
| glEnable(GL_BLEND); |
| |
| GLTexture texture1; |
| glBindTexture(GL_TEXTURE_2D, texture1); |
| glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); |
| EXPECT_GL_NO_ERROR(); |
| |
| GLTexture texture2; |
| glBindTexture(GL_TEXTURE_2D, texture2); |
| glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, 1, 1, 0, GL_RGBA, GL_FLOAT, nullptr); |
| EXPECT_GL_NO_ERROR(); |
| |
| GLFramebuffer fbo1; |
| glBindFramebuffer(GL_FRAMEBUFFER, fbo1); |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture1, 0); |
| ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER)); |
| |
| GLFramebuffer fbo2; |
| glBindFramebuffer(GL_FRAMEBUFFER, fbo2); |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture2, 0); |
| ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER)); |
| glDrawArrays(GL_POINTS, 0, 1); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| |
| glDisable(GL_BLEND); |
| glDrawArrays(GL_POINTS, 0, 1); |
| EXPECT_GL_NO_ERROR(); |
| glEnable(GL_BLEND); |
| |
| glBindFramebuffer(GL_FRAMEBUFFER, fbo1); |
| glDrawArrays(GL_POINTS, 0, 1); |
| |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, |
| 0); // test unbind |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture2, 0); |
| ASSERT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER)); |
| |
| glDrawArrays(GL_POINTS, 0, 1); |
| EXPECT_GL_ERROR(GL_INVALID_OPERATION); |
| |
| glDisable(GL_BLEND); |
| glDrawArrays(GL_POINTS, 0, 1); |
| EXPECT_GL_NO_ERROR(); |
| glEnable(GL_BLEND); |
| |
| glBindTexture(GL_TEXTURE_2D, texture2); |
| glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); |
| |
| glDrawArrays(GL_POINTS, 0, 1); |
| EXPECT_GL_NO_ERROR(); |
| } |
| |
| // Test that has float color attachment caching works with multiple color attachments bound to a |
| // Framebuffer |
| TEST_P(WebGLCompatibilityTest, FramebufferFloatColorAttachmentMRT) |
| { |
| bool isWebGL2 = getClientMajorVersion() >= 3; |
| if (isWebGL2) |
| { |
| ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_EXT_color_buffer_float")); |
| |
| constexpr char kVS[] = |
| R"(#version 300 es |
|
