| // Copyright 2017 The SwiftShader Authors. All Rights Reserved. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| // OpenGL ES unit tests that provide coverage for functionality not tested by |
| // the dEQP test suite. Also used as a smoke test. |
| |
| #include "gmock/gmock.h" |
| #include "gtest/gtest.h" |
| |
| #include <EGL/egl.h> |
| #include <GL/glcorearb.h> |
| #include <GL/glext.h> |
| #include <GLES2/gl2.h> |
| #include <GLES2/gl2ext.h> |
| #include <GLES3/gl3.h> |
| |
| #if defined(_WIN32) |
| # include <Windows.h> |
| #endif |
| |
| #include <string.h> |
| #include <cstdint> |
| |
| #define EXPECT_GLENUM_EQ(expected, actual) EXPECT_EQ(static_cast<GLenum>(expected), static_cast<GLenum>(actual)) |
| |
| #define EXPECT_NO_GL_ERROR() EXPECT_GLENUM_EQ(GL_NO_ERROR, glGetError()) |
| #define EXPECT_NO_EGL_ERROR() EXPECT_EQ(EGL_SUCCESS, eglGetError()) |
| |
| class SwiftShaderTest : public testing::Test |
| { |
| protected: |
| void SetUp() override |
| { |
| #if defined(_WIN32) && !defined(STANDALONE) |
| // The DLLs are delay loaded (see BUILD.gn), so we can load |
| // the correct ones from Chrome's swiftshader subdirectory. |
| HMODULE libEGL = LoadLibraryA("swiftshader\\libEGL.dll"); |
| EXPECT_NE((HMODULE)NULL, libEGL); |
| |
| HMODULE libGLESv2 = LoadLibraryA("swiftshader\\libGLESv2.dll"); |
| EXPECT_NE((HMODULE)NULL, libGLESv2); |
| #endif |
| } |
| |
| void expectFramebufferColor(const unsigned char referenceColor[4], GLint x = 0, GLint y = 0) |
| { |
| unsigned char color[4] = { 0 }; |
| glReadPixels(x, y, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &color); |
| EXPECT_NO_GL_ERROR(); |
| EXPECT_EQ(color[0], referenceColor[0]); |
| EXPECT_EQ(color[1], referenceColor[1]); |
| EXPECT_EQ(color[2], referenceColor[2]); |
| EXPECT_EQ(color[3], referenceColor[3]); |
| } |
| |
| void expectFramebufferColor(const float referenceColor[4], GLint x = 0, GLint y = 0) |
| { |
| float color[4] = { 0 }; |
| glReadPixels(x, y, 1, 1, GL_RGBA, GL_FLOAT, &color); |
| EXPECT_NO_GL_ERROR(); |
| EXPECT_EQ(color[0], referenceColor[0]); |
| EXPECT_EQ(color[1], referenceColor[1]); |
| EXPECT_EQ(color[2], referenceColor[2]); |
| EXPECT_EQ(color[3], referenceColor[3]); |
| } |
| |
| void Initialize(int version, bool withChecks) |
| { |
| EXPECT_NO_EGL_ERROR(); |
| |
| display = eglGetDisplay(EGL_DEFAULT_DISPLAY); |
| |
| if(withChecks) |
| { |
| EXPECT_NO_EGL_ERROR(); |
| EXPECT_NE(EGL_NO_DISPLAY, display); |
| |
| eglQueryString(display, EGL_VENDOR); |
| EXPECT_EQ(EGL_NOT_INITIALIZED, eglGetError()); |
| } |
| |
| EGLint major; |
| EGLint minor; |
| EGLBoolean initialized = eglInitialize(display, &major, &minor); |
| |
| if(withChecks) |
| { |
| EXPECT_NO_EGL_ERROR(); |
| EXPECT_EQ((EGLBoolean)EGL_TRUE, initialized); |
| EXPECT_EQ(1, major); |
| EXPECT_EQ(4, minor); |
| |
| const char *eglVendor = eglQueryString(display, EGL_VENDOR); |
| EXPECT_NO_EGL_ERROR(); |
| EXPECT_STREQ("Google Inc.", eglVendor); |
| |
| const char *eglVersion = eglQueryString(display, EGL_VERSION); |
| EXPECT_NO_EGL_ERROR(); |
| EXPECT_THAT(eglVersion, testing::HasSubstr("1.4 SwiftShader ")); |
| } |
| |
| eglBindAPI(EGL_OPENGL_ES_API); |
| EXPECT_NO_EGL_ERROR(); |
| |
| const EGLint configAttributes[] = { |
| EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, |
| EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, |
| EGL_ALPHA_SIZE, 8, |
| EGL_NONE |
| }; |
| |
| EGLint num_config = -1; |
| EGLBoolean success = eglChooseConfig(display, configAttributes, &config, 1, &num_config); |
| EXPECT_NO_EGL_ERROR(); |
| EXPECT_EQ(num_config, 1); |
| EXPECT_EQ((EGLBoolean)EGL_TRUE, success); |
| |
| if(withChecks) |
| { |
| EGLint conformant = 0; |
| eglGetConfigAttrib(display, config, EGL_CONFORMANT, &conformant); |
| EXPECT_NO_EGL_ERROR(); |
| EXPECT_TRUE(conformant & EGL_OPENGL_ES2_BIT); |
| |
| EGLint renderableType = 0; |
| eglGetConfigAttrib(display, config, EGL_RENDERABLE_TYPE, &renderableType); |
| EXPECT_NO_EGL_ERROR(); |
| EXPECT_TRUE(renderableType & EGL_OPENGL_ES2_BIT); |
| |
| EGLint surfaceType = 0; |
| eglGetConfigAttrib(display, config, EGL_SURFACE_TYPE, &surfaceType); |
| EXPECT_NO_EGL_ERROR(); |
| EXPECT_TRUE(surfaceType & EGL_WINDOW_BIT); |
| } |
| |
| EGLint surfaceAttributes[] = { |
| EGL_WIDTH, 1920, |
| EGL_HEIGHT, 1080, |
| EGL_NONE |
| }; |
| |
| surface = eglCreatePbufferSurface(display, config, surfaceAttributes); |
| EXPECT_NO_EGL_ERROR(); |
| EXPECT_NE(EGL_NO_SURFACE, surface); |
| |
| EGLint contextAttributes[] = { |
| EGL_CONTEXT_CLIENT_VERSION, version, |
| EGL_NONE |
| }; |
| |
| context = eglCreateContext(display, config, NULL, contextAttributes); |
| EXPECT_NO_EGL_ERROR(); |
| EXPECT_NE(EGL_NO_CONTEXT, context); |
| |
| success = eglMakeCurrent(display, surface, surface, context); |
| EXPECT_NO_EGL_ERROR(); |
| EXPECT_EQ((EGLBoolean)EGL_TRUE, success); |
| |
| if(withChecks) |
| { |
| EGLDisplay currentDisplay = eglGetCurrentDisplay(); |
| EXPECT_NO_EGL_ERROR(); |
| EXPECT_EQ(display, currentDisplay); |
| |
| EGLSurface currentDrawSurface = eglGetCurrentSurface(EGL_DRAW); |
| EXPECT_NO_EGL_ERROR(); |
| EXPECT_EQ(surface, currentDrawSurface); |
| |
| EGLSurface currentReadSurface = eglGetCurrentSurface(EGL_READ); |
| EXPECT_NO_EGL_ERROR(); |
| EXPECT_EQ(surface, currentReadSurface); |
| |
| EGLContext currentContext = eglGetCurrentContext(); |
| EXPECT_NO_EGL_ERROR(); |
| EXPECT_EQ(context, currentContext); |
| } |
| |
| EXPECT_NO_GL_ERROR(); |
| } |
| |
| void Uninitialize() |
| { |
| EXPECT_NO_GL_ERROR(); |
| |
| EGLBoolean success = eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); |
| EXPECT_NO_EGL_ERROR(); |
| EXPECT_EQ((EGLBoolean)EGL_TRUE, success); |
| |
| EGLDisplay currentDisplay = eglGetCurrentDisplay(); |
| EXPECT_NO_EGL_ERROR(); |
| EXPECT_EQ(EGL_NO_DISPLAY, currentDisplay); |
| |
| EGLSurface currentDrawSurface = eglGetCurrentSurface(EGL_DRAW); |
| EXPECT_NO_EGL_ERROR(); |
| EXPECT_EQ(EGL_NO_SURFACE, currentDrawSurface); |
| |
| EGLSurface currentReadSurface = eglGetCurrentSurface(EGL_READ); |
| EXPECT_NO_EGL_ERROR(); |
| EXPECT_EQ(EGL_NO_SURFACE, currentReadSurface); |
| |
| EGLContext currentContext = eglGetCurrentContext(); |
| EXPECT_NO_EGL_ERROR(); |
| EXPECT_EQ(EGL_NO_CONTEXT, currentContext); |
| |
| success = eglDestroyContext(display, context); |
| EXPECT_NO_EGL_ERROR(); |
| EXPECT_EQ((EGLBoolean)EGL_TRUE, success); |
| |
| success = eglDestroySurface(display, surface); |
| EXPECT_NO_EGL_ERROR(); |
| EXPECT_EQ((EGLBoolean)EGL_TRUE, success); |
| |
| success = eglTerminate(display); |
| EXPECT_NO_EGL_ERROR(); |
| EXPECT_EQ((EGLBoolean)EGL_TRUE, success); |
| } |
| |
| struct ProgramHandles |
| { |
| GLuint program; |
| GLuint vertexShader; |
| GLuint fragmentShader; |
| }; |
| |
| GLuint MakeShader(const std::string &source, GLenum shaderType) |
| { |
| GLuint shader = glCreateShader(shaderType); |
| const char *c_source[1] = { source.c_str() }; |
| glShaderSource(shader, 1, c_source, nullptr); |
| glCompileShader(shader); |
| EXPECT_NO_GL_ERROR(); |
| |
| GLchar buf[1024]; |
| GLint compileStatus = 0; |
| glGetShaderiv(shader, GL_COMPILE_STATUS, &compileStatus); |
| glGetShaderInfoLog(shader, sizeof(buf), nullptr, buf); |
| EXPECT_EQ(compileStatus, GL_TRUE) << "Compile status: " << std::endl |
| << buf; |
| |
| return shader; |
| } |
| |
| GLuint MakeProgram(GLuint vs, GLuint fs) |
| { |
| GLuint program; |
| |
| program = glCreateProgram(); |
| EXPECT_NO_GL_ERROR(); |
| |
| glAttachShader(program, vs); |
| glAttachShader(program, fs); |
| EXPECT_NO_GL_ERROR(); |
| |
| return program; |
| } |
| |
| void LinkProgram(GLuint program) |
| { |
| GLchar buf[1024]; |
| glLinkProgram(program); |
| |
| GLint linkStatus = 0; |
| glGetProgramiv(program, GL_LINK_STATUS, &linkStatus); |
| glGetProgramInfoLog(program, sizeof(buf), nullptr, buf); |
| EXPECT_NE(linkStatus, 0) << "Link status: " << std::endl |
| << buf; |
| |
| EXPECT_NO_GL_ERROR(); |
| } |
| |
| ProgramHandles createProgram(const std::string &vs, const std::string &fs) |
| { |
| ProgramHandles ph; |
| ph.vertexShader = MakeShader(vs, GL_VERTEX_SHADER); |
| ph.fragmentShader = MakeShader(fs, GL_FRAGMENT_SHADER); |
| ph.program = MakeProgram(ph.vertexShader, ph.fragmentShader); |
| LinkProgram(ph.program); |
| |
| return ph; |
| } |
| |
| void deleteProgram(const ProgramHandles &ph) |
| { |
| glDeleteShader(ph.fragmentShader); |
| glDeleteShader(ph.vertexShader); |
| glDeleteProgram(ph.program); |
| |
| EXPECT_NO_GL_ERROR(); |
| } |
| |
| void drawQuad(GLuint program, const char *textureName = nullptr) |
| { |
| GLint prevProgram = 0; |
| glGetIntegerv(GL_CURRENT_PROGRAM, &prevProgram); |
| |
| glUseProgram(program); |
| EXPECT_NO_GL_ERROR(); |
| |
| GLint posLoc = glGetAttribLocation(program, "position"); |
| EXPECT_NO_GL_ERROR(); |
| |
| if(textureName) |
| { |
| GLint location = glGetUniformLocation(program, textureName); |
| ASSERT_NE(-1, location); |
| glUniform1i(location, 0); |
| } |
| |
| float vertices[18] = { -1.0f, 1.0f, 0.5f, |
| -1.0f, -1.0f, 0.5f, |
| 1.0f, -1.0f, 0.5f, |
| -1.0f, 1.0f, 0.5f, |
| 1.0f, -1.0f, 0.5f, |
| 1.0f, 1.0f, 0.5f }; |
| |
| glVertexAttribPointer(posLoc, 3, GL_FLOAT, GL_FALSE, 0, vertices); |
| glEnableVertexAttribArray(posLoc); |
| glDrawArrays(GL_TRIANGLES, 0, 6); |
| EXPECT_NO_GL_ERROR(); |
| |
| glVertexAttribPointer(posLoc, 4, GL_FLOAT, GL_FALSE, 0, nullptr); |
| glDisableVertexAttribArray(posLoc); |
| glUseProgram(prevProgram); |
| EXPECT_NO_GL_ERROR(); |
| } |
| |
| std::string replace(std::string str, const std::string &substr, const std::string &replacement) |
| { |
| size_t pos = 0; |
| while((pos = str.find(substr, pos)) != std::string::npos) |
| { |
| str.replace(pos, substr.length(), replacement); |
| pos += replacement.length(); |
| } |
| return str; |
| } |
| |
| void checkCompiles(std::string v, std::string f) |
| { |
| Initialize(3, false); |
| |
| std::string vs = |
| R"(#version 300 es |
| in vec4 position; |
| out float unfoldable; |
| $INSERT |
| void main() |
| { |
| unfoldable = position.x; |
| gl_Position = vec4(position.xy, 0.0, 1.0); |
| gl_Position.x += F(unfoldable);\ |
| })"; |
| |
| std::string fs = |
| R"(#version 300 es |
| precision mediump float; |
| in float unfoldable; |
| out vec4 fragColor; |
| $INSERT |
| void main() |
| { |
| fragColor = vec4(1.0, 1.0, 1.0, 1.0); |
| fragColor.x += F(unfoldable); |
| })"; |
| |
| vs = replace(vs, "$INSERT", (v.length() > 0) ? v : "float F(float ignored) { return 0.0; }"); |
| fs = replace(fs, "$INSERT", (f.length() > 0) ? f : "float F(float ignored) { return 0.0; }"); |
| |
| const ProgramHandles ph = createProgram(vs, fs); |
| |
| glUseProgram(ph.program); |
| |
| drawQuad(ph.program); |
| |
| deleteProgram(ph); |
| |
| EXPECT_NO_GL_ERROR(); |
| |
| Uninitialize(); |
| } |
| |
| void checkCompiles(std::string s) |
| { |
| checkCompiles(s, ""); |
| checkCompiles("", s); |
| } |
| |
| std::string checkCompileFails(std::string source, GLenum glShaderType) |
| { |
| Initialize(3, false); |
| |
| GLint compileStatus = 0; |
| const char *c_source[1] = { source.c_str() }; |
| GLuint glShader = glCreateShader(glShaderType); |
| |
| glShaderSource(glShader, 1, c_source, nullptr); |
| glCompileShader(glShader); |
| EXPECT_NO_GL_ERROR(); |
| |
| std::string log; |
| char *buf; |
| GLsizei length = 0; |
| GLsizei written = 0; |
| |
| glGetShaderiv(glShader, GL_COMPILE_STATUS, &compileStatus); |
| EXPECT_EQ(compileStatus, GL_FALSE); |
| |
| glGetShaderiv(glShader, GL_INFO_LOG_LENGTH, &length); |
| EXPECT_NO_GL_ERROR(); |
| EXPECT_NE(length, 0); |
| buf = new char[length]; |
| |
| glGetShaderInfoLog(glShader, length, &written, buf); |
| EXPECT_NO_GL_ERROR(); |
| EXPECT_EQ(length, written + 1); |
| log.assign(buf, length); |
| delete[] buf; |
| |
| glDeleteShader(glShader); |
| |
| Uninitialize(); |
| |
| return log; |
| } |
| |
| void checkCompileFails(std::string s) |
| { |
| std::string vs = |
| R"(#version 300 es |
| in vec4 position; |
| out float unfoldable; |
| $INSERT |
| void main() |
| { |
| unfoldable = position.x; |
| gl_Position = vec4(position.xy, 0.0, 1.0); |
| gl_Position.x += F(unfoldable); |
| })"; |
| |
| std::string fs = |
| R"(#version 300 es |
| precision mediump float; |
| in float unfoldable; |
| out vec4 fragColor; |
| $INSERT |
| void main() |
| { |
| fragColor = vec4(1.0, 1.0, 1.0, 1.0); |
| fragColor.x += F(unfoldable); |
| })"; |
| |
| vs = replace(vs, "$INSERT", s); |
| fs = replace(fs, "$INSERT", s); |
| |
| checkCompileFails(vs, GL_VERTEX_SHADER); |
| checkCompileFails(fs, GL_FRAGMENT_SHADER); |
| } |
| |
| EGLDisplay getDisplay() const { return display; } |
| EGLConfig getConfig() const { return config; } |
| EGLSurface getSurface() const { return surface; } |
| EGLContext getContext() const { return context; } |
| |
| private: |
| EGLDisplay display; |
| EGLConfig config; |
| EGLSurface surface; |
| EGLContext context; |
| }; |
| |
| TEST_F(SwiftShaderTest, Initalization) |
| { |
| Initialize(2, true); |
| |
| const GLubyte *glVendor = glGetString(GL_VENDOR); |
| EXPECT_NO_GL_ERROR(); |
| EXPECT_STREQ("Google Inc.", (const char *)glVendor); |
| |
| const GLubyte *glRenderer = glGetString(GL_RENDERER); |
| EXPECT_NO_GL_ERROR(); |
| EXPECT_STREQ("Google SwiftShader", (const char *)glRenderer); |
| |
| // SwiftShader return an OpenGL ES 3.0 context when a 2.0 context is requested, as allowed by the spec. |
| const GLubyte *glVersion = glGetString(GL_VERSION); |
| EXPECT_NO_GL_ERROR(); |
| EXPECT_THAT((const char *)glVersion, testing::HasSubstr("OpenGL ES 3.0 SwiftShader ")); |
| |
| Uninitialize(); |
| } |
| |
| // Test attempting to clear an incomplete framebuffer |
| TEST_F(SwiftShaderTest, ClearIncomplete) |
| { |
| Initialize(3, false); |
| |
| GLfloat zero_float = 0; |
| GLuint renderbuffer; |
| glGenRenderbuffers(1, &renderbuffer); |
| GLuint framebuffer; |
| glGenFramebuffers(1, &framebuffer); |
| |
| glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer); |
| EXPECT_NO_GL_ERROR(); |
| glRenderbufferStorage(GL_RENDERBUFFER, GL_R8I, 43, 27); |
| EXPECT_NO_GL_ERROR(); |
| glBindFramebuffer(GL_READ_FRAMEBUFFER, framebuffer); |
| EXPECT_NO_GL_ERROR(); |
| glFramebufferRenderbuffer(GL_READ_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, renderbuffer); |
| EXPECT_NO_GL_ERROR(); |
| glBindFramebuffer(GL_FRAMEBUFFER, framebuffer); |
| EXPECT_NO_GL_ERROR(); |
| glClearBufferfv(GL_DEPTH, 0, &zero_float); |
| EXPECT_GLENUM_EQ(GL_INVALID_FRAMEBUFFER_OPERATION, glGetError()); |
| |
| Uninitialize(); |
| } |
| |
| // Test unrolling of a loop |
| TEST_F(SwiftShaderTest, UnrollLoop) |
| { |
| Initialize(3, false); |
| |
| unsigned char green[4] = { 0, 255, 0, 255 }; |
| |
| const std::string vs = |
| R"(#version 300 es |
| in vec4 position; |
| out vec4 color; |
| void main() |
| { |
| for(int i = 0; i < 4; i++) |
| { |
| color[i] = (i % 2 == 0) ? 0.0 : 1.0; |
| } |
| gl_Position = vec4(position.xy, 0.0, 1.0); |
| })"; |
| |
| const std::string fs = |
| R"(#version 300 es |
| precision mediump float; |
| in vec4 color; |
| out vec4 fragColor; |
| void main() |
| { |
| fragColor = color; |
| })"; |
| |
| const ProgramHandles ph = createProgram(vs, fs); |
| |
| // Expect the info log to contain "unrolled". This is not a spec requirement. |
| GLsizei length = 0; |
| glGetShaderiv(ph.vertexShader, GL_INFO_LOG_LENGTH, &length); |
| EXPECT_NO_GL_ERROR(); |
| EXPECT_NE(length, 0); |
| char *log = new char[length]; |
| GLsizei written = 0; |
| glGetShaderInfoLog(ph.vertexShader, length, &written, log); |
| EXPECT_NO_GL_ERROR(); |
| EXPECT_EQ(length, written + 1); |
| EXPECT_NE(strstr(log, "unrolled"), nullptr); |
| delete[] log; |
| |
| glUseProgram(ph.program); |
| |
| glClearColor(0.0, 0.0, 0.0, 0.0); |
| glClear(GL_COLOR_BUFFER_BIT); |
| EXPECT_NO_GL_ERROR(); |
| |
| drawQuad(ph.program); |
| |
| deleteProgram(ph); |
| |
| expectFramebufferColor(green); |
| |
| EXPECT_NO_GL_ERROR(); |
| |
| Uninitialize(); |
| } |
| |
| // Test non-canonical or non-deterministic loops do not get unrolled |
| TEST_F(SwiftShaderTest, DynamicLoop) |
| { |
| Initialize(3, false); |
| |
| const std::string vs = |
| R"(#version 300 es |
| in vec4 position; |
| out vec4 color; |
| void main() |
| { |
| for(int i = 0; i < 4; ) |
| { |
| color[i] = (i % 2 == 0) ? 0.0 : 1.0; |
| i++; |
| } |
| gl_Position = vec4(position.xy, 0.0, 1.0); |
| })"; |
| |
| const std::string fs = |
| R"(#version 300 es |
| precision mediump float; |
| in vec4 color; |
| out vec4 fragColor; |
| void main() |
| { |
| vec4 temp; |
| for(int i = 0; i < 4; i++) |
| { |
| if(color.x < 0.0) return; |
| temp[i] = color[i]; |
| } |
| fragColor = vec4(temp[0], temp[1], temp[2], temp[3]); |
| })"; |
| |
| const ProgramHandles ph = createProgram(vs, fs); |
| |
| // Expect the info logs to be empty. This is not a spec requirement. |
| GLsizei length = 0; |
| glGetShaderiv(ph.vertexShader, GL_INFO_LOG_LENGTH, &length); |
| EXPECT_NO_GL_ERROR(); |
| EXPECT_EQ(length, 0); |
| glGetShaderiv(ph.fragmentShader, GL_INFO_LOG_LENGTH, &length); |
| EXPECT_NO_GL_ERROR(); |
| EXPECT_EQ(length, 0); |
| |
| glUseProgram(ph.program); |
| |
| glClearColor(0.0, 0.0, 0.0, 0.0); |
| glClear(GL_COLOR_BUFFER_BIT); |
| EXPECT_NO_GL_ERROR(); |
| |
| drawQuad(ph.program); |
| |
| deleteProgram(ph); |
| |
| unsigned char green[4] = { 0, 255, 0, 255 }; |
| expectFramebufferColor(green); |
| |
| EXPECT_NO_GL_ERROR(); |
| |
| Uninitialize(); |
| } |
| |
| // Test dynamic indexing |
| TEST_F(SwiftShaderTest, DynamicIndexing) |
| { |
| Initialize(3, false); |
| |
| const std::string vs = |
| R"(#version 300 es |
| in vec4 position; |
| out float color[4]; |
| void main() |
| { |
| for(int i = 0; i < 4; ) |
| { |
| int j = (gl_VertexID + i) % 4; |
| color[j] = (j % 2 == 0) ? 0.0 : 1.0; |
| i++; |
| } |
| gl_Position = vec4(position.xy, 0.0, 1.0); |
| })"; |
| |
| const std::string fs = |
| R"(#version 300 es |
| precision mediump float; |
| in float color[4]; |
| out vec4 fragColor; |
| void main() |
| { |
| float temp[4]; |
| for(int i = 0; i < 4; ) |
| { |
| temp[i] = color[i]; |
| i++; |
| } |
| fragColor = vec4(temp[0], temp[1], temp[2], temp[3]); |
| })"; |
| |
| const ProgramHandles ph = createProgram(vs, fs); |
| |
| glUseProgram(ph.program); |
| |
| glClearColor(0.0, 0.0, 0.0, 0.0); |
| glClear(GL_COLOR_BUFFER_BIT); |
| EXPECT_NO_GL_ERROR(); |
| |
| drawQuad(ph.program); |
| |
| deleteProgram(ph); |
| |
| unsigned char green[4] = { 0, 255, 0, 255 }; |
| expectFramebufferColor(green); |
| |
| EXPECT_NO_GL_ERROR(); |
| |
| Uninitialize(); |
| } |
| |
| // Test vertex attribute location linking |
| TEST_F(SwiftShaderTest, AttributeLocation) |
| { |
| Initialize(3, false); |
| |
| const std::string vs = |
| R"(#version 300 es |
| layout(location = 0) in vec4 a0; // Explicitly bound in GLSL |
| layout(location = 2) in vec4 a2; // Explicitly bound in GLSL |
| in vec4 a5; // Bound to location 5 by API |
| in mat2 a3; // Implicit location |
| in vec4 a1; // Implicit location |
| in vec4 a6; // Implicit location |
| out vec4 color; |
| void main() |
| { |
| vec4 a34 = vec4(a3[0], a3[1]); |
| gl_Position = a0; |
| color = (a2 == vec4(1.0, 2.0, 3.0, 4.0) && |
| a34 == vec4(5.0, 6.0, 7.0, 8.0) && |
| a5 == vec4(9.0, 10.0, 11.0, 12.0) && |
| a1 == vec4(13.0, 14.0, 15.0, 16.0) && |
| a6 == vec4(17.0, 18.0, 19.0, 20.0)) ? |
| vec4(0.0, 1.0, 0.0, 1.0) : |
| vec4(1.0, 0.0, 0.0, 1.0); |
| })"; |
| |
| const std::string fs = |
| R"(#version 300 es |
| precision mediump float; |
| in vec4 color; |
| out vec4 fragColor; |
| void main() |
| { |
| fragColor = color; |
| })"; |
| |
| ProgramHandles ph; |
| ph.vertexShader = MakeShader(vs, GL_VERTEX_SHADER); |
| ph.fragmentShader = MakeShader(fs, GL_FRAGMENT_SHADER); |
| ph.program = glCreateProgram(); |
| EXPECT_NO_GL_ERROR(); |
| |
| // Not assigned a layout location in GLSL. Bind it explicitly with the API. |
| glBindAttribLocation(ph.program, 5, "a5"); |
| EXPECT_NO_GL_ERROR(); |
| |
| // Should not override GLSL layout location qualifier |
| glBindAttribLocation(ph.program, 8, "a2"); |
| EXPECT_NO_GL_ERROR(); |
| |
| glAttachShader(ph.program, ph.vertexShader); |
| glAttachShader(ph.program, ph.fragmentShader); |
| glLinkProgram(ph.program); |
| EXPECT_NO_GL_ERROR(); |
| |
| // Changes after linking should have no effect |
| glBindAttribLocation(ph.program, 0, "a1"); |
| glBindAttribLocation(ph.program, 6, "a2"); |
| glBindAttribLocation(ph.program, 2, "a6"); |
| |
| GLint linkStatus = 0; |
| glGetProgramiv(ph.program, GL_LINK_STATUS, &linkStatus); |
| EXPECT_NE(linkStatus, 0); |
| EXPECT_NO_GL_ERROR(); |
| |
| float vertices[6][3] = { { -1.0f, 1.0f, 0.5f }, |
| { -1.0f, -1.0f, 0.5f }, |
| { 1.0f, -1.0f, 0.5f }, |
| { -1.0f, 1.0f, 0.5f }, |
| { 1.0f, -1.0f, 0.5f }, |
| { 1.0f, 1.0f, 0.5f } }; |
| |
| float attributes[5][4] = { { 1.0f, 2.0f, 3.0f, 4.0f }, |
| { 5.0f, 6.0f, 7.0f, 8.0f }, |
| { 9.0f, 10.0f, 11.0f, 12.0f }, |
| { 13.0f, 14.0f, 15.0f, 16.0f }, |
| { 17.0f, 18.0f, 19.0f, 20.0f } }; |
| |
| GLint a0 = glGetAttribLocation(ph.program, "a0"); |
| EXPECT_EQ(a0, 0); |
| glVertexAttribPointer(a0, 3, GL_FLOAT, GL_FALSE, 0, vertices); |
| glEnableVertexAttribArray(a0); |
| EXPECT_NO_GL_ERROR(); |
| |
| GLint a2 = glGetAttribLocation(ph.program, "a2"); |
| EXPECT_EQ(a2, 2); |
| glVertexAttribPointer(a2, 4, GL_FLOAT, GL_FALSE, 0, attributes[0]); |
| glVertexAttribDivisor(a2, 1); |
| glEnableVertexAttribArray(a2); |
| EXPECT_NO_GL_ERROR(); |
| |
| GLint a3 = glGetAttribLocation(ph.program, "a3"); |
| EXPECT_EQ(a3, 3); // Note: implementation specific |
| glVertexAttribPointer(a3 + 0, 2, GL_FLOAT, GL_FALSE, 0, &attributes[1][0]); |
| glVertexAttribPointer(a3 + 1, 2, GL_FLOAT, GL_FALSE, 0, &attributes[1][2]); |
| glVertexAttribDivisor(a3 + 0, 1); |
| glVertexAttribDivisor(a3 + 1, 1); |
| glEnableVertexAttribArray(a3 + 0); |
| glEnableVertexAttribArray(a3 + 1); |
| EXPECT_NO_GL_ERROR(); |
| |
| GLint a5 = glGetAttribLocation(ph.program, "a5"); |
| EXPECT_EQ(a5, 5); |
| glVertexAttribPointer(a5, 4, GL_FLOAT, GL_FALSE, 0, attributes[2]); |
| glVertexAttribDivisor(a5, 1); |
| glEnableVertexAttribArray(a5); |
| EXPECT_NO_GL_ERROR(); |
| |
| GLint a1 = glGetAttribLocation(ph.program, "a1"); |
| EXPECT_EQ(a1, 1); // Note: implementation specific |
| glVertexAttribPointer(a1, 4, GL_FLOAT, GL_FALSE, 0, attributes[3]); |
| glVertexAttribDivisor(a1, 1); |
| glEnableVertexAttribArray(a1); |
| EXPECT_NO_GL_ERROR(); |
| |
| GLint a6 = glGetAttribLocation(ph.program, "a6"); |
| EXPECT_EQ(a6, 6); // Note: implementation specific |
| glVertexAttribPointer(a6, 4, GL_FLOAT, GL_FALSE, 0, attributes[4]); |
| glVertexAttribDivisor(a6, 1); |
| glEnableVertexAttribArray(a6); |
| EXPECT_NO_GL_ERROR(); |
| |
| glUseProgram(ph.program); |
| glDrawArrays(GL_TRIANGLES, 0, 6); |
| EXPECT_NO_GL_ERROR(); |
| |
| deleteProgram(ph); |
| |
| unsigned char green[4] = { 0, 255, 0, 255 }; |
| expectFramebufferColor(green); |
| |
| EXPECT_NO_GL_ERROR(); |
| |
| Uninitialize(); |
| } |
| |
| // Test negative layout locations |
| TEST_F(SwiftShaderTest, NegativeLocation) |
| { |
| const std::string vs = |
| R"(#version 300 es |
| layout(location = 0x86868686u) in vec4 a0; // Explicitly bound in GLSL |
| layout(location = 0x96969696u) in vec4 a2; // Explicitly bound in GLSL |
| in vec4 a5; // Bound to location 5 by API |
| in mat2 a3; // Implicit location |
| in vec4 a1; // Implicit location |
| in vec4 a6; // Implicit location |
| out vec4 color; |
| float F(float f) |
| { |
| vec4 a34 = vec4(a3[0], a3[1]);\n" |
| gl_Position = a0;\n" |
| color = (a2 == vec4(1.0, 2.0, 3.0, 4.0) && |
| a34 == vec4(5.0, 6.0, 7.0, 8.0) && |
| a5 == vec4(9.0, 10.0, 11.0, 12.0) && |
| a1 == vec4(13.0, 14.0, 15.0, 16.0) && |
| a6 == vec4(17.0, 18.0, 19.0, 20.0)) ? |
| vec4(0.0, 1.0, 0.0, 1.0) : |
| vec4(1.0, 0.0, 0.0, 1.0); |
| })"; |
| |
| const std::string fs = |
| R"(#version 300 es |
| precision mediump float; |
| in vec4 color; |
| layout(location = 0xA6A6A6A6u) out vec4 fragColor; |
| float F main() |
| { |
| fragColor = color; |
| })"; |
| |
| { |
| std::string log = checkCompileFails(vs, GL_VERTEX_SHADER); |
| EXPECT_NE(strstr(log.c_str(), "out of range: location must be non-negative"), nullptr); |
| } |
| |
| { |
| std::string log = checkCompileFails(fs, GL_FRAGMENT_SHADER); |
| EXPECT_NE(strstr(log.c_str(), "out of range: location must be non-negative"), nullptr); |
| } |
| } |
| |
| // Tests clearing of a texture with 'dirty' content. |
| TEST_F(SwiftShaderTest, ClearDirtyTexture) |
| { |
| Initialize(3, false); |
| |
| GLuint tex = 1; |
| glBindTexture(GL_TEXTURE_2D, tex); |
| glTexImage2D(GL_TEXTURE_2D, 0, GL_R11F_G11F_B10F, 256, 256, 0, GL_RGB, GL_UNSIGNED_INT_10F_11F_11F_REV, nullptr); |
| EXPECT_NO_GL_ERROR(); |
| |
| GLuint fbo = 1; |
| glBindFramebuffer(GL_FRAMEBUFFER, fbo); |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0); |
| EXPECT_NO_GL_ERROR(); |
| EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER)); |
| |
| float dirty_color[3] = { 128 / 255.0f, 64 / 255.0f, 192 / 255.0f }; |
| GLint dirty_x = 8; |
| GLint dirty_y = 12; |
| glTexSubImage2D(GL_TEXTURE_2D, 0, dirty_x, dirty_y, 1, 1, GL_RGB, GL_FLOAT, dirty_color); |
| |
| const float clear_color[4] = { 1.0f, 32.0f, 0.5f, 1.0f }; |
| glClearColor(clear_color[0], clear_color[1], clear_color[2], 1.0f); |
| glClear(GL_COLOR_BUFFER_BIT); |
| EXPECT_NO_GL_ERROR(); |
| |
| expectFramebufferColor(clear_color, dirty_x, dirty_y); |
| |
| Uninitialize(); |
| } |
| |
| // Tests copying between textures of different floating-point formats using a framebuffer object. |
| TEST_F(SwiftShaderTest, CopyTexImage) |
| { |
| Initialize(3, false); |
| |
| GLuint tex1 = 1; |
| float green[4] = { 0.0f, 1.0f, 0.0f, 1.0f }; |
| glBindTexture(GL_TEXTURE_2D, tex1); |
| glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA32F, 16, 16); |
| glTexSubImage2D(GL_TEXTURE_2D, 0, 5, 10, 1, 1, GL_RGBA, GL_FLOAT, &green); |
| EXPECT_NO_GL_ERROR(); |
| |
| GLuint fbo = 1; |
| glBindFramebuffer(GL_FRAMEBUFFER, fbo); |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex1, 0); |
| EXPECT_NO_GL_ERROR(); |
| |
| GLuint tex2 = 2; |
| glBindTexture(GL_TEXTURE_2D, tex2); |
| glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 2, 6, 8, 8, 0); |
| EXPECT_NO_GL_ERROR(); |
| |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex2, 0); |
| expectFramebufferColor(green, 3, 4); |
| EXPECT_NO_GL_ERROR(); |
| |
| Uninitialize(); |
| } |
| |
| // Tests copying to a texture from a pixel buffer object |
| TEST_F(SwiftShaderTest, CopyTexImageFromPixelBuffer) |
| { |
| Initialize(3, false); |
| const GLuint red = 0xff0000ff; |
| const GLuint green = 0x00ff00ff; |
| const GLuint blue = 0x0000ffff; |
| // Set up texture |
| GLuint texture = 0; |
| glGenTextures(1, &texture); |
| EXPECT_NO_GL_ERROR(); |
| GLuint tex_data[4][4] = { |
| { red, red, red, red }, |
| { red, red, red, red }, |
| { red, red, red, red }, |
| { red, red, red, red } |
| }; |
| glBindTexture(GL_TEXTURE_2D, texture); |
| EXPECT_NO_GL_ERROR(); |
| glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, (void *)tex_data[0]); |
| EXPECT_NO_GL_ERROR(); |
| // Set up Pixel Buffer Object |
| GLuint pixelBuffer = 0; |
| glGenBuffers(1, &pixelBuffer); |
| glBindBuffer(GL_PIXEL_UNPACK_BUFFER, pixelBuffer); |
| EXPECT_NO_GL_ERROR(); |
| glPixelStorei(GL_UNPACK_ROW_LENGTH, 4); |
| glPixelStorei(GL_UNPACK_ALIGNMENT, 1); |
| EXPECT_NO_GL_ERROR(); |
| GLuint pixel_data[4][4] = { |
| { blue, blue, green, green }, |
| { blue, blue, green, green }, |
| { blue, blue, green, green }, |
| { blue, blue, green, green }, |
| }; |
| glBufferData(GL_PIXEL_UNPACK_BUFFER, sizeof(pixel_data), (void *)pixel_data, GL_STREAM_DRAW); |
| // Should set the 2-rightmost columns of the currently bound texture to the |
| // 2-rightmost columns of the PBO; |
| GLintptr offset = 2 * sizeof(GLuint); |
| glTexSubImage2D(GL_TEXTURE_2D, 0, 2, 0, 2, 4, GL_RGBA, GL_UNSIGNED_BYTE, reinterpret_cast<void *>(offset)); |
| EXPECT_NO_GL_ERROR(); |
| // Create an off-screen framebuffer to render the texture data to. |
| GLuint fbo = 0; |
| glGenFramebuffers(1, &fbo); |
| glBindFramebuffer(GL_FRAMEBUFFER, fbo); |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); |
| EXPECT_NO_GL_ERROR(); |
| unsigned int color[4][4] = { |
| { 0, 0, 0, 0 }, |
| { 0, 0, 0, 0 }, |
| { 0, 0, 0, 0 }, |
| { 0, 0, 0, 0 } |
| }; |
| glReadPixels(0, 0, 4, 4, GL_RGBA, GL_UNSIGNED_BYTE, &color); |
| EXPECT_NO_GL_ERROR(); |
| bool allEqual = true; |
| for(int i = 0; i < 4; i++) |
| { |
| for(int j = 0; j < 2; j++) |
| { |
| allEqual = allEqual && (color[i][j] == tex_data[i][j]); |
| allEqual = allEqual && (color[i][j + 2] == pixel_data[i][j + 2]); |
| if(!allEqual) |
| break; |
| } |
| if(!allEqual) |
| break; |
| } |
| EXPECT_EQ(allEqual, true); |
| // We can't use an offset of 3 GLuints or more, because the PBO is not large |
| // enough to satisfy such a request with the current GL_UNPACK_ROW_LENGTH. |
| offset = 3 * sizeof(GLuint); |
| glTexSubImage2D(GL_TEXTURE_2D, 0, 2, 0, 2, 4, GL_RGBA, GL_UNSIGNED_BYTE, reinterpret_cast<void *>(offset)); |
| GLenum error = glGetError(); |
| EXPECT_GLENUM_EQ(GL_INVALID_OPERATION, error); |
| Uninitialize(); |
| } |
| |
| // Tests reading of half-float textures. |
| TEST_F(SwiftShaderTest, ReadHalfFloat) |
| { |
| Initialize(3, false); |
| |
| GLuint tex = 1; |
| glBindTexture(GL_TEXTURE_2D, tex); |
| glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB16F, 256, 256, 0, GL_RGB, GL_HALF_FLOAT, nullptr); |
| EXPECT_NO_GL_ERROR(); |
| |
| GLuint fbo = 1; |
| glBindFramebuffer(GL_FRAMEBUFFER, fbo); |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0); |
| EXPECT_NO_GL_ERROR(); |
| EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER)); |
| |
| const float clear_color[4] = { 1.0f, 32.0f, 0.5f, 1.0f }; |
| glClearColor(clear_color[0], clear_color[1], clear_color[2], 1.0f); |
| glClear(GL_COLOR_BUFFER_BIT); |
| EXPECT_NO_GL_ERROR(); |
| |
| uint16_t pixel[3] = { 0x1234, 0x3F80, 0xAAAA }; |
| GLint x = 6; |
| GLint y = 3; |
| glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, 1, 1, GL_RGB, GL_HALF_FLOAT, pixel); |
| |
| // This relies on GL_HALF_FLOAT being a valid type for read-back, |
| // which isn't guaranteed by the spec but is supported by SwiftShader. |
| uint16_t read_color[3] = { 0, 0, 0 }; |
| glReadPixels(x, y, 1, 1, GL_RGB, GL_HALF_FLOAT, &read_color); |
| EXPECT_NO_GL_ERROR(); |
| EXPECT_EQ(read_color[0], pixel[0]); |
| EXPECT_EQ(read_color[1], pixel[1]); |
| EXPECT_EQ(read_color[2], pixel[2]); |
| |
| Uninitialize(); |
| } |
| |
| // Tests construction of a structure containing a single matrix |
| TEST_F(SwiftShaderTest, MatrixInStruct) |
| { |
| Initialize(2, false); |
| |
| const std::string fs = |
| R"(#version 100 |
| precision mediump float; |
| struct S |
| { |
| mat2 rotation; |
| }; |
| void main(void) |
| { |
| float angle = 1.0; |
| S(mat2(1.0, angle, 1.0, 1.0)); |
| })"; |
| |
| MakeShader(fs, GL_FRAGMENT_SHADER); |
| EXPECT_NO_GL_ERROR(); |
| |
| Uninitialize(); |
| } |
| |
| TEST_F(SwiftShaderTest, TestMat4Uniform) |
| { |
| Initialize(3, false); |
| const std::string vs = R"(#version 300 es |
| precision highp float; |
| uniform mat4 UniformMatrix; |
| out vec4 color; |
| void main() |
| { |
| const vec4 pos[] = vec4[]( |
| vec4( 1., 1., .0, 1.), |
| vec4(-1., 1., .0, 1.), |
| vec4(-1., -1., .0, 1.), |
| vec4( 1., 1., .0, 1.), |
| vec4(-1., -1., .0, 1.), |
| vec4( 1., -1., .0, 1.)); |
| gl_Position = pos[gl_VertexID]; |
| color = vec4(vec3(UniformMatrix[0].xyz), 1.); |
| } |
| )"; |
| const std::string ps = R"(#version 300 es |
| precision highp float; |
| in vec4 color; |
| out vec4 fragColor; |
| void main() |
| { |
| fragColor = color; |
| })"; |
| const ProgramHandles ph = createProgram(vs, ps); |
| |
| glUseProgram(ph.program); |
| GLint location = glGetUniformLocation(ph.program, "UniformMatrix"); |
| ASSERT_NE(-1, location); |
| constexpr float unit_mat[] = { |
| 1., 0., 0., 0., |
| 0., 1., 0., 0., |
| 0., 0., 1., 0., |
| 0., 0., 0., 1. |
| }; |
| glUniformMatrix4fv(location, 1, GL_FALSE, unit_mat); |
| glClearColor(0.0, 0.0, 0.0, 1.0); |
| glClear(GL_COLOR_BUFFER_BIT); |
| GLuint dummyvao = GL_NONE; |
| glGenVertexArrays(1, &dummyvao); |
| glBindVertexArray(dummyvao); |
| glDrawArrays(GL_TRIANGLES, 0, 6); |
| |
| EXPECT_NO_GL_ERROR(); |
| |
| unsigned char red[4] = { 255, 0, 0, 255 }; |
| expectFramebufferColor(red); |
| |
| Uninitialize(); |
| } |
| |
| // Test sampling from a sampler in a struct as a function argument |
| TEST_F(SwiftShaderTest, SamplerArrayInStructArrayAsFunctionArg) |
| { |
| Initialize(3, false); |
| |
| GLuint tex = 1; |
| glBindTexture(GL_TEXTURE_2D, tex); |
| EXPECT_NO_GL_ERROR(); |
| |
| unsigned char green[4] = { 0, 255, 0, 255 }; |
| glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, green); |
| EXPECT_NO_GL_ERROR(); |
| |
| const std::string vs = |
| R"(#version 300 es |
| in vec4 position; |
| void main() |
| { |
| gl_Position = vec4(position.xy, 0.0, 1.0); |
| })"; |
| |
| const std::string fs = |
| R"(#version 300 es |
| precision mediump float; |
| struct SamplerStruct{ sampler2D tex[2]; }; |
| vec4 doSample(in SamplerStruct s[2]) |
| { |
| return texture(s[1].tex[1], vec2(0.0)); |
| } |
| uniform SamplerStruct samplerStruct[2]; |
| out vec4 fragColor; |
| void main() |
| { |
| fragColor = doSample(samplerStruct); |
| })"; |
| |
| const ProgramHandles ph = createProgram(vs, fs); |
| |
| glUseProgram(ph.program); |
| GLint location = glGetUniformLocation(ph.program, "samplerStruct[1].tex[1]"); |
| ASSERT_NE(-1, location); |
| glUniform1i(location, 0); |
| |
| glClearColor(0.0, 0.0, 0.0, 0.0); |
| glClear(GL_COLOR_BUFFER_BIT); |
| EXPECT_NO_GL_ERROR(); |
| |
| drawQuad(ph.program, "samplerStruct[1].tex[1]"); |
| |
| deleteProgram(ph); |
| |
| expectFramebufferColor(green); |
| |
| EXPECT_NO_GL_ERROR(); |
| |
| Uninitialize(); |
| } |
| |
| // Test sampling from a sampler in a struct as a function argument |
| TEST_F(SwiftShaderTest, AtanCornerCases) |
| { |
| Initialize(3, false); |
| |
| const std::string vs = |
| R"(#version 300 es |
| in vec4 position; |
| void main() |
| { |
| gl_Position = vec4(position.xy, 0.0, 1.0); |
| })"; |
| |
| const std::string fs = |
| R"(#version 300 es |
| precision mediump float; |
| const float kPI = 3.14159265358979323846; |
| uniform float positive_value; |
| uniform float negative_value; |
| out vec4 fragColor; |
| void main() |
| { |
| // Should yield vec4(0, pi, pi/2, -pi/2) |
| vec4 result = atan(vec4(0.0, 0.0, positive_value, negative_value), |
| vec4(positive_value, negative_value, 0.0, 0.0)); |
| fragColor = (result / vec4(kPI)) + vec4(0.5, -0.5, 0.0, 1.0) + vec4(0.5 / 255.0); |
| })"; |
| |
| const ProgramHandles ph = createProgram(vs, fs); |
| |
| glUseProgram(ph.program); |
| GLint positive_value = glGetUniformLocation(ph.program, "positive_value"); |
| ASSERT_NE(-1, positive_value); |
| GLint negative_value = glGetUniformLocation(ph.program, "negative_value"); |
| ASSERT_NE(-1, negative_value); |
| |
| float value = 1.0f; |
| glUniform1fv(positive_value, 1, &value); |
| value = -1.0f; |
| glUniform1fv(negative_value, 1, &value); |
| |
| glClearColor(0.0, 0.0, 0.0, 0.0); |
| glClear(GL_COLOR_BUFFER_BIT); |
| EXPECT_NO_GL_ERROR(); |
| |
| drawQuad(ph.program, nullptr); |
| |
| deleteProgram(ph); |
| |
| unsigned char grey[4] = { 128, 128, 128, 128 }; |
| expectFramebufferColor(grey); |
| |
| EXPECT_NO_GL_ERROR(); |
| |
| Uninitialize(); |
| } |
| |
| TEST_F(SwiftShaderTest, TransformFeedback_DrawArraysInstanced) |
| { |
| Initialize(3, false); |
| |
| std::string fs = |
| R"(#version 300 es |
| in mediump vec2 vary; |
| out mediump vec4 color; |
| void main() |
| { |
| color = vec4(vary, 0.0, 1.0); |
| })"; |
| std::string vs = |
| R"(#version 300 es |
| layout(location=0) in mediump vec2 pos; |
| out mediump vec2 vary; |
| void main() |
| { |
| vary = pos; |
| gl_Position = vec4(pos, 0.0, 1.0); |
| })"; |
| |
| GLuint vert = MakeShader(vs, GL_VERTEX_SHADER); |
| GLuint frag = MakeShader(fs, GL_FRAGMENT_SHADER); |
| GLuint program = MakeProgram(vert, frag); |
| LinkProgram(program); |
| glBeginTransformFeedback(GL_POINTS); |
| glDrawArraysInstanced(GL_POINTS, 0, 1, 1); |
| |
| Uninitialize(); |
| } |
| |
| TEST_F(SwiftShaderTest, TransformFeedback_BadViewport) |
| { |
| Initialize(3, false); |
| |
| GLuint tfBuffer; |
| glGenBuffers(1, &tfBuffer); |
| glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, tfBuffer); |
| glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 1 << 12, nullptr, GL_STATIC_DRAW); |
| |
| std::string vsSource = |
| R"(#version 300 es |
| in vec4 a_position; |
| void main() |
| { |
| gl_Position = a_position; |
| })"; |
| std::string fsSource = |
| R"(#version 300 es |
| precision highp float; |
| out vec4 my_FragColor; |
| void main() |
| { |
| my_FragColor = vec4(1.0, 0.0, 0.0, 1.0); |
| })"; |
| |
| const char *varyings[] = { "gl_Position" }; |
| |
| GLuint vs = MakeShader(vsSource, GL_VERTEX_SHADER); |
| GLuint fs = MakeShader(fsSource, GL_FRAGMENT_SHADER); |
| GLuint program = MakeProgram(vs, fs); |
| |
| glTransformFeedbackVaryings(program, 1, |
| &varyings[0], GL_INTERLEAVED_ATTRIBS); |
| LinkProgram(program); |
| glUseProgram(program); |
| |
| glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, tfBuffer); |
| glBeginTransformFeedback(GL_TRIANGLES); |
| |
| GLuint primitivesWrittenQuery = 0; |
| glGenQueries(1, &primitivesWrittenQuery); |
| glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, primitivesWrittenQuery); |
| |
| glViewport(0, 10000000, 300, 300); |
| |
| GLint positionLocation = glGetAttribLocation(program, "a_position"); |
| GLfloat quadVertices[] = { |
| -1.0f, |
| 1.0f, |
| 0.5f, |
| -1.0f, |
| -1.0f, |
| 0.5f, |
| 1.0f, |
| -1.0f, |
| 0.5f, |
| -1.0f, |
| 1.0f, |
| 0.5f, |
| 1.0f, |
| -1.0f, |
| 0.5f, |
| 1.0f, |
| 1.0f, |
| 0.5f, |
| }; |
| |
| glBindBuffer(GL_ARRAY_BUFFER, 0); |
| |
| glVertexAttribPointer(positionLocation, 3, GL_FLOAT, GL_FALSE, 0, &quadVertices[0]); |
| |
| glDrawArrays(GL_TRIANGLES, 0, 6); |
| glDisableVertexAttribArray(positionLocation); |
| glVertexAttribPointer(positionLocation, 4, GL_FLOAT, GL_FALSE, 0, nullptr); |
| |
| glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN); |
| glEndTransformFeedback(); |
| |
| GLuint primitivesWritten = 0; |
| glGetQueryObjectuiv(primitivesWrittenQuery, GL_QUERY_RESULT_EXT, &primitivesWritten); |
| EXPECT_NO_GL_ERROR(); |
| |
| EXPECT_EQ(2u, primitivesWritten); |
| |
| Uninitialize(); |
| } |
| |
| // Test conditions that should result in a GL_OUT_OF_MEMORY and not crash |
| TEST_F(SwiftShaderTest, OutOfMemory) |
| { |
| // Image sizes are assumed to fit in a 32-bit signed integer by the renderer, |
| // so test that we can't create a 2+ GiB image. |
| { |
| Initialize(3, false); |
| |
| GLuint tex = 1; |
| glBindTexture(GL_TEXTURE_3D, tex); |
| |
| const int width = 0xC2; |
| const int height = 0x541; |
| const int depth = 0x404; |
| glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA32F, width, height, depth, 0, GL_RGBA, GL_FLOAT, nullptr); |
| EXPECT_GLENUM_EQ(GL_OUT_OF_MEMORY, glGetError()); |
| |
| // b/145229887: Allocating an image of exactly 1 GiB should succeed. |
| const int width8k = 8192; |
| const int height8k = 8192; |
| glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, width8k, height8k, 0, GL_RGBA, GL_FLOAT, nullptr); |
| EXPECT_NO_GL_ERROR(); |
| |
| // The spec states that the GL is in an undefined state when GL_OUT_OF_MEMORY |
| // is returned, and the context must be recreated before attempting more rendering. |
| Uninitialize(); |
| } |
| } |
| |
| TEST_F(SwiftShaderTest, ViewportBounds) |
| { |
| auto doRenderWithViewportSettings = [&](GLint x, GLint y, GLsizei w, GLsizei h) { |
| Initialize(3, false); |
| |
| std::string vs = |
| R"(#version 300 es |
| in vec4 position; |
| out float unfoldable; |
| void main() |
| { |
| unfoldable = position.x; |
| gl_Position = vec4(position.xy, 0.0, 1.0); |
| })"; |
| |
| std::string fs = |
| R"(#version 300 es |
| precision mediump float; |
| in float unfoldable; |
| out vec4 fragColor; |
| void main() |
| { |
| fragColor = vec4(1.0, 1.0, 1.0, 1.0); |
| })"; |
| |
| const ProgramHandles ph = createProgram(vs, fs); |
| |
| glUseProgram(ph.program); |
| |
| glViewport(x, y, w, h); |
| |
| drawQuad(ph.program); |
| EXPECT_NO_GL_ERROR(); |
| |
| deleteProgram(ph); |
| Uninitialize(); |
| }; |
| |
| GLsizei w = 100; |
| GLsizei h = 100; |
| GLint minPos = -2000; |
| |
| doRenderWithViewportSettings(0, 0, 0, 0); |
| doRenderWithViewportSettings(0, 0, w, h); |
| |
| // Negative positions |
| doRenderWithViewportSettings(minPos, 0, w, h); |
| doRenderWithViewportSettings(0, minPos, w, h); |
| doRenderWithViewportSettings(minPos, minPos, w, h); |
| } |
| |
| // Test using TexImage2D to define a rectangle texture |
| |
| TEST_F(SwiftShaderTest, TextureRectangle_TexImage2D) |
| { |
| Initialize(2, false); |
| |
| GLuint tex = 1; |
| glBindTexture(GL_TEXTURE_RECTANGLE_ARB, tex); |
| |
| // Defining level 0 is allowed |
| glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); |
| EXPECT_NO_GL_ERROR(); |
| |
| // Defining level other than 0 is not allowed |
| glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 1, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); |
| EXPECT_GLENUM_EQ(GL_INVALID_VALUE, glGetError()); |
| |
| GLint maxSize = 0; |
| glGetIntegerv(GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB, &maxSize); |
| |
| // Defining a texture of the max size is allowed |
| { |
| glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, maxSize, maxSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); |
| GLenum error = glGetError(); |
| ASSERT_TRUE(error == GL_NO_ERROR || error == GL_OUT_OF_MEMORY); |
| } |
| |
| // Defining a texture larger than the max size is disallowed |
| glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, maxSize + 1, maxSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); |
| EXPECT_GLENUM_EQ(GL_INVALID_VALUE, glGetError()); |
| glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, maxSize, maxSize + 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); |
| EXPECT_GLENUM_EQ(GL_INVALID_VALUE, glGetError()); |
| |
| Uninitialize(); |
| } |
| |
| // Test using CompressedTexImage2D cannot be used on a retangle texture |
| TEST_F(SwiftShaderTest, TextureRectangle_CompressedTexImage2DDisallowed) |
| { |
| Initialize(2, false); |
| |
| const char data[128] = { 0 }; |
| |
| // Control case: 2D texture |
| { |
| GLuint tex = 1; |
| glBindTexture(GL_TEXTURE_2D, tex); |
| glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, 16, 16, 0, 128, data); |
| EXPECT_NO_GL_ERROR(); |
| } |
| |
| // Rectangle textures cannot be compressed |
| { |
| GLuint tex = 2; |
| glBindTexture(GL_TEXTURE_RECTANGLE_ARB, tex); |
| glCompressedTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, 16, 16, 0, 128, data); |
| EXPECT_GLENUM_EQ(GL_INVALID_ENUM, glGetError()); |
| } |
| |
| Uninitialize(); |
| } |
| |
| // Test using TexStorage2D to define a rectangle texture (ES3) |
| TEST_F(SwiftShaderTest, TextureRectangle_TexStorage2D) |
| { |
| Initialize(3, false); |
| |
| // Defining one level is allowed |
| { |
| GLuint tex = 1; |
| glBindTexture(GL_TEXTURE_RECTANGLE_ARB, tex); |
| glTexStorage2D(GL_TEXTURE_RECTANGLE_ARB, 1, GL_RGBA8UI, 16, 16); |
| EXPECT_NO_GL_ERROR(); |
| } |
| |
| // Having more than one level is not allowed |
| { |
| GLuint tex = 2; |
| glBindTexture(GL_TEXTURE_RECTANGLE_ARB, tex); |
| // Use 5 levels because the EXT_texture_storage extension requires a mip chain all the way |
| // to a 1x1 mip. |
| glTexStorage2D(GL_TEXTURE_RECTANGLE_ARB, 5, GL_RGBA8UI, 16, 16); |
| EXPECT_GLENUM_EQ(GL_INVALID_VALUE, glGetError()); |
| } |
| |
| GLint maxSize = 0; |
| glGetIntegerv(GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB, &maxSize); |
| |
| // Defining a texture of the max size is allowed but still allow for OOM |
| { |
| GLuint tex = 3; |
| glBindTexture(GL_TEXTURE_RECTANGLE_ARB, tex); |
| glTexStorage2D(GL_TEXTURE_RECTANGLE_ARB, 1, GL_RGBA8UI, maxSize, maxSize); |
| GLenum error = glGetError(); |
| ASSERT_TRUE(error == GL_NO_ERROR || error == GL_OUT_OF_MEMORY); |
| } |
| |
| // Defining a texture larger than the max size is disallowed |
| { |
| GLuint tex = 4; |
| glBindTexture(GL_TEXTURE_RECTANGLE_ARB, tex); |
| glTexStorage2D(GL_TEXTURE_RECTANGLE_ARB, 1, GL_RGBA8UI, maxSize + 1, maxSize); |
| EXPECT_GLENUM_EQ(GL_INVALID_VALUE, glGetError()); |
| glTexStorage2D(GL_TEXTURE_RECTANGLE_ARB, 1, GL_RGBA8UI, maxSize, maxSize + 1); |
| EXPECT_GLENUM_EQ(GL_INVALID_VALUE, glGetError()); |
| } |
| |
| // Compressed formats are disallowed |
| GLuint tex = 5; |
| glBindTexture(GL_TEXTURE_RECTANGLE_ARB, tex); |
| glTexStorage2D(GL_TEXTURE_RECTANGLE_ARB, 1, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, 16, 16); |
| EXPECT_GLENUM_EQ(GL_INVALID_ENUM, glGetError()); |
| |
| Uninitialize(); |
| } |
| |
| // Test validation of disallowed texture parameters |
| TEST_F(SwiftShaderTest, TextureRectangle_TexParameterRestriction) |
| { |
| Initialize(3, false); |
| |
| GLuint tex = 1; |
| glBindTexture(GL_TEXTURE_RECTANGLE_ARB, tex); |
| |
| // Only wrap mode CLAMP_TO_EDGE is supported |
| // Wrap S |
| glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); |
| EXPECT_NO_GL_ERROR(); |
| glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_REPEAT); |
| EXPECT_GLENUM_EQ(GL_INVALID_ENUM, glGetError()); |
| glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT); |
| EXPECT_GLENUM_EQ(GL_INVALID_ENUM, glGetError()); |
| |
| // Wrap T |
| glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); |
| EXPECT_NO_GL_ERROR(); |
| glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_REPEAT); |
| EXPECT_GLENUM_EQ(GL_INVALID_ENUM, glGetError()); |
| glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT); |
| EXPECT_GLENUM_EQ(GL_INVALID_ENUM, glGetError()); |
| |
| // Min filter has to be nearest or linear |
| glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST); |
| EXPECT_NO_GL_ERROR(); |
| glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR); |
| EXPECT_NO_GL_ERROR(); |
| glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); |
| EXPECT_GLENUM_EQ(GL_INVALID_ENUM, glGetError()); |
| glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR); |
| EXPECT_GLENUM_EQ(GL_INVALID_ENUM, glGetError()); |
| glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST); |
| EXPECT_GLENUM_EQ(GL_INVALID_ENUM, glGetError()); |
| glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); |
| EXPECT_GLENUM_EQ(GL_INVALID_ENUM, glGetError()); |
| |
| // Base level has to be 0 |
| glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_BASE_LEVEL, 0); |
| EXPECT_NO_GL_ERROR(); |
| glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_BASE_LEVEL, 1); |
| EXPECT_GLENUM_EQ(GL_INVALID_OPERATION, glGetError()); |
| |
| Uninitialize(); |
| } |
| |
| // Test validation of "level" in FramebufferTexture2D |
| TEST_F(SwiftShaderTest, TextureRectangle_FramebufferTexture2DLevel) |
| { |
| Initialize(3, false); |
| |
| GLuint tex = 1; |
| glBindTexture(GL_TEXTURE_RECTANGLE_ARB, tex); |
| glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); |
| EXPECT_NO_GL_ERROR(); |
| |
| GLuint fbo = 1; |
| glBindFramebuffer(GL_FRAMEBUFFER, fbo); |
| |
| // Using level 0 of a rectangle texture is valid. |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE_ARB, tex, 0); |
| EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER)); |
| EXPECT_NO_GL_ERROR(); |
| |
| // Setting level != 0 is invalid |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE_ARB, tex, 1); |
| EXPECT_GLENUM_EQ(GL_INVALID_VALUE, glGetError()); |
| |
| Uninitialize(); |
| } |
| |
| // Test sampling from a rectangle texture |
| TEST_F(SwiftShaderTest, TextureRectangle_SamplingFromRectangle) |
| { |
| Initialize(3, false); |
| |
| GLuint tex = 1; |
| glBindTexture(GL_TEXTURE_RECTANGLE_ARB, tex); |
| EXPECT_NO_GL_ERROR(); |
| |
| unsigned char green[4] = { 0, 255, 0, 255 }; |
| glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, green); |
| EXPECT_NO_GL_ERROR(); |
| |
| const std::string vs = |
| R"(attribute vec4 position; |
| void main() |
| { |
| gl_Position = vec4(position.xy, 0.0, 1.0); |
| })"; |
| |
| const std::string fs = |
| R"(#extension GL_ARB_texture_rectangle : require |
| precision mediump float; |
| uniform sampler2DRect tex; |
| void main() |
| { |
| gl_FragColor = texture2DRect(tex, vec2(0, 0)); |
| })"; |
| |
| const ProgramHandles ph = createProgram(vs, fs); |
| |
| glUseProgram(ph.program); |
| GLint location = glGetUniformLocation(ph.program, "tex"); |
| ASSERT_NE(-1, location); |
| glUniform1i(location, 0); |
| |
| glClearColor(0.0, 0.0, 0.0, 0.0); |
| glClear(GL_COLOR_BUFFER_BIT); |
| EXPECT_NO_GL_ERROR(); |
| |
| drawQuad(ph.program, "tex"); |
| |
| deleteProgram(ph); |
| |
| expectFramebufferColor(green); |
| |
| EXPECT_NO_GL_ERROR(); |
| |
| Uninitialize(); |
| } |
| |
| // Test sampling from a rectangle texture |
| TEST_F(SwiftShaderTest, TextureRectangle_SamplingFromRectangleESSL3) |
| { |
| Initialize(3, false); |
| |
| GLuint tex = 1; |
| glBindTexture(GL_TEXTURE_RECTANGLE_ARB, tex); |
| EXPECT_NO_GL_ERROR(); |
| |
| unsigned char green[4] = { 0, 255, 0, 255 }; |
| glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, green); |
| EXPECT_NO_GL_ERROR(); |
| |
| const std::string vs = |
| R"(#version 300 es |
| in vec4 position; |
| void main() |
| { |
| gl_Position = vec4(position.xy, 0.0, 1.0); |
| })"; |
| |
| const std::string fs = |
| R"(#version 300 es |
| #extension GL_ARB_texture_rectangle : require |
| precision mediump float; |
| uniform sampler2DRect tex; |
| out vec4 fragColor; |
| void main() |
| { |
| fragColor = texture(tex, vec2(0, 0)); |
| })"; |
| |
| const ProgramHandles ph = createProgram(vs, fs); |
| |
| glUseProgram(ph.program); |
| GLint location = glGetUniformLocation(ph.program, "tex"); |
| ASSERT_NE(-1, location); |
| glUniform1i(location, 0); |
| |
| glClearColor(0.0, 0.0, 0.0, 0.0); |
| glClear(GL_COLOR_BUFFER_BIT); |
| EXPECT_NO_GL_ERROR(); |
| |
| drawQuad(ph.program, "tex"); |
| |
| deleteProgram(ph); |
| |
| expectFramebufferColor(green); |
| |
| EXPECT_NO_GL_ERROR(); |
| |
| Uninitialize(); |
| } |
| |
| // Test attaching a rectangle texture and rendering to it. |
| TEST_F(SwiftShaderTest, TextureRectangle_RenderToRectangle) |
| { |
| Initialize(3, false); |
| |
| GLuint tex = 1; |
| glBindTexture(GL_TEXTURE_RECTANGLE_ARB, tex); |
| unsigned char black[4] = { 0, 0, 0, 255 }; |
| glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, black); |
| |
| GLuint fbo = 1; |
| glBindFramebuffer(GL_FRAMEBUFFER, fbo); |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE_ARB, tex, 0); |
| EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER)); |
| EXPECT_NO_GL_ERROR(); |
| |
| // Clearing a texture is just as good as checking we can render to it, right? |
| glClearColor(0.0, 1.0, 0.0, 1.0); |
| glClear(GL_COLOR_BUFFER_BIT); |
| |
| unsigned char green[4] = { 0, 255, 0, 255 }; |
| expectFramebufferColor(green); |
| EXPECT_NO_GL_ERROR(); |
| |
| Uninitialize(); |
| } |
| |
| TEST_F(SwiftShaderTest, TextureRectangle_DefaultSamplerParameters) |
| { |
| Initialize(3, false); |
| |
| GLuint tex = 1; |
| glBindTexture(GL_TEXTURE_RECTANGLE_ARB, tex); |
| |
| GLint minFilter = 0; |
| glGetTexParameteriv(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, &minFilter); |
| EXPECT_GLENUM_EQ(GL_LINEAR, minFilter); |
| |
| GLint wrapS = 0; |
| glGetTexParameteriv(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, &wrapS); |
| EXPECT_GLENUM_EQ(GL_CLAMP_TO_EDGE, wrapS); |
| |
| GLint wrapT = 0; |
| glGetTexParameteriv(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, &wrapT); |
| EXPECT_GLENUM_EQ(GL_CLAMP_TO_EDGE, wrapT); |
| |
| Uninitialize(); |
| } |
| |
| // Test glCopyTexImage with rectangle textures (ES3) |
| TEST_F(SwiftShaderTest, TextureRectangle_CopyTexImage) |
| { |
| Initialize(3, false); |
| |
| GLuint tex = 1; |
| glBindTexture(GL_TEXTURE_RECTANGLE_ARB, tex); |
| |
| glBindFramebuffer(GL_FRAMEBUFFER, 0); |
| glClearColor(0, 1, 0, 1); |
| glClear(GL_COLOR_BUFFER_BIT); |
| EXPECT_NO_GL_ERROR(); |
| |
| // Error case: level != 0 |
| glCopyTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 1, GL_RGBA8, 0, 0, 1, 1, 0); |
| EXPECT_GLENUM_EQ(GL_INVALID_VALUE, glGetError()); |
| |
| // level = 0 works and defines the texture. |
| glCopyTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8, 0, 0, 1, 1, 0); |
| EXPECT_NO_GL_ERROR(); |
| |
| GLuint fbo = 1; |
| glBindFramebuffer(GL_FRAMEBUFFER, fbo); |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE_ARB, tex, 0); |
| |
| unsigned char green[4] = { 0, 255, 0, 255 }; |
| expectFramebufferColor(green); |
| EXPECT_NO_GL_ERROR(); |
| |
| Uninitialize(); |
| } |
| |
| // Test glCopyTexSubImage with rectangle textures (ES3) |
| TEST_F(SwiftShaderTest, TextureRectangle_CopyTexSubImage) |
| { |
| Initialize(3, false); |
| |
| GLuint tex = 1; |
| glBindTexture(GL_TEXTURE_RECTANGLE_ARB, tex); |
| unsigned char black[4] = { 0, 0, 0, 255 }; |
| glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, black); |
| |
| glBindFramebuffer(GL_FRAMEBUFFER, 0); |
| glClearColor(0, 1, 0, 1); |
| glClear(GL_COLOR_BUFFER_BIT); |
| EXPECT_NO_GL_ERROR(); |
| |
| // Error case: level != 0 |
| glCopyTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 1, 0, 0, 0, 0, 1, 1); |
| EXPECT_GLENUM_EQ(GL_INVALID_VALUE, glGetError()); |
| |
| // level = 0 works and defines the texture. |
| glCopyTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0, 0, 0, 1, 1); |
| EXPECT_NO_GL_ERROR(); |
| |
| GLuint fbo = 1; |
| glBindFramebuffer(GL_FRAMEBUFFER, fbo); |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE_ARB, tex, 0); |
| |
| unsigned char green[4] = { 0, 255, 0, 255 }; |
| expectFramebufferColor(green); |
| EXPECT_NO_GL_ERROR(); |
| |
| Uninitialize(); |
| } |
| |
| TEST_F(SwiftShaderTest, BlitTest) |
| { |
| Initialize(3, false); |
| |
| GLuint fbos[] = { 0, 0 }; |
| glGenFramebuffers(2, fbos); |
| |
| glBindFramebuffer(GL_READ_FRAMEBUFFER, fbos[0]); |
| glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbos[1]); |
| |
| GLuint textures[] = { 0, 0 }; |
| glGenTextures(2, textures); |
| |
| glBindTexture(GL_TEXTURE_2D, textures[0]); |
| unsigned char red[4][4] = { |
| { 255, 0, 0, 255 }, |
| { 255, 0, 0, 255 }, |
| { 255, 0, 0, 255 }, |
| { 255, 0, 0, 255 } |
| }; |
| glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, red); |
| EXPECT_NO_GL_ERROR(); |
| |
| glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textures[0], 0); |
| EXPECT_NO_GL_ERROR(); |
| |
| glBindTexture(GL_TEXTURE_2D, textures[1]); |
| unsigned char black[4][4] = { |
| { 0, 0, 0, 255 }, |
| { 0, 0, 0, 255 }, |
| { 0, 0, 0, 255 }, |
| { 0, 0, 0, 255 } |
| }; |
| glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, black); |
| EXPECT_NO_GL_ERROR(); |
| glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textures[1], 0); |
| |
| // Test that glBlitFramebuffer works as expected for the normal case. |
| glBlitFramebuffer(0, 0, 1, 1, 0, 0, 1, 1, GL_COLOR_BUFFER_BIT, GL_NEAREST); |
| EXPECT_NO_GL_ERROR(); |
| EXPECT_EQ(red[0][1], black[0][1]); |
| |
| // Check that glBlitFramebuffer doesn't crash with ugly input. |
| const int big = (int)2e9; |
| const int small = 200; |
| const int neg_small = -small; |
| const int neg_big = -big; |
| int max = 0x7fffffff; |
| int data[][8] = { |
| // sx0, sy0, sx1, sy1, dx0, dy0, dx1, dy1 |
| { 0, 0, 0, 0, 0, 0, 0, 0 }, |
| { -1, -1, -1, -1, -1, -1, -1, -1 }, |
| { 1, 1, 1, 1, 1, 1, 1, 1 }, |
| { -1, -1, 1, 1, -1, -1, 1, 1 }, |
| { 0, 0, 127, (int)2e9, 10, 10, 200, 200 }, |
| { -2, -2, 127, 2147483470, 10, 10, 200, 200 }, |
| { big, small, small, big, big, big, small, small }, |
| { neg_small, small, neg_small, neg_small, neg_small, big, small }, |
| { big, big - 1, big - 2, big - 3, big - 4, big - 5, big - 6, big - 7 }, |
| { big, neg_big, neg_big, big, small, big, 0, neg_small }, |
| { 323479648, 21931, 1769809195, 32733, 0, 0, -161640504, 32766 }, |
| { 0, 0, max, max, 0, 0, 8, 8 }, |
| { 0, 0, 8, 8, 0, 0, max, max }, |
| { 0, 0, max, max, 0, 0, max, max }, |
| { -1, -1, max, max, 0, 0, 8, 8 }, |
| { 0, 0, 8, 8, -1, -1, max, max }, |
| { -1, -1, max, max, -1, -1, max, max }, |
| { -max - 1, -max - 1, max, max, -max - 1, -max - 1, max, max } |
| }; |
| |
| for(int i = 0; i < (int)(sizeof(data) / sizeof(data[0])); i++) |
| { |
| glBlitFramebuffer( |
| data[i][0], data[i][1], data[i][2], data[i][3], |
| data[i][4], data[i][5], data[i][6], data[i][7], |
| GL_COLOR_BUFFER_BIT, GL_NEAREST); |
| // Ignore error state, just make sure that we don't crash on these inputs. |
| } |
| |
| // Clear the error state before uninitializing test. |
| glGetError(); |
| |
| glDeleteFramebuffers(2, fbos); |
| glDeleteTextures(2, textures); |
| Uninitialize(); |
| } |
| |
| TEST_F(SwiftShaderTest, InvalidEnum_TexImage2D) |
| { |
| Initialize(3, false); |
| |
| const GLenum invalidTarget = GL_TEXTURE_3D; |
| |
| glTexImage2D(invalidTarget, 0, GL_R11F_G11F_B10F, 256, 256, 0, GL_RGB, GL_UNSIGNED_INT_10F_11F_11F_REV, nullptr); |
| EXPECT_GLENUM_EQ(GL_INVALID_ENUM, glGetError()); |
| |
| float pixels[3] = { 0.0f, 0.0f, 0.0f }; |
| glTexSubImage2D(invalidTarget, 0, 0, 0, 1, 1, GL_RGB, GL_FLOAT, pixels); |
| EXPECT_GLENUM_EQ(GL_INVALID_ENUM, glGetError()); |
| |
| glCopyTexImage2D(invalidTarget, 0, GL_RGB, 2, 6, 8, 8, 0); |
| EXPECT_GLENUM_EQ(GL_INVALID_ENUM, glGetError()); |
| |
| glCopyTexSubImage2D(invalidTarget, 0, 0, 0, 0, 0, 1, 1); |
| EXPECT_GLENUM_EQ(GL_INVALID_ENUM, glGetError()); |
| |
| const char data[128] = { 0 }; |
| glCompressedTexImage2D(invalidTarget, 0, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, 16, 16, 0, 128, data); |
| EXPECT_GLENUM_EQ(GL_INVALID_ENUM, glGetError()); |
| |
| glCompressedTexSubImage2D(invalidTarget, 0, 0, 0, 0, 0, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 0, 0); |
| EXPECT_GLENUM_EQ(GL_INVALID_ENUM, glGetError()); |
| |
| Uninitialize(); |
| } |
| |
| TEST_F(SwiftShaderTest, CompilerLimits_DeepNestedIfs) |
| { |
| std::string body = "return 1.0;"; |
| for(int i = 0; i < 16; i++) |
| { |
| body = " if (f > " + std::to_string(i * 0.1f) + ") {\n" + body + "}\n"; |
| } |
| |
| checkCompiles( |
| "float F(float f) {\n" + body + " return 0.0f;\n}\n"); |
| } |
| |
| TEST_F(SwiftShaderTest, CompilerLimits_DeepNestedSwitches) |
| { |
| std::string body = "return 1.0;"; |
| for(int i = 0; i < 16; i++) |
| { |
| body = " switch (int(f)) {\n case 1:\n f *= 2.0;\n" + body + "}\n"; |
| } |
| |
| checkCompiles("float F(float f) {\n" + body + " return 0.0f;\n}\n"); |
| } |
| |
| TEST_F(SwiftShaderTest, CompilerLimits_DeepNestedLoops) |
| { |
| std::string loops = "f = f + f * 2.0;"; |
| for(int i = 0; i < 16; i++) |
| { |
| auto it = "l" + std::to_string(i); |
| loops = " for (int " + it + " = 0; " + it + " < i; " + it + "++) {\n" + loops + "}\n"; |
| } |
| |
| checkCompiles( |
| "float F(float f) {\n" |
| " int i = (f > 0.0) ? 1 : 0;\n" + |
| loops + |
| " return f;\n" |
| "}\n"); |
| } |
| |
| TEST_F(SwiftShaderTest, CompilerLimits_DeepNestedCalls) |
| { |
| std::string funcs = "float E(float f) { return f * 2.0f; }\n"; |
| std::string last = "E"; |
| for(int i = 0; i < 16; i++) |
| { |
| std::string f = "C" + std::to_string(i); |
| funcs += "float " + f + "(float f) { return " + last + "(f) + 1.0f; }\n"; |
| last = f; |
| } |
| |
| checkCompiles(funcs + |
| "float F(float f) { return " + last + "(f); }\n"); |
| } |
| |
| TEST_F(SwiftShaderTest, CompilerLimits_ManyCallSites) |
| { |
| std::string calls; |
| for(int i = 0; i < 256; i++) |
| { |
| calls += " f += C(f);\n"; |
| } |
| |
| checkCompiles( |
| "float C(float f) { return f * 2.0f; }\n" |
| "float F(float f) {\n" + |
| calls + " return f;\n}\n"); |
| } |
| |
| TEST_F(SwiftShaderTest, CompilerLimits_DeepNestedCallsInUnusedFunction) |
| { |
| std::string funcs = "float E(float f) { return f * 2.0f; }\n"; |
| std::string last = "E"; |
| for(int i = 0; i < 16; i++) |
| { |
| std::string f = "C" + std::to_string(i); |
| funcs += "float " + f + "(float f) { return " + last + "(f) + 1.0f; }\n"; |
| last = f; |
| } |
| |
| checkCompiles(funcs + |
| "float F(float f) { return f; }\n"); |
| } |
| |
| // Test that the compiler correctly handles functions being stripped. |
| // The frontend will strip the Dead functions, but may keep the their function |
| // labels reserved. This produces labels that are greater than the number of |
| // live functions. |
| TEST_F(SwiftShaderTest, CompilerLimits_SparseLabels) |
| { |
| checkCompiles( |
| R"(void Dead1() {} |
| void Dead2() {} |
| void Dead3() {} |
| void Dead4() {} |
| void Dead5() { Dead1(); Dead2(); Dead3(); Dead4(); } |
| float F(float f) { for(int i = 0; i < -1; ++i) { Dead5(); } return f; })"); |
| } |
| |
| // Test that the compiler doesn't compile arrays larger than |
| // GL_MAX_{VERTEX/FRAGMENT}_UNIFORM_VECTOR. |
| TEST_F(SwiftShaderTest, CompilerLimits_ArraySize) |
| { |
| checkCompileFails( |
| R"(uniform float u_var[100000000]; |
| float F(float f) { return u_var[2]; })"); |
| checkCompileFails( |
| R"(struct structType { mediump sampler2D m0; mediump samplerCube m1; }; |
| uniform structType u_var[100000000]; |
| float F(float f) { return texture(u_var[2].m1, vec3(0.0)), vec4(0.26, 1.72, 0.60, 0.12).x; })"); |
| } |
| |
| // Test that the compiler rejects negations of things that can't be negated. |
| TEST_F(SwiftShaderTest, BadNegation) |
| { |
| checkCompileFails( |
| R"(uniform samplerCube m; |
| float F (float f) { vec4 ret = texture(-m, vec3(f)); return ret.x; })"); |
| checkCompileFails( |
| R"(uniform sampler2D m[9]; |
| vec4 G (sampler2D X[9]) { return texture(X[0], vec2(0.0f)); } |
| float F (float f) { vec4 ret = G(-m); return ret.x; })"); |
| checkCompileFails( |
| R"(struct structType { int a; float b; }; |
| uniform structType m; |
| float F (float f) { structType n = -m; return f; })"); |
| checkCompileFails( |
| R"(struct structType { int a; float b; }; |
| uniform structType m[4]; |
| float F (float f) { structType n[4] = -m; return f; })"); |
| checkCompileFails( |
| R"(uniform float m[4]; |
| float G (float f[4]) { return f[0]; } |
| float F (float f) { return G(-m); })"); |
| } |
| |
| TEST_F(SwiftShaderTest, SwitchDefaultOnly) |
| { |
| checkCompiles(R"( |
| float F (float f) { |
| switch (0u) { |
| default: |
| return -f; |
| } |
| return f; |
| })"); |
| } |
| |
| #ifndef EGL_ANGLE_iosurface_client_buffer |
| # define EGL_ANGLE_iosurface_client_buffer 1 |
| # define EGL_IOSURFACE_ANGLE 0x3454 |
| # define EGL_IOSURFACE_PLANE_ANGLE 0x345A |
| # define EGL_TEXTURE_RECTANGLE_ANGLE 0x345B |
| # define EGL_TEXTURE_TYPE_ANGLE 0x345C |
| # define EGL_TEXTURE_INTERNAL_FORMAT_ANGLE 0x345D |
| #endif /* EGL_ANGLE_iosurface_client_buffer */ |
| |
| #if defined(__APPLE__) |
| # include <CoreFoundation/CoreFoundation.h> |
| # include <IOSurface/IOSurface.h> |
| |
| namespace { |
| void AddIntegerValue(CFMutableDictionaryRef dictionary, const CFStringRef key, int32_t value) |
| { |
| CFNumberRef number = CFNumberCreate(nullptr, kCFNumberSInt32Type, &value); |
| CFDictionaryAddValue(dictionary, key, number); |
| CFRelease(number); |
| } |
| } // anonymous namespace |
| |
| class EGLClientBufferWrapper |
| { |
| public: |
| EGLClientBufferWrapper(int width = 1, int height = 1) |
| { |
| // Create a 1 by 1 BGRA8888 IOSurface |
| ioSurface = nullptr; |
| |
| CFMutableDictionaryRef dict = CFDictionaryCreateMutable( |
| kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); |
| AddIntegerValue(dict, kIOSurfaceWidth, width); |
| AddIntegerValue(dict, kIOSurfaceHeight, height); |
| AddIntegerValue(dict, kIOSurfacePixelFormat, 'BGRA'); |
| AddIntegerValue(dict, kIOSurfaceBytesPerElement, 4); |
| |
| ioSurface = IOSurfaceCreate(dict); |
| CFRelease(dict); |
| |
| EXPECT_NE(nullptr, ioSurface); |
| } |
| |
| ~EGLClientBufferWrapper() |
| { |
| IOSurfaceUnlock(ioSurface, kIOSurfaceLockReadOnly, nullptr); |
| |
| CFRelease(ioSurface); |
| } |
| |
| EGLClientBuffer getClientBuffer() const |
| { |
| return ioSurface; |
| } |
| |
| const unsigned char *lockColor() |
| { |
| IOSurfaceLock(ioSurface, kIOSurfaceLockReadOnly, nullptr); |
| return reinterpret_cast<const unsigned char *>(IOSurfaceGetBaseAddress(ioSurface)); |
| } |
| |
| void unlockColor() |
| { |
| IOSurfaceUnlock(ioSurface, kIOSurfaceLockReadOnly, nullptr); |
| } |
| |
| void writeColor(void *data, size_t dataSize) |
| { |
| // Write the data to the IOSurface |
| IOSurfaceLock(ioSurface, 0, nullptr); |
| memcpy(IOSurfaceGetBaseAddress(ioSurface), data, dataSize); |
| IOSurfaceUnlock(ioSurface, 0, nullptr); |
| } |
| |
| private: |
| IOSurfaceRef ioSurface; |
| }; |
| |
| #else // __APPLE__ |
| |
| class EGLClientBufferWrapper |
| { |
| public: |
| EGLClientBufferWrapper(int width = 1, int height = 1) |
| { |
| clientBuffer = new unsigned char[4 * width * height]; |
| } |
| |
| ~EGLClientBufferWrapper() |
| { |
| delete[] clientBuffer; |
| } |
| |
| EGLClientBuffer getClientBuffer() const |
| { |
| return clientBuffer; |
| } |
| |
| const unsigned char *lockColor() |
| { |
| return clientBuffer; |
| } |
| |
| void unlockColor() |
| { |
| } |
| |
| void writeColor(void *data, size_t dataSize) |
| { |
| memcpy(clientBuffer, data, dataSize); |
| } |
| |
| private: |
| unsigned char *clientBuffer; |
| }; |
| |
| #endif |
| |
| class IOSurfaceClientBufferTest : public SwiftShaderTest |
| { |
| protected: |
| EGLSurface createIOSurfacePbuffer(EGLClientBuffer buffer, EGLint width, EGLint height, EGLint plane, GLenum internalFormat, GLenum type) const |
| { |
| // Make a PBuffer from it using the EGL_ANGLE_iosurface_client_buffer extension |
| const EGLint attribs[] = { |
| EGL_WIDTH, |
| width, |
| EGL_HEIGHT, |
| height, |
| EGL_IOSURFACE_PLANE_ANGLE, |
| plane, |
| EGL_TEXTURE_TARGET, |
| EGL_TEXTURE_RECTANGLE_ANGLE, |
| EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, |
| (EGLint)internalFormat, |
| EGL_TEXTURE_FORMAT, |
| EGL_TEXTURE_RGBA, |
| EGL_TEXTURE_TYPE_ANGLE, |
| (EGLint)type, |
| EGL_NONE, |
| EGL_NONE, |
| }; |
| |
| EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, buffer, getConfig(), attribs); |
| EXPECT_NE(EGL_NO_SURFACE, pbuffer); |
| return pbuffer; |
| } |
| |
| void bindIOSurfaceToTexture(EGLClientBuffer buffer, EGLint width, EGLint height, EGLint plane, GLenum internalFormat, GLenum type, EGLSurface *pbuffer, GLuint *texture) const |
| { |
| *pbuffer = createIOSurfacePbuffer(buffer, width, height, plane, internalFormat, type); |
| |
| // Bind the pbuffer |
| glBindTexture(GL_TEXTURE_RECTANGLE_ARB, *texture); |
| EGLBoolean result = eglBindTexImage(getDisplay(), *pbuffer, EGL_BACK_BUFFER); |
| EXPECT_EQ((EGLBoolean)EGL_TRUE, result); |
| EXPECT_NO_EGL_ERROR(); |
| } |
| |
| void doClear(GLenum internalFormat, bool clearToZero) |
| { |
| if(internalFormat == GL_R16UI) |
| { |
| GLuint color = clearToZero ? 0 : 257; |
| glClearBufferuiv(GL_COLOR, 0, &color); |
| EXPECT_NO_GL_ERROR(); |
| } |
| else |
| { |
| glClearColor(clearToZero ? 0.0f : 1.0f / 255.0f, |
| clearToZero ? 0.0f : 2.0f / 255.0f, |
| clearToZero ? 0.0f : 3.0f / 255.0f, |
| clearToZero ? 0.0f : 4.0f / 255.0f); |
| EXPECT_NO_GL_ERROR(); |
| glClear(GL_COLOR_BUFFER_BIT); |
| EXPECT_NO_GL_ERROR(); |
| } |
| } |
| |
| void doClearTest(EGLClientBufferWrapper &clientBufferWrapper, GLenum internalFormat, GLenum type, void *data, size_t dataSize) |
| { |
| ASSERT_TRUE(dataSize <= 4); |
| |
| // Bind the IOSurface to a texture and clear it. |
| GLuint texture = 1; |
| EGLSurface pbuffer; |
| bindIOSurfaceToTexture(clientBufferWrapper.getClientBuffer(), 1, 1, 0, internalFormat, type, &pbuffer, &texture); |
| |
| // glClear the pbuffer |
| GLuint fbo = 2; |
| glBindFramebuffer(GL_FRAMEBUFFER, fbo); |
| EXPECT_NO_GL_ERROR(); |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE_ARB, texture, 0); |
| EXPECT_NO_GL_ERROR(); |
| EXPECT_GLENUM_EQ(glCheckFramebufferStatus(GL_FRAMEBUFFER), GL_FRAMEBUFFER_COMPLETE); |
| EXPECT_NO_GL_ERROR(); |
| |
| doClear(internalFormat, false); |
| |
| // Unbind pbuffer and check content. |
| EGLBoolean result = eglReleaseTexImage(getDisplay(), pbuffer, EGL_BACK_BUFFER); |
| EXPECT_EQ((EGLBoolean)EGL_TRUE, result); |
| EXPECT_NO_EGL_ERROR(); |
| |
| const unsigned char *color = clientBufferWrapper.lockColor(); |
| for(size_t i = 0; i < dataSize; ++i) |
| { |
| EXPECT_EQ(color[i], reinterpret_cast<unsigned char *>(data)[i]); |
| } |
| |
| result = eglDestroySurface(getDisplay(), pbuffer); |
| EXPECT_EQ((EGLBoolean)EGL_TRUE, result); |
| EXPECT_NO_EGL_ERROR(); |
| } |
| |
| void doSampleTest(EGLClientBufferWrapper &clientBufferWrapper, GLenum internalFormat, GLenum type, void *data, size_t dataSize) |
| { |
| ASSERT_TRUE(dataSize <= 4); |
| |
| clientBufferWrapper.writeColor(data, dataSize); |
| |
| // Bind the IOSurface to a texture and clear it. |
| GLuint texture = 1; |
| EGLSurface pbuffer; |
| bindIOSurfaceToTexture(clientBufferWrapper.getClientBuffer(), 1, 1, 0, internalFormat, type, &pbuffer, &texture); |
| |
| doClear(internalFormat, true); |
| |
| // Create program and draw quad using it |
| const std::string vs = |
| R"(attribute vec4 position; |
| void main() |
| { |
| gl_Position = vec4(position.xy, 0.0, 1.0); |
| })"; |
| |
| const std::string fs = |
| R"(#extension GL_ARB_texture_rectangle : require |
| precision mediump float; |
| uniform sampler2DRect tex; |
| void main() |
| { |
| gl_FragColor = texture2DRect(tex, vec2(0, 0)); |
| })"; |
| |
| const ProgramHandles ph = createProgram(vs, fs); |
| |
| drawQuad(ph.program, "tex"); |
| |
| deleteProgram(ph); |
| EXPECT_NO_GL_ERROR(); |
| |
| // Unbind pbuffer and check content. |
| EGLBoolean result = eglReleaseTexImage(getDisplay(), pbuffer, EGL_BACK_BUFFER); |
| EXPECT_EQ((EGLBoolean)EGL_TRUE, result); |
| EXPECT_NO_EGL_ERROR(); |
| |
| const unsigned char *color = clientBufferWrapper.lockColor(); |
| for(size_t i = 0; i < dataSize; ++i) |
| { |
| EXPECT_EQ(color[i], reinterpret_cast<unsigned char *>(data)[i]); |
| } |
| clientBufferWrapper.unlockColor(); |
| } |
| }; |
| |
| // Tests for the EGL_ANGLE_iosurface_client_buffer extension |
| TEST_F(IOSurfaceClientBufferTest, RenderToBGRA8888IOSurface) |
| { |
| Initialize(3, false); |
| |
| { // EGLClientBufferWrapper scope |
| EGLClientBufferWrapper clientBufferWrapper; |
| unsigned char data[4] = { 3, 2, 1, 4 }; |
| doClearTest(clientBufferWrapper, GL_BGRA_EXT, GL_UNSIGNED_BYTE, data, 4); |
| } // end of EGLClientBufferWrapper scope |
| |
| Uninitialize(); |
| } |
| |
| // Test reading from BGRA8888 IOSurfaces |
| TEST_F(IOSurfaceClientBufferTest, ReadFromBGRA8888IOSurface) |
| { |
| Initialize(3, false); |
| |
| { // EGLClientBufferWrapper scope |
| EGLClientBufferWrapper clientBufferWrapper; |
| unsigned char data[4] = { 3, 2, 1, 4 }; |
| doSampleTest(clientBufferWrapper, GL_BGRA_EXT, GL_UNSIGNED_BYTE, data, 4); |
| } // end of EGLClientBufferWrapper scope |
| |
| Uninitialize(); |
| } |
| |
| // Test using RGBX8888 IOSurfaces for rendering |
| TEST_F(IOSurfaceClientBufferTest, RenderToRGBX8888IOSurface) |
| { |
| Initialize(3, false); |
| |
| { // EGLClientBufferWrapper scope |
| EGLClientBufferWrapper clientBufferWrapper; |
| unsigned char data[3] = { 1, 2, 3 }; |
| doClearTest(clientBufferWrapper, GL_RGB, GL_UNSIGNED_BYTE, data, 3); |
| } // end of EGLClientBufferWrapper scope |
| |
| Uninitialize(); |
| } |
| |
| // Test reading from RGBX8888 IOSurfaces |
| TEST_F(IOSurfaceClientBufferTest, ReadFromRGBX8888IOSurface) |
| { |
| Initialize(3, false); |
| |
| { // EGLClientBufferWrapper scope |
| EGLClientBufferWrapper clientBufferWrapper; |
| unsigned char data[3] = { 1, 2, 3 }; |
| doSampleTest(clientBufferWrapper, GL_RGB, GL_UNSIGNED_BYTE, data, 3); |
| } // end of EGLClientBufferWrapper scope |
| |
| Uninitialize(); |
| } |
| |
| // Test using RG88 IOSurfaces for rendering |
| TEST_F(IOSurfaceClientBufferTest, RenderToRG88IOSurface) |
| { |
| Initialize(3, false); |
| |
| { // EGLClientBufferWrapper scope |
| EGLClientBufferWrapper clientBufferWrapper; |
| unsigned char data[2] = { 1, 2 }; |
| doClearTest(clientBufferWrapper, GL_RG, GL_UNSIGNED_BYTE, data, 2); |
| } // end of EGLClientBufferWrapper scope |
| |
| Uninitialize(); |
| } |
| |
| // Test reading from RG88 IOSurfaces |
| TEST_F(IOSurfaceClientBufferTest, ReadFromRG88IOSurface) |
| { |
| Initialize(3, false); |
| |
| { // EGLClientBufferWrapper scope |
| EGLClientBufferWrapper clientBufferWrapper; |
| unsigned char data[2] = { 1, 2 }; |
| doSampleTest(clientBufferWrapper, GL_RG, GL_UNSIGNED_BYTE, data, 2); |
| } // end of EGLClientBufferWrapper scope |
| |
| Uninitialize(); |
| } |
| |
| // Test using R8 IOSurfaces for rendering |
| TEST_F(IOSurfaceClientBufferTest, RenderToR8IOSurface) |
| { |
| Initialize(3, false); |
| |
| { // EGLClientBufferWrapper scope |
| EGLClientBufferWrapper clientBufferWrapper; |
| unsigned char data[1] = { 1 }; |
| doClearTest(clientBufferWrapper, GL_RED, GL_UNSIGNED_BYTE, data, 1); |
| } // end of EGLClientBufferWrapper scope |
| |
| Uninitialize(); |
| } |
| |
| // Test reading from R8 IOSurfaces |
| TEST_F(IOSurfaceClientBufferTest, ReadFromR8IOSurface) |
| { |
| Initialize(3, false); |
| |
| { // EGLClientBufferWrapper scope |
| EGLClientBufferWrapper clientBufferWrapper; |
| unsigned char data[1] = { 1 }; |
| doSampleTest(clientBufferWrapper, GL_RED, GL_UNSIGNED_BYTE, data, 1); |
| } // end of EGLClientBufferWrapper scope |
| |
| Uninitialize(); |
| } |
| |
| // Test using R16 IOSurfaces for rendering |
| TEST_F(IOSurfaceClientBufferTest, RenderToR16IOSurface) |
| { |
| Initialize(3, false); |
| |
| { // EGLClientBufferWrapper scope |
| EGLClientBufferWrapper clientBufferWrapper; |
| uint16_t data[1] = { 257 }; |
| doClearTest(clientBufferWrapper, GL_R16UI, GL_UNSIGNED_SHORT, data, 2); |
| } // end of EGLClientBufferWrapper scope |
| |
| Uninitialize(); |
| } |
| |
| // Test reading from R8 IOSurfaces |
| TEST_F(IOSurfaceClientBufferTest, ReadFromR16IOSurface) |
| { |
| Initialize(3, false); |
| |
| { // EGLClientBufferWrapper scope |
| EGLClientBufferWrapper clientBufferWrapper; |
| uint16_t data[1] = { 257 }; |
| doSampleTest(clientBufferWrapper, GL_R16UI, GL_UNSIGNED_SHORT, data, 1); |
| } // end of EGLClientBufferWrapper scope |
| |
| Uninitialize(); |
| } |
| |
| // Test the validation errors for missing attributes for eglCreatePbufferFromClientBuffer with |
| // IOSurface |
| TEST_F(IOSurfaceClientBufferTest, NegativeValidationMissingAttributes) |
| { |
| Initialize(3, false); |
| |
| { |
| EGLClientBufferWrapper clientBufferWrapper(10, 10); |
| |
| // Success case |
| { |
| const EGLint attribs[] = { |
| EGL_WIDTH, |
| 10, |
| EGL_HEIGHT, |
| 10, |
| EGL_IOSURFACE_PLANE_ANGLE, |
| 0, |
| EGL_TEXTURE_TARGET, |
| EGL_TEXTURE_RECTANGLE_ANGLE, |
| EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, |
| GL_BGRA_EXT, |
| EGL_TEXTURE_FORMAT, |
| EGL_TEXTURE_RGBA, |
| EGL_TEXTURE_TYPE_ANGLE, |
| GL_UNSIGNED_BYTE, |
| EGL_NONE, |
| EGL_NONE, |
| }; |
| |
| EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs); |
| EXPECT_NE(EGL_NO_SURFACE, pbuffer); |
| |
| EGLBoolean result = eglDestroySurface(getDisplay(), pbuffer); |
| EXPECT_EQ((EGLBoolean)EGL_TRUE, result); |
| EXPECT_NO_EGL_ERROR(); |
| } |
| |
| // Missing EGL_WIDTH |
| { |
| const EGLint attribs[] = { |
| EGL_HEIGHT, |
| 10, |
| EGL_IOSURFACE_PLANE_ANGLE, |
| 0, |
| EGL_TEXTURE_TARGET, |
| EGL_TEXTURE_RECTANGLE_ANGLE, |
| EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, |
| GL_BGRA_EXT, |
| EGL_TEXTURE_FORMAT, |
| EGL_TEXTURE_RGBA, |
| EGL_TEXTURE_TYPE_ANGLE, |
| GL_UNSIGNED_BYTE, |
| EGL_NONE, |
| EGL_NONE, |
| }; |
| |
| EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs); |
| EXPECT_EQ(EGL_NO_SURFACE, pbuffer); |
| EXPECT_EQ(EGL_BAD_PARAMETER, eglGetError()); |
| } |
| |
| // Missing EGL_HEIGHT |
| { |
| const EGLint attribs[] = { |
| EGL_WIDTH, |
| 10, |
| EGL_IOSURFACE_PLANE_ANGLE, |
| 0, |
| EGL_TEXTURE_TARGET, |
| EGL_TEXTURE_RECTANGLE_ANGLE, |
| EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, |
| GL_BGRA_EXT, |
| EGL_TEXTURE_FORMAT, |
| EGL_TEXTURE_RGBA, |
| EGL_TEXTURE_TYPE_ANGLE, |
| GL_UNSIGNED_BYTE, |
| EGL_NONE, |
| EGL_NONE, |
| }; |
| |
| EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs); |
| EXPECT_EQ(EGL_NO_SURFACE, pbuffer); |
| EXPECT_EQ(EGL_BAD_PARAMETER, eglGetError()); |
| } |
| |
| // Missing EGL_IOSURFACE_PLANE_ANGLE |
| { |
| const EGLint attribs[] = { |
| EGL_WIDTH, |
| 10, |
| EGL_HEIGHT, |
| 10, |
| EGL_TEXTURE_TARGET, |
| EGL_TEXTURE_RECTANGLE_ANGLE, |
| EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, |
| GL_BGRA_EXT, |
| EGL_TEXTURE_FORMAT, |
| EGL_TEXTURE_RGBA, |
| EGL_TEXTURE_TYPE_ANGLE, |
| GL_UNSIGNED_BYTE, |
| EGL_NONE, |
| EGL_NONE, |
| }; |
| |
| EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs); |
| EXPECT_EQ(EGL_NO_SURFACE, pbuffer); |
| EXPECT_EQ(EGL_BAD_PARAMETER, eglGetError()); |
| } |
| |
| // Missing EGL_TEXTURE_TARGET - EGL_BAD_MATCH from the base spec of |
| // eglCreatePbufferFromClientBuffer |
| { |
| const EGLint attribs[] = { |
| EGL_WIDTH, |
| 10, |
| EGL_HEIGHT, |
| 10, |
| EGL_IOSURFACE_PLANE_ANGLE, |
| 0, |
| EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, |
| GL_BGRA_EXT, |
| EGL_TEXTURE_FORMAT, |
| EGL_TEXTURE_RGBA, |
| EGL_TEXTURE_TYPE_ANGLE, |
| GL_UNSIGNED_BYTE, |
| EGL_NONE, |
| EGL_NONE, |
| }; |
| |
| EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs); |
| EXPECT_EQ(EGL_NO_SURFACE, pbuffer); |
| EXPECT_EQ(EGL_BAD_MATCH, eglGetError()); |
| } |
| |
| // Missing EGL_TEXTURE_INTERNAL_FORMAT_ANGLE |
| { |
| const EGLint attribs[] = { |
| EGL_WIDTH, |
| 10, |
| EGL_HEIGHT, |
| 10, |
| EGL_IOSURFACE_PLANE_ANGLE, |
| 0, |
| EGL_TEXTURE_TARGET, |
| EGL_TEXTURE_RECTANGLE_ANGLE, |
| EGL_TEXTURE_FORMAT, |
| EGL_TEXTURE_RGBA, |
| EGL_TEXTURE_TYPE_ANGLE, |
| GL_UNSIGNED_BYTE, |
| EGL_NONE, |
| EGL_NONE, |
| }; |
| |
| EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs); |
| EXPECT_EQ(EGL_NO_SURFACE, pbuffer); |
| EXPECT_EQ(EGL_BAD_PARAMETER, eglGetError()); |
| } |
| |
| // Missing EGL_TEXTURE_FORMAT - EGL_BAD_MATCH from the base spec of |
| // eglCreatePbufferFromClientBuffer |
| { |
| const EGLint attribs[] = { |
| EGL_WIDTH, |
| 10, |
| EGL_HEIGHT, |
| 10, |
| EGL_IOSURFACE_PLANE_ANGLE, |
| 0, |
| EGL_TEXTURE_TARGET, |
| EGL_TEXTURE_RECTANGLE_ANGLE, |
| EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, |
| GL_BGRA_EXT, |
| EGL_TEXTURE_TYPE_ANGLE, |
| GL_UNSIGNED_BYTE, |
| EGL_NONE, |
| EGL_NONE, |
| }; |
| |
| EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs); |
| EXPECT_EQ(EGL_NO_SURFACE, pbuffer); |
| EXPECT_EQ(EGL_BAD_MATCH, eglGetError()); |
| } |
| |
| // Missing EGL_TEXTURE_TYPE_ANGLE |
| { |
| const EGLint attribs[] = { |
| EGL_WIDTH, |
| 10, |
| EGL_HEIGHT, |
| 10, |
| EGL_IOSURFACE_PLANE_ANGLE, |
| 0, |
| EGL_TEXTURE_TARGET, |
| EGL_TEXTURE_RECTANGLE_ANGLE, |
| EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, |
| GL_BGRA_EXT, |
| EGL_TEXTURE_FORMAT, |
| EGL_TEXTURE_RGBA, |
| EGL_NONE, |
| EGL_NONE, |
| }; |
| |
| EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs); |
| EXPECT_EQ(EGL_NO_SURFACE, pbuffer); |
| EXPECT_EQ(EGL_BAD_PARAMETER, eglGetError()); |
| } |
| } |
| |
| Uninitialize(); |
| } |
| |
| // Test the validation errors for bad parameters for eglCreatePbufferFromClientBuffer with IOSurface |
| TEST_F(IOSurfaceClientBufferTest, NegativeValidationBadAttributes) |
| { |
| Initialize(3, false); |
| |
| { |
| EGLClientBufferWrapper clientBufferWrapper(10, 10); |
| |
| // Success case |
| { |
| const EGLint attribs[] = { |
| EGL_WIDTH, |
| 10, |
| EGL_HEIGHT, |
| 10, |
| EGL_IOSURFACE_PLANE_ANGLE, |
| 0, |
| EGL_TEXTURE_TARGET, |
| EGL_TEXTURE_RECTANGLE_ANGLE, |
| EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, |
| GL_BGRA_EXT, |
| EGL_TEXTURE_FORMAT, |
| EGL_TEXTURE_RGBA, |
| EGL_TEXTURE_TYPE_ANGLE, |
| GL_UNSIGNED_BYTE, |
| EGL_NONE, |
| EGL_NONE, |
| }; |
| |
| EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs); |
| EXPECT_NE(EGL_NO_SURFACE, pbuffer); |
| |
| EGLBoolean result = eglDestroySurface(getDisplay(), pbuffer); |
| EXPECT_EQ((EGLBoolean)EGL_TRUE, result); |
| EXPECT_NO_EGL_ERROR(); |
| } |
| |
| // EGL_TEXTURE_FORMAT must be EGL_TEXTURE_RGBA |
| { |
| const EGLint attribs[] = { |
| EGL_WIDTH, |
| 10, |
| EGL_HEIGHT, |
| 10, |
| EGL_IOSURFACE_PLANE_ANGLE, |
| 0, |
| EGL_TEXTURE_TARGET, |
| EGL_TEXTURE_RECTANGLE_ANGLE, |
| EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, |
| GL_BGRA_EXT, |
| EGL_TEXTURE_FORMAT, |
| EGL_TEXTURE_RGB, |
| EGL_TEXTURE_TYPE_ANGLE, |
| GL_UNSIGNED_BYTE, |
| EGL_NONE, |
| EGL_NONE, |
| }; |
| |
| EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs); |
| EXPECT_EQ(EGL_NO_SURFACE, pbuffer); |
| EXPECT_EQ(EGL_BAD_ATTRIBUTE, eglGetError()); |
| } |
| |
| // EGL_WIDTH must be at least 1 |
| { |
| const EGLint attribs[] = { |
| EGL_WIDTH, |
| 0, |
| EGL_HEIGHT, |
| 10, |
| EGL_IOSURFACE_PLANE_ANGLE, |
| 0, |
| EGL_TEXTURE_TARGET, |
| EGL_TEXTURE_RECTANGLE_ANGLE, |
| EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, |
| GL_BGRA_EXT, |
| EGL_TEXTURE_FORMAT, |
| EGL_TEXTURE_RGBA, |
| EGL_TEXTURE_TYPE_ANGLE, |
| GL_UNSIGNED_BYTE, |
| EGL_NONE, |
| EGL_NONE, |
| }; |
| |
| EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs); |
| EXPECT_EQ(EGL_NO_SURFACE, pbuffer); |
| EXPECT_EQ(EGL_BAD_ATTRIBUTE, eglGetError()); |
| } |
| |
| // EGL_HEIGHT must be at least 1 |
| { |
| const EGLint attribs[] = { |
| EGL_WIDTH, |
| 10, |
| EGL_HEIGHT, |
| 0, |
| EGL_IOSURFACE_PLANE_ANGLE, |
| 0, |
| EGL_TEXTURE_TARGET, |
| EGL_TEXTURE_RECTANGLE_ANGLE, |
| EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, |
| GL_BGRA_EXT, |
| EGL_TEXTURE_FORMAT, |
| EGL_TEXTURE_RGBA, |
| EGL_TEXTURE_TYPE_ANGLE, |
| GL_UNSIGNED_BYTE, |
| EGL_NONE, |
| EGL_NONE, |
| }; |
| |
| EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs); |
| EXPECT_EQ(EGL_NO_SURFACE, pbuffer); |
| EXPECT_EQ(EGL_BAD_ATTRIBUTE, eglGetError()); |
| } |
| |
| #if defined(__APPLE__) |
| // EGL_WIDTH must be at most the width of the IOSurface |
| { |
| const EGLint attribs[] = { |
| EGL_WIDTH, |
| 11, |
| EGL_HEIGHT, |
| 10, |
| EGL_IOSURFACE_PLANE_ANGLE, |
| 0, |
| EGL_TEXTURE_TARGET, |
| EGL_TEXTURE_RECTANGLE_ANGLE, |
| EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, |
| GL_BGRA_EXT, |
| EGL_TEXTURE_FORMAT, |
| EGL_TEXTURE_RGBA, |
| EGL_TEXTURE_TYPE_ANGLE, |
| GL_UNSIGNED_BYTE, |
| EGL_NONE, |
| EGL_NONE, |
| }; |
| |
| EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs); |
| EXPECT_EQ(EGL_NO_SURFACE, pbuffer); |
| EXPECT_EQ(EGL_BAD_ATTRIBUTE, eglGetError()); |
| } |
| |
| // EGL_HEIGHT must be at most the height of the IOSurface |
| { |
| const EGLint attribs[] = { |
| EGL_WIDTH, |
| 10, |
| EGL_HEIGHT, |
| 11, |
| EGL_IOSURFACE_PLANE_ANGLE, |
| 0, |
| EGL_TEXTURE_TARGET, |
| EGL_TEXTURE_RECTANGLE_ANGLE, |
| EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, |
| GL_BGRA_EXT, |
| EGL_TEXTURE_FORMAT, |
| EGL_TEXTURE_RGBA, |
| EGL_TEXTURE_TYPE_ANGLE, |
| GL_UNSIGNED_BYTE, |
| EGL_NONE, |
| EGL_NONE, |
| }; |
| |
| EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs); |
| EXPECT_EQ(EGL_NO_SURFACE, pbuffer); |
| EXPECT_EQ(EGL_BAD_ATTRIBUTE, eglGetError()); |
| } |
| |
| // EGL_IOSURFACE_PLANE_ANGLE must less than the number of planes of the IOSurface |
| { |
| const EGLint attribs[] = { |
| EGL_WIDTH, |
| 10, |
| EGL_HEIGHT, |
| 10, |
| EGL_IOSURFACE_PLANE_ANGLE, |
| 1, |
| EGL_TEXTURE_TARGET, |
| EGL_TEXTURE_RECTANGLE_ANGLE, |
| EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, |
| GL_BGRA_EXT, |
| EGL_TEXTURE_FORMAT, |
| EGL_TEXTURE_RGBA, |
| EGL_TEXTURE_TYPE_ANGLE, |
| GL_UNSIGNED_BYTE, |
| EGL_NONE, |
| EGL_NONE, |
| }; |
| |
| EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs); |
| EXPECT_EQ(EGL_NO_SURFACE, pbuffer); |
| EXPECT_EQ(EGL_BAD_ATTRIBUTE, eglGetError()); |
| } |
| #endif |
| |
| // EGL_TEXTURE_FORMAT must be at EGL_TEXTURE_RECTANGLE_ANGLE |
| { |
| const EGLint attribs[] = { |
| EGL_WIDTH, |
| 10, |
| EGL_HEIGHT, |
| 10, |
| EGL_IOSURFACE_PLANE_ANGLE, |
| 0, |
| EGL_TEXTURE_TARGET, |
| EGL_TEXTURE_2D, |
| EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, |
| GL_BGRA_EXT, |
| EGL_TEXTURE_FORMAT, |
| EGL_TEXTURE_RGBA, |
| EGL_TEXTURE_TYPE_ANGLE, |
| GL_UNSIGNED_BYTE, |
| EGL_NONE, |
| EGL_NONE, |
| }; |
| |
| EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs); |
| EXPECT_EQ(EGL_NO_SURFACE, pbuffer); |
| EXPECT_EQ(EGL_BAD_ATTRIBUTE, eglGetError()); |
| } |
| |
| // EGL_IOSURFACE_PLANE_ANGLE must be at least 0 |
| { |
| const EGLint attribs[] = { |
| EGL_WIDTH, |
| 10, |
| EGL_HEIGHT, |
| 10, |
| EGL_IOSURFACE_PLANE_ANGLE, |
| -1, |
| EGL_TEXTURE_TARGET, |
| EGL_TEXTURE_RECTANGLE_ANGLE, |
| EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, |
| GL_BGRA_EXT, |
| EGL_TEXTURE_FORMAT, |
| EGL_TEXTURE_RGBA, |
| EGL_TEXTURE_TYPE_ANGLE, |
| GL_UNSIGNED_BYTE, |
| EGL_NONE, |
| EGL_NONE, |
| }; |
| |
| EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs); |
| EXPECT_EQ(EGL_NO_SURFACE, pbuffer); |
| EXPECT_EQ(EGL_BAD_ATTRIBUTE, eglGetError()); |
| } |
| |
| // The internal format / type most be listed in the table |
| { |
| const EGLint attribs[] = { |
| EGL_WIDTH, |
| 10, |
| EGL_HEIGHT, |
| 10, |
| EGL_IOSURFACE_PLANE_ANGLE, |
| 0, |
| EGL_TEXTURE_TARGET, |
| EGL_TEXTURE_RECTANGLE_ANGLE, |