src/tests/egl_tests/EGLContextPassthroughShadersTest.cpp - third_party/angle - Git at Google


            
            //

            
            // Copyright 2025 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.

            
            //

            
            // EGLContextPassthroughShadersTest.cpp:

            
            //  Tests of the EGL_ANGLE_create_context_passthrough_shaders extension.

            
            //


            #include <gtest/gtest.h>


            #include "GLES2/gl2.h"

            
            #include "test_utils/ANGLETest.h"

            
            #include "test_utils/angle_test_instantiate.h"

            
            #include "test_utils/angle_test_platform.h"

            
            #include "test_utils/gl_raii.h"

            
            #include "util/gles_loader_autogen.h"


            using namespace angle;


            class EGLContextPassthroughShadersTest : public ANGLETest<>

            
            {

            
              public:

            
                EGLContextPassthroughShadersTest() : mDisplay(EGL_NO_DISPLAY) {}


                void testSetUp() override

            
                {

            
                    EGLAttrib dispattrs[] = {EGL_PLATFORM_ANGLE_TYPE_ANGLE, GetParam().getRenderer(),

            
                                             EGL_PLATFORM_ANGLE_NATIVE_PLATFORM_TYPE_ANGLE,

            
                                             static_cast<EGLAttrib>(GetPbufferOnlyDefaultPlatformType()),

            
                                             EGL_NONE};

            
                    mDisplay              = eglGetPlatformDisplay(GetEglPlatform(),

            
                                                                  reinterpret_cast<void *>(EGL_DEFAULT_DISPLAY), dispattrs);

            
                    EXPECT_TRUE(mDisplay != EGL_NO_DISPLAY);

            
                    EXPECT_EGL_TRUE(eglInitialize(mDisplay, nullptr, nullptr) != EGL_FALSE);


                    EGLint attribs[] = {EGL_RED_SIZE,

            
                                        8,

            
                                        EGL_GREEN_SIZE,

            
                                        8,

            
                                        EGL_BLUE_SIZE,

            
                                        8,

            
                                        EGL_ALPHA_SIZE,

            
                                        8,

            
                                        EGL_RENDERABLE_TYPE,

            
                                        EGL_OPENGL_ES2_BIT,

            
                                        EGL_SURFACE_TYPE,

            
                                        EGL_PBUFFER_BIT,

            
                                        EGL_NONE};


                    EGLint count = 0;

            
                    EXPECT_EGL_TRUE(eglChooseConfig(mDisplay, attribs, &mConfig, 1, &count));

            
                    ANGLE_SKIP_TEST_IF(mConfig == EGL_NO_CONFIG_KHR);

            
                    EXPECT_GT(count, 0);


                    EGLint pBufferAttribs[] = {EGL_WIDTH, 32, EGL_HEIGHT, 32, EGL_NONE};

            
                    mSurface                = eglCreatePbufferSurface(mDisplay, mConfig, pBufferAttribs);

            
                    EXPECT_NE(mSurface, EGL_NO_SURFACE);

            
                }


                void testTearDown() override

            
                {

            
                    if (mDisplay != EGL_NO_DISPLAY)

            
                    {

            
                        eglTerminate(mDisplay);

            
                        eglReleaseThread();

            
                        mDisplay = EGL_NO_DISPLAY;

            
                    }

            
                    ASSERT_EGL_SUCCESS() << "Error during test TearDown";

            
                }


                bool supportsPassthroughShadersExtension()

            
                {

            
                    return IsEGLDisplayExtensionEnabled(mDisplay,

            
                                                        "EGL_ANGLE_create_context_passthrough_shaders");

            
                }


                EGLDisplay mDisplay;

            
                EGLConfig mConfig = EGL_NO_CONFIG_KHR;

            
                EGLSurface mSurface;

            
            };


            // Test creating a context with passthrough shaders enabled and verify by querying translated

            
            // shaders source

            
            TEST_P(EGLContextPassthroughShadersTest, CreateContext)

            
            {

            
                ANGLE_SKIP_TEST_IF(!supportsPassthroughShadersExtension());


                EGLint ctxAttribs[] = {EGL_CONTEXT_MAJOR_VERSION, 2, EGL_CONTEXT_PASSTHROUGH_SHADERS_ANGLE,

            
                                       EGL_TRUE, EGL_NONE};

            
                EGLContext context  = eglCreateContext(mDisplay, mConfig, nullptr, ctxAttribs);

            
                EXPECT_NE(context, EGL_NO_CONTEXT);


                EXPECT_EGL_TRUE(eglMakeCurrent(mDisplay, mSurface, mSurface, context));


                constexpr const char kFragmentShader[] = R"(

            
                        precision highp float;

            
                        uniform sampler2D tex;

            
                        varying vec2 texcoord;


                        #define TEST_MACRO_THAT_WOULD_BE_REMOVED


                        void main()

            
                        {

            
                            gl_FragColor = texture2D(tex, texcoord);

            
                        }

            
                    )";

            
                GLuint shader                          = CompileShader(GL_FRAGMENT_SHADER, kFragmentShader);


                EXPECT_TRUE(EnsureGLExtensionEnabled("GL_ANGLE_translated_shader_source"));

            
                std::array<char, std::size(kFragmentShader) + 1> translatedSourceBuffer;

            
                glGetTranslatedShaderSourceANGLE(shader, static_cast<GLsizei>(translatedSourceBuffer.size()),

            
                                                 nullptr, translatedSourceBuffer.data());

            
                EXPECT_EQ(std::string(kFragmentShader), std::string(translatedSourceBuffer.data()));

            
            }


            // Regression test for a Skia shader which had assertion failures in CollectVariables

            
            TEST_P(EGLContextPassthroughShadersTest, ShaderRegressionTest)

            
            {

            
                ANGLE_SKIP_TEST_IF(!supportsPassthroughShadersExtension());


                EGLint ctxAttribs[] = {EGL_CONTEXT_MAJOR_VERSION, 3, EGL_CONTEXT_PASSTHROUGH_SHADERS_ANGLE,

            
                                       EGL_TRUE, EGL_NONE};

            
                EGLContext context  = eglCreateContext(mDisplay, mConfig, nullptr, ctxAttribs);

            
                EXPECT_NE(context, EGL_NO_CONTEXT);


                EXPECT_EGL_TRUE(eglMakeCurrent(mDisplay, mSurface, mSurface, context));


                constexpr const char kVS[] = R"(#version 300 es


            precision mediump float;

            
            precision mediump sampler2D;

            
            const highp float PRECISION = 4.0;

            
            const highp float MAX_FIXED_RESOLVE_LEVEL = 5.0;

            
            const highp float MAX_FIXED_SEGMENTS = 32.0;

            
            uniform highp vec4 sk_RTAdjust;

            
            uniform highp vec4 uaffineMatrix_S0;

            
            uniform highp vec2 utranslate_S0;

            
            in highp vec2 resolveLevel_and_idx;

            
            in highp vec4 p01;

            
            in highp vec4 p23;

            
            in highp vec2 fanPointAttrib;

            
            highp float wangs_formula_max_fdiff_p2_ff2f2f2f2f22(highp vec2 p0, highp vec2 p1, highp vec2 p2, highp vec2 p3, highp mat2 matrix) {

            
            highp vec2 d0 = matrix * (((vec2(-2.0)) * (p1) + (p2)) + p0);

            
            highp vec2 d1 = matrix * (((vec2(-2.0)) * (p2) + (p3)) + p1);

            
            return max(dot(d0, d0), dot(d1, d1));

            
            }

            
            highp float wangs_formula_conic_p2_fff2f2f2f(highp float _precision_, highp vec2 p0, highp vec2 p1, highp vec2 p2, highp float w) {

            
            highp vec2 C = (min(min(p0, p1), p2) + max(max(p0, p1), p2)) * 0.5;

            
            p0 -= C;

            
            p1 -= C;

            
            p2 -= C;

            
            highp float m = sqrt(max(max(dot(p0, p0), dot(p1, p1)), dot(p2, p2)));

            
            highp vec2 dp = ((vec2(-2.0 * w)) * (p1) + (p0)) + p2;

            
            highp float dw = abs(((-2.0) * (w) + (2.0)));

            
            highp float rp_minus_1 = max(0.0, ((m) * (_precision_) + (-1.0)));

            
            highp float numer = length(dp) * _precision_ + rp_minus_1 * dw;

            
            highp float denom = 4.0 * min(w, 1.0);

            
            return numer / denom;

            
            }

            
            void main() {

            
            highp mat2 AFFINE_MATRIX = mat2(uaffineMatrix_S0.xy, uaffineMatrix_S0.zw);

            
            highp vec2 TRANSLATE = utranslate_S0;

            
            highp float resolveLevel = resolveLevel_and_idx.x;

            
            highp float idxInResolveLevel = resolveLevel_and_idx.y;

            
            highp vec2 localcoord;

            
            if (resolveLevel < 0.0) {

            
            localcoord = fanPointAttrib;

            
            } else {

            
            if (isinf(p23.z)) {

            
            localcoord = resolveLevel != 0.0 ? p01.zw : (idxInResolveLevel != 0.0 ? p23.xy : p01.xy);

            
            } else {

            
            highp vec2 p0 = p01.xy;

            
            highp vec2 p1 = p01.zw;

            
            highp vec2 p2 = p23.xy;

            
            highp vec2 p3 = p23.zw;

            
            highp float w = -1.0;

            
            highp float maxResolveLevel;

            
            if (isinf(p23.w)) {

            
            w = p3.x;

            
            highp float _0_n2 = wangs_formula_conic_p2_fff2f2f2f(PRECISION, AFFINE_MATRIX * p0, AFFINE_MATRIX * p1, AFFINE_MATRIX * p2, w);

            
            maxResolveLevel = ceil(log2(max(_0_n2, 1.0)) * 0.5);

            
            p1 *= w;

            
            p3 = p2;

            
            } else {

            
            highp float _1_m = wangs_formula_max_fdiff_p2_ff2f2f2f2f22(p0, p1, p2, p3, AFFINE_MATRIX);

            
            maxResolveLevel = ceil(log2(max(9.0 * _1_m, 1.0)) * 0.25);

            
            }

            
            if (resolveLevel > maxResolveLevel) {

            
            idxInResolveLevel = floor(idxInResolveLevel * exp2(maxResolveLevel - resolveLevel));

            
            resolveLevel = maxResolveLevel;

            
            }

            
            highp float fixedVertexID = floor(0.5 + idxInResolveLevel * exp2(MAX_FIXED_RESOLVE_LEVEL - resolveLevel));

            
            if (0.0 < fixedVertexID && fixedVertexID < MAX_FIXED_SEGMENTS) {

            
            highp float T = fixedVertexID * 0.03125;

            
            highp vec2 ab = mix(p0, p1, T);

            
            highp vec2 bc = mix(p1, p2, T);

            
            highp vec2 cd = mix(p2, p3, T);

            
            highp vec2 abc = mix(ab, bc, T);

            
            highp vec2 bcd = mix(bc, cd, T);

            
            highp vec2 abcd = mix(abc, bcd, T);

            
            highp float u = mix(1.0, w, T);

            
            highp float v = (w + 1.0) - u;

            
            highp float uv = mix(u, v, T);

            
            localcoord = w < 0.0 ? abcd : abc / uv;

            
            } else {

            
            localcoord = fixedVertexID == 0.0 ? p0 : p3;

            
            }

            
            }

            
            }

            
            highp vec2 vertexpos = AFFINE_MATRIX * localcoord + TRANSLATE;

            
            gl_Position = vec4(vertexpos, 0.0, 1.0);

            
            gl_Position = vec4(gl_Position.xy * sk_RTAdjust.xz + gl_Position.ww * sk_RTAdjust.yw, 0.0, gl_Position.w);

            
            }

            
            )";


                constexpr const char kFS[] = R"(#version 300 es

            
            precision highp float;

            
            out vec4 my_FragColor;

            
            void main()

            
            {

            
                my_FragColor = vec4(1.0, 0.0, 0.0, 1.0);

            
            })";


                ANGLE_GL_PROGRAM(program, kVS, kFS);

            
            }


            // Test creating two programs with the same vertex shader (but not the same fragment shader) in two

            
            // different contexts, one passthrough and one not.  There shouldn't be a cache hit in the second

            
            // program creation.

            
            TEST_P(EGLContextPassthroughShadersTest, SameShaderWithAndWithoutPassthrough)

            
            {

            
                ANGLE_SKIP_TEST_IF(!supportsPassthroughShadersExtension());


                // When passthrough is enabled, some extensions are automatically disabled.  To remove

            
                // differences between the two contexts, mark all extensions disabled.

            
                //

            
                // Also, make sure a GLES2 context is created so that even more extensions that cannot normally

            
                // be disabled are disabled.

            
                std::vector<EGLint> ctxAttribs = {EGL_CONTEXT_MAJOR_VERSION, 2};

            
                if (IsEGLDisplayExtensionEnabled(mDisplay, "EGL_ANGLE_create_context_extensions_enabled"))

            
                {

            
                    ctxAttribs.push_back(EGL_EXTENSIONS_ENABLED_ANGLE);

            
                    ctxAttribs.push_back(EGL_FALSE);

            
                }

            
                if (IsEGLDisplayExtensionEnabled(mDisplay, "EGL_ANGLE_create_context_backwards_compatible"))

            
                {

            
                    ctxAttribs.push_back(EGL_CONTEXT_OPENGL_BACKWARDS_COMPATIBLE_ANGLE);

            
                    ctxAttribs.push_back(EGL_FALSE);

            
                }

            
                ctxAttribs.push_back(EGL_CONTEXT_PASSTHROUGH_SHADERS_ANGLE);

            
                ctxAttribs.push_back(EGL_FALSE);

            
                ctxAttribs.push_back(EGL_NONE);


                // Create two identical contexts who only differe in EGL_CONTEXT_PASSTHROUGH_SHADERS_ANGLE.

            
                EGLContext noPassthroughContext =

            
                    eglCreateContext(mDisplay, mConfig, nullptr, ctxAttribs.data());

            
                EXPECT_NE(noPassthroughContext, EGL_NO_CONTEXT);


                ctxAttribs[ctxAttribs.size() - 2] = EGL_TRUE;

            
                EGLContext passthroughContext = eglCreateContext(mDisplay, mConfig, nullptr, ctxAttribs.data());

            
                EXPECT_NE(passthroughContext, EGL_NO_CONTEXT);


                constexpr char kVS[] = R"(precision highp float;

            
            attribute vec4 position;

            
            varying vec4 color;

            
            void main()

            
            {

            
                gl_Position = position;

            
                color = vec4(1, 0, 0, 1);

            
            })";


                constexpr char kFS1[] = R"(precision highp float;

            
            varying vec4 color;

            
            void main()

            
            {

            
                gl_FragColor = color;

            
            })";


                constexpr char kFS2[] = R"(precision highp float;

            
            varying vec4 color;

            
            void main()

            
            {

            
                gl_FragColor = color + vec4(0, 1, 0, 0);

            
            })";


                // Draw VS + FS1 in one context

            
                EXPECT_EGL_TRUE(eglMakeCurrent(mDisplay, mSurface, mSurface, noPassthroughContext));

            
                {

            
                    ANGLE_GL_PROGRAM(program1, kVS, kFS1);

            
                    drawQuad(program1, "position", 0);

            
                }

            
                EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::red);

            
                ASSERT_GL_NO_ERROR();


                // Draw VS + FS2 in the other context

            
                EXPECT_EGL_TRUE(eglMakeCurrent(mDisplay, mSurface, mSurface, passthroughContext));

            
                {

            
                    ANGLE_GL_PROGRAM(program2, kVS, kFS2);

            
                    drawQuad(program2, "position", 0);

            
                }

            
                EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::yellow);

            
                ASSERT_GL_NO_ERROR();

            
            }


            GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(EGLContextPassthroughShadersTest);

            
            ANGLE_INSTANTIATE_TEST(EGLContextPassthroughShadersTest,

            
                                   WithNoFixture(ES2_D3D11()),

            
                                   WithNoFixture(ES2_OPENGL()),

            
                                   WithNoFixture(ES2_OPENGLES()),

            
                                   WithNoFixture(ES2_VULKAN()),

            
                                   WithNoFixture(ES3_D3D11()),

            
                                   WithNoFixture(ES3_OPENGL()),

            
                                   WithNoFixture(ES3_OPENGLES()),

            
                                   WithNoFixture(ES3_VULKAN()));
	//
	// Copyright 2025 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.
	//
	// EGLContextPassthroughShadersTest.cpp:
	// Tests of the EGL_ANGLE_create_context_passthrough_shaders extension.
	//

	#include <gtest/gtest.h>

	#include "GLES2/gl2.h"
	#include "test_utils/ANGLETest.h"
	#include "test_utils/angle_test_instantiate.h"
	#include "test_utils/angle_test_platform.h"
	#include "test_utils/gl_raii.h"
	#include "util/gles_loader_autogen.h"

	using namespace angle;

	class EGLContextPassthroughShadersTest : public ANGLETest<>
	{
	public:
	EGLContextPassthroughShadersTest() : mDisplay(EGL_NO_DISPLAY) {}

	void testSetUp() override
	{
	EGLAttrib dispattrs[] = {EGL_PLATFORM_ANGLE_TYPE_ANGLE, GetParam().getRenderer(),
	EGL_PLATFORM_ANGLE_NATIVE_PLATFORM_TYPE_ANGLE,
	static_cast<EGLAttrib>(GetPbufferOnlyDefaultPlatformType()),
	EGL_NONE};
	mDisplay = eglGetPlatformDisplay(GetEglPlatform(),
	reinterpret_cast<void *>(EGL_DEFAULT_DISPLAY), dispattrs);
	EXPECT_TRUE(mDisplay != EGL_NO_DISPLAY);
	EXPECT_EGL_TRUE(eglInitialize(mDisplay, nullptr, nullptr) != EGL_FALSE);

	EGLint attribs[] = {EGL_RED_SIZE,
	8,
	EGL_GREEN_SIZE,
	8,
	EGL_BLUE_SIZE,
	8,
	EGL_ALPHA_SIZE,
	8,
	EGL_RENDERABLE_TYPE,
	EGL_OPENGL_ES2_BIT,
	EGL_SURFACE_TYPE,
	EGL_PBUFFER_BIT,
	EGL_NONE};

	EGLint count = 0;
	EXPECT_EGL_TRUE(eglChooseConfig(mDisplay, attribs, &mConfig, 1, &count));
	ANGLE_SKIP_TEST_IF(mConfig == EGL_NO_CONFIG_KHR);
	EXPECT_GT(count, 0);

	EGLint pBufferAttribs[] = {EGL_WIDTH, 32, EGL_HEIGHT, 32, EGL_NONE};
	mSurface = eglCreatePbufferSurface(mDisplay, mConfig, pBufferAttribs);
	EXPECT_NE(mSurface, EGL_NO_SURFACE);
	}

	void testTearDown() override
	{
	if (mDisplay != EGL_NO_DISPLAY)
	{
	eglTerminate(mDisplay);
	eglReleaseThread();
	mDisplay = EGL_NO_DISPLAY;
	}
	ASSERT_EGL_SUCCESS() << "Error during test TearDown";
	}

	bool supportsPassthroughShadersExtension()
	{
	return IsEGLDisplayExtensionEnabled(mDisplay,
	"EGL_ANGLE_create_context_passthrough_shaders");
	}

	EGLDisplay mDisplay;
	EGLConfig mConfig = EGL_NO_CONFIG_KHR;
	EGLSurface mSurface;
	};

	// Test creating a context with passthrough shaders enabled and verify by querying translated
	// shaders source
	TEST_P(EGLContextPassthroughShadersTest, CreateContext)
	{
	ANGLE_SKIP_TEST_IF(!supportsPassthroughShadersExtension());

	EGLint ctxAttribs[] = {EGL_CONTEXT_MAJOR_VERSION, 2, EGL_CONTEXT_PASSTHROUGH_SHADERS_ANGLE,
	EGL_TRUE, EGL_NONE};
	EGLContext context = eglCreateContext(mDisplay, mConfig, nullptr, ctxAttribs);
	EXPECT_NE(context, EGL_NO_CONTEXT);

	EXPECT_EGL_TRUE(eglMakeCurrent(mDisplay, mSurface, mSurface, context));

	constexpr const char kFragmentShader[] = R"(
	precision highp float;
	uniform sampler2D tex;
	varying vec2 texcoord;

	#define TEST_MACRO_THAT_WOULD_BE_REMOVED

	void main()
	{
	gl_FragColor = texture2D(tex, texcoord);
	}
	)";
	GLuint shader = CompileShader(GL_FRAGMENT_SHADER, kFragmentShader);

	EXPECT_TRUE(EnsureGLExtensionEnabled("GL_ANGLE_translated_shader_source"));
	std::array<char, std::size(kFragmentShader) + 1> translatedSourceBuffer;
	glGetTranslatedShaderSourceANGLE(shader, static_cast<GLsizei>(translatedSourceBuffer.size()),
	nullptr, translatedSourceBuffer.data());
	EXPECT_EQ(std::string(kFragmentShader), std::string(translatedSourceBuffer.data()));
	}

	// Regression test for a Skia shader which had assertion failures in CollectVariables
	TEST_P(EGLContextPassthroughShadersTest, ShaderRegressionTest)
	{
	ANGLE_SKIP_TEST_IF(!supportsPassthroughShadersExtension());

	EGLint ctxAttribs[] = {EGL_CONTEXT_MAJOR_VERSION, 3, EGL_CONTEXT_PASSTHROUGH_SHADERS_ANGLE,
	EGL_TRUE, EGL_NONE};
	EGLContext context = eglCreateContext(mDisplay, mConfig, nullptr, ctxAttribs);
	EXPECT_NE(context, EGL_NO_CONTEXT);

	EXPECT_EGL_TRUE(eglMakeCurrent(mDisplay, mSurface, mSurface, context));

	constexpr const char kVS[] = R"(#version 300 es

	precision mediump float;
	precision mediump sampler2D;
	const highp float PRECISION = 4.0;
	const highp float MAX_FIXED_RESOLVE_LEVEL = 5.0;
	const highp float MAX_FIXED_SEGMENTS = 32.0;
	uniform highp vec4 sk_RTAdjust;
	uniform highp vec4 uaffineMatrix_S0;
	uniform highp vec2 utranslate_S0;
	in highp vec2 resolveLevel_and_idx;
	in highp vec4 p01;
	in highp vec4 p23;
	in highp vec2 fanPointAttrib;
	highp float wangs_formula_max_fdiff_p2_ff2f2f2f2f22(highp vec2 p0, highp vec2 p1, highp vec2 p2, highp vec2 p3, highp mat2 matrix) {
	highp vec2 d0 = matrix * (((vec2(-2.0)) * (p1) + (p2)) + p0);
	highp vec2 d1 = matrix * (((vec2(-2.0)) * (p2) + (p3)) + p1);
	return max(dot(d0, d0), dot(d1, d1));
	}
	highp float wangs_formula_conic_p2_fff2f2f2f(highp float _precision_, highp vec2 p0, highp vec2 p1, highp vec2 p2, highp float w) {
	highp vec2 C = (min(min(p0, p1), p2) + max(max(p0, p1), p2)) * 0.5;
	p0 -= C;
	p1 -= C;
	p2 -= C;
	highp float m = sqrt(max(max(dot(p0, p0), dot(p1, p1)), dot(p2, p2)));
	highp vec2 dp = ((vec2(-2.0 * w)) * (p1) + (p0)) + p2;
	highp float dw = abs(((-2.0) * (w) + (2.0)));
	highp float rp_minus_1 = max(0.0, ((m) * (_precision_) + (-1.0)));
	highp float numer = length(dp) * _precision_ + rp_minus_1 * dw;
	highp float denom = 4.0 * min(w, 1.0);
	return numer / denom;
	}
	void main() {
	highp mat2 AFFINE_MATRIX = mat2(uaffineMatrix_S0.xy, uaffineMatrix_S0.zw);
	highp vec2 TRANSLATE = utranslate_S0;
	highp float resolveLevel = resolveLevel_and_idx.x;
	highp float idxInResolveLevel = resolveLevel_and_idx.y;
	highp vec2 localcoord;
	if (resolveLevel < 0.0) {
	localcoord = fanPointAttrib;
	} else {
	if (isinf(p23.z)) {
	localcoord = resolveLevel != 0.0 ? p01.zw : (idxInResolveLevel != 0.0 ? p23.xy : p01.xy);
	} else {
	highp vec2 p0 = p01.xy;
	highp vec2 p1 = p01.zw;
	highp vec2 p2 = p23.xy;
	highp vec2 p3 = p23.zw;
	highp float w = -1.0;
	highp float maxResolveLevel;
	if (isinf(p23.w)) {
	w = p3.x;
	highp float _0_n2 = wangs_formula_conic_p2_fff2f2f2f(PRECISION, AFFINE_MATRIX * p0, AFFINE_MATRIX * p1, AFFINE_MATRIX * p2, w);
	maxResolveLevel = ceil(log2(max(_0_n2, 1.0)) * 0.5);
	p1 *= w;
	p3 = p2;
	} else {
	highp float _1_m = wangs_formula_max_fdiff_p2_ff2f2f2f2f22(p0, p1, p2, p3, AFFINE_MATRIX);
	maxResolveLevel = ceil(log2(max(9.0 * _1_m, 1.0)) * 0.25);
	}
	if (resolveLevel > maxResolveLevel) {
	idxInResolveLevel = floor(idxInResolveLevel * exp2(maxResolveLevel - resolveLevel));
	resolveLevel = maxResolveLevel;
	}
	highp float fixedVertexID = floor(0.5 + idxInResolveLevel * exp2(MAX_FIXED_RESOLVE_LEVEL - resolveLevel));
	if (0.0 < fixedVertexID && fixedVertexID < MAX_FIXED_SEGMENTS) {
	highp float T = fixedVertexID * 0.03125;
	highp vec2 ab = mix(p0, p1, T);
	highp vec2 bc = mix(p1, p2, T);
	highp vec2 cd = mix(p2, p3, T);
	highp vec2 abc = mix(ab, bc, T);
	highp vec2 bcd = mix(bc, cd, T);
	highp vec2 abcd = mix(abc, bcd, T);
	highp float u = mix(1.0, w, T);
	highp float v = (w + 1.0) - u;
	highp float uv = mix(u, v, T);
	localcoord = w < 0.0 ? abcd : abc / uv;
	} else {
	localcoord = fixedVertexID == 0.0 ? p0 : p3;
	}
	}
	}
	highp vec2 vertexpos = AFFINE_MATRIX * localcoord + TRANSLATE;
	gl_Position = vec4(vertexpos, 0.0, 1.0);
	gl_Position = vec4(gl_Position.xy * sk_RTAdjust.xz + gl_Position.ww * sk_RTAdjust.yw, 0.0, gl_Position.w);
	}
	)";

	constexpr const char kFS[] = R"(#version 300 es
	precision highp float;
	out vec4 my_FragColor;
	void main()
	{
	my_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
	})";

	ANGLE_GL_PROGRAM(program, kVS, kFS);
	}

	// Test creating two programs with the same vertex shader (but not the same fragment shader) in two
	// different contexts, one passthrough and one not. There shouldn't be a cache hit in the second
	// program creation.
	TEST_P(EGLContextPassthroughShadersTest, SameShaderWithAndWithoutPassthrough)
	{
	ANGLE_SKIP_TEST_IF(!supportsPassthroughShadersExtension());

	// When passthrough is enabled, some extensions are automatically disabled. To remove
	// differences between the two contexts, mark all extensions disabled.
	//
	// Also, make sure a GLES2 context is created so that even more extensions that cannot normally
	// be disabled are disabled.
	std::vector<EGLint> ctxAttribs = {EGL_CONTEXT_MAJOR_VERSION, 2};
	if (IsEGLDisplayExtensionEnabled(mDisplay, "EGL_ANGLE_create_context_extensions_enabled"))
	{
	ctxAttribs.push_back(EGL_EXTENSIONS_ENABLED_ANGLE);
	ctxAttribs.push_back(EGL_FALSE);
	}
	if (IsEGLDisplayExtensionEnabled(mDisplay, "EGL_ANGLE_create_context_backwards_compatible"))
	{
	ctxAttribs.push_back(EGL_CONTEXT_OPENGL_BACKWARDS_COMPATIBLE_ANGLE);
	ctxAttribs.push_back(EGL_FALSE);
	}
	ctxAttribs.push_back(EGL_CONTEXT_PASSTHROUGH_SHADERS_ANGLE);
	ctxAttribs.push_back(EGL_FALSE);
	ctxAttribs.push_back(EGL_NONE);

	// Create two identical contexts who only differe in EGL_CONTEXT_PASSTHROUGH_SHADERS_ANGLE.
	EGLContext noPassthroughContext =
	eglCreateContext(mDisplay, mConfig, nullptr, ctxAttribs.data());
	EXPECT_NE(noPassthroughContext, EGL_NO_CONTEXT);

	ctxAttribs[ctxAttribs.size() - 2] = EGL_TRUE;
	EGLContext passthroughContext = eglCreateContext(mDisplay, mConfig, nullptr, ctxAttribs.data());
	EXPECT_NE(passthroughContext, EGL_NO_CONTEXT);

	constexpr char kVS[] = R"(precision highp float;
	attribute vec4 position;
	varying vec4 color;
	void main()
	{
	gl_Position = position;
	color = vec4(1, 0, 0, 1);
	})";

	constexpr char kFS1[] = R"(precision highp float;
	varying vec4 color;
	void main()
	{
	gl_FragColor = color;
	})";

	constexpr char kFS2[] = R"(precision highp float;
	varying vec4 color;
	void main()
	{
	gl_FragColor = color + vec4(0, 1, 0, 0);
	})";

	// Draw VS + FS1 in one context
	EXPECT_EGL_TRUE(eglMakeCurrent(mDisplay, mSurface, mSurface, noPassthroughContext));
	{
	ANGLE_GL_PROGRAM(program1, kVS, kFS1);
	drawQuad(program1, "position", 0);
	}
	EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::red);
	ASSERT_GL_NO_ERROR();

	// Draw VS + FS2 in the other context
	EXPECT_EGL_TRUE(eglMakeCurrent(mDisplay, mSurface, mSurface, passthroughContext));
	{
	ANGLE_GL_PROGRAM(program2, kVS, kFS2);
	drawQuad(program2, "position", 0);
	}
	EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::yellow);
	ASSERT_GL_NO_ERROR();
	}

	GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(EGLContextPassthroughShadersTest);
	ANGLE_INSTANTIATE_TEST(EGLContextPassthroughShadersTest,
	WithNoFixture(ES2_D3D11()),
	WithNoFixture(ES2_OPENGL()),
	WithNoFixture(ES2_OPENGLES()),
	WithNoFixture(ES2_VULKAN()),
	WithNoFixture(ES3_D3D11()),
	WithNoFixture(ES3_OPENGL()),
	WithNoFixture(ES3_OPENGLES()),
	WithNoFixture(ES3_VULKAN()));