src/tests/gl_tests/TextureFixedRateCompressionTest.cpp - third_party/angle - Git at Google

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

 // TextureFixedRateCompressionTest: Tests for GL_EXT_texture_storage_compression

 #ifdef UNSAFE_BUFFERS_BUILD
 #    pragma allow_unsafe_buffers
 #endif

 #include "test_utils/ANGLETest.h"
 #include "test_utils/gl_raii.h"

 namespace angle
 {

 static constexpr GLint kDefaultAttribList[3][3] = {
     {GL_NONE, GL_NONE, GL_NONE},
     {GL_SURFACE_COMPRESSION_EXT, GL_SURFACE_COMPRESSION_FIXED_RATE_NONE_EXT, GL_NONE},
     {GL_SURFACE_COMPRESSION_EXT, GL_SURFACE_COMPRESSION_FIXED_RATE_DEFAULT_EXT, GL_NONE},
 };

 // Return its name by value for easy printing
 static const char *Name(int value)
 {
 #define NAME(ERR) \
     case ERR:     \
         return #ERR;
     switch (value)
     {
         NAME(GL_SURFACE_COMPRESSION_FIXED_RATE_NONE_EXT)
         NAME(GL_SURFACE_COMPRESSION_FIXED_RATE_DEFAULT_EXT)
         NAME(GL_SURFACE_COMPRESSION_FIXED_RATE_1BPC_EXT)
         NAME(GL_SURFACE_COMPRESSION_FIXED_RATE_2BPC_EXT)
         NAME(GL_SURFACE_COMPRESSION_FIXED_RATE_3BPC_EXT)
         NAME(GL_SURFACE_COMPRESSION_FIXED_RATE_4BPC_EXT)
         NAME(GL_SURFACE_COMPRESSION_FIXED_RATE_5BPC_EXT)
         NAME(GL_SURFACE_COMPRESSION_FIXED_RATE_6BPC_EXT)
         NAME(GL_SURFACE_COMPRESSION_FIXED_RATE_7BPC_EXT)
         NAME(GL_SURFACE_COMPRESSION_FIXED_RATE_8BPC_EXT)
         NAME(GL_SURFACE_COMPRESSION_FIXED_RATE_9BPC_EXT)
         NAME(GL_SURFACE_COMPRESSION_FIXED_RATE_10BPC_EXT)
         NAME(GL_SURFACE_COMPRESSION_FIXED_RATE_11BPC_EXT)
         NAME(GL_SURFACE_COMPRESSION_FIXED_RATE_12BPC_EXT)
     }
     return "UNKNOW";
 #undef NAME
 }

 class TextureFixedRateCompressionTest : public ANGLETest<>
 {
   protected:
     void invalidTestHelper(const GLint *attribs);
     void basicTestHelper(const GLint *attribs);
     void RenderToTexture(const GLenum internalFormat, const GLint *attribs);
 };

 void TextureFixedRateCompressionTest::invalidTestHelper(const GLint *attribs)
 {
     GLTexture tex;
     glBindTexture(GL_TEXTURE_2D, tex);
     ASSERT_GL_NO_ERROR();

     glTexStorageAttribs2DEXT(GL_TEXTURE_2D, 1, GL_RGBA8, 16, 16, attribs);
     ASSERT_GL_NO_ERROR();

     /* Query compression rate */
     GLint compressRate = GL_SURFACE_COMPRESSION_FIXED_RATE_NONE_EXT;
     glGetTexParameteriv(GL_TEXTURE_2D, GL_SURFACE_COMPRESSION_EXT, &compressRate);
     ASSERT_GL_NO_ERROR();

     glBindImageTexture(0, tex, 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA8);
     if (nullptr == attribs)
     {
         /* Default attrib which is non-compressed formats will return GL_NO_ERROR. */
         ASSERT_GL_NO_ERROR();
     }
     else if (compressRate == GL_SURFACE_COMPRESSION_FIXED_RATE_DEFAULT_EXT ||
              (compressRate >= GL_SURFACE_COMPRESSION_FIXED_RATE_1BPC_EXT &&
               compressRate <= GL_SURFACE_COMPRESSION_FIXED_RATE_12BPC_EXT))
     {
         /* Compressed texture is not supported in glBindImageTexture. */
         ASSERT_GL_ERROR(GL_INVALID_VALUE);
     }
     else if (attribs[1] == GL_SURFACE_COMPRESSION_FIXED_RATE_NONE_EXT || attribs[0] == GL_NONE)
     {
         /* Default attrib which is non-compressed formats will return GL_NO_ERROR. */
         ASSERT_GL_NO_ERROR();
     }
 }

 void TextureFixedRateCompressionTest::basicTestHelper(const GLint *attribs)
 {
     GLTexture texture;
     glBindTexture(GL_TEXTURE_2D, texture);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     ASSERT_GL_NO_ERROR();

     glTexStorageAttribs2DEXT(GL_TEXTURE_2D, 1, GL_RGBA8, 16, 16, attribs);
     ASSERT_GL_NO_ERROR();

     /* Query and check the compression rate */
     GLint compressRate;
     glGetTexParameteriv(GL_TEXTURE_2D, GL_SURFACE_COMPRESSION_EXT, &compressRate);
     ASSERT_GL_NO_ERROR();

     if (nullptr != attribs && compressRate != GL_SURFACE_COMPRESSION_FIXED_RATE_NONE_EXT &&
         attribs[1] != GL_SURFACE_COMPRESSION_FIXED_RATE_DEFAULT_EXT)
     {
         EXPECT_EQ(compressRate, attribs[1]);
     }

     GLFramebuffer fbo;
     glBindFramebuffer(GL_FRAMEBUFFER, fbo);
     ASSERT_GL_NO_ERROR();
     glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
     ASSERT_GL_NO_ERROR();
     ASSERT_GL_FRAMEBUFFER_COMPLETE(GL_FRAMEBUFFER);

     ANGLE_GL_PROGRAM(drawRed, essl1_shaders::vs::Simple(), essl1_shaders::fs::Red());
     drawQuad(drawRed, essl1_shaders::PositionAttrib(), 0);
     EXPECT_PIXEL_RECT_EQ(0, 0, 16, 16, GLColor::red);
     ASSERT_GL_NO_ERROR();
 }

 // Invalid attrib list, GL_INVALID_VALUE is generated.
 TEST_P(TextureFixedRateCompressionTest, Invalidate)
 {
     ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_EXT_texture_storage_compression"));

     constexpr GLint kAttribListInvalid[3] = {GL_SURFACE_COMPRESSION_EXT, GL_SURFACE_COMPRESSION_EXT,
                                              GL_NONE};

     GLTexture texture;
     glBindTexture(GL_TEXTURE_2D, texture);
     ASSERT_GL_NO_ERROR();

     glTexStorageAttribs2DEXT(GL_TEXTURE_2D, 1, GL_RGBA8, 16, 16, kAttribListInvalid);
     ASSERT_GL_ERROR(GL_INVALID_VALUE);

     for (const GLint *attribs : kDefaultAttribList)
     {
         invalidTestHelper(attribs);
     }
     invalidTestHelper(nullptr);
 }

 // Test basic usage of glTexStorageAttribs2DEXT
 TEST_P(TextureFixedRateCompressionTest, TexStorageAttribs2DEXT)
 {
     ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_EXT_texture_storage_compression"));

     for (const GLint *attribs : kDefaultAttribList)
     {
         basicTestHelper(attribs);
     }
 }

 void TextureFixedRateCompressionTest::RenderToTexture(const GLenum internalFormat,
                                                       const GLint *attribs)
 {
     GLint compressRate = 0;
     ASSERT(attribs != nullptr);

     GLTexture texture;
     glBindTexture(GL_TEXTURE_2D, texture);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     ASSERT_GL_NO_ERROR();

     glTexStorageAttribs2DEXT(GL_TEXTURE_2D, 1, internalFormat, 16, 16, attribs);
     ASSERT_GL_NO_ERROR();

     GLFramebuffer fbo;
     glBindFramebuffer(GL_FRAMEBUFFER, fbo);
     ASSERT_GL_NO_ERROR();
     glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
     ASSERT_GL_NO_ERROR();
     ASSERT_GL_FRAMEBUFFER_COMPLETE(GL_FRAMEBUFFER);

     // Query and check the compression rate
     glGetTexParameteriv(GL_TEXTURE_2D, GL_SURFACE_COMPRESSION_EXT, &compressRate);
     ASSERT_GL_NO_ERROR();
     ASSERT_EQ(compressRate, attribs[1])
         << "Compression rate of original texture: " << Name(compressRate);

     ANGLE_GL_PROGRAM(drawRed, essl1_shaders::vs::Simple(), essl1_shaders::fs::Red());
     drawQuad(drawRed, essl1_shaders::PositionAttrib(), 0);
     EXPECT_PIXEL_RECT_EQ(0, 0, 16, 16, GLColor::red);
     ASSERT_GL_NO_ERROR();

     // Query and check the compression rate after render
     glGetTexParameteriv(GL_TEXTURE_2D, GL_SURFACE_COMPRESSION_EXT, &compressRate);
     ASSERT_GL_NO_ERROR();
     ASSERT_EQ(compressRate, attribs[1])
         << "Compression rate of texture after render: " << Name(compressRate);
 }

 // Test render to texture with fixed compression
 TEST_P(TextureFixedRateCompressionTest, RenderToTexture)
 {
     ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_EXT_texture_storage_compression"));

     static GLint attribList[]          = {GL_SURFACE_COMPRESSION_EXT,
                                           GL_SURFACE_COMPRESSION_FIXED_RATE_1BPC_EXT, GL_NONE};
     GLint numRates                     = 0;
     constexpr GLenum internalFormats[] = {GL_RGBA4, GL_R8, GL_RG8, GL_RGB8, GL_RGBA8};

     for (GLenum internalFormat : internalFormats)
     {
         // Test attrib list generated from internal format query.
         glGetInternalformativ(GL_TEXTURE_2D, internalFormat,
                               GL_NUM_SURFACE_COMPRESSION_FIXED_RATES_EXT, 1, &numRates);
         ASSERT_GL_NO_ERROR();
         if (numRates > 0)
         {
             std::vector<GLint> rates(numRates);
             glGetInternalformativ(GL_TEXTURE_2D, internalFormat, GL_SURFACE_COMPRESSION_EXT,
                                   numRates, rates.data());
             ASSERT_GL_NO_ERROR();

             for (int i = 0; i < numRates; ++i)
             {
                 attribList[1] = rates[i];
                 RenderToTexture(internalFormat, attribList);
             }
         }
     }
 }

 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(TextureFixedRateCompressionTest);
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these
 // tests should be run against.
 ANGLE_INSTANTIATE_TEST_ES31_AND(TextureFixedRateCompressionTest);

 }  // namespace angle
	//
	// Copyright 2024 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.
	//

	// TextureFixedRateCompressionTest: Tests for GL_EXT_texture_storage_compression

	#ifdef UNSAFE_BUFFERS_BUILD
	# pragma allow_unsafe_buffers
	#endif

	#include "test_utils/ANGLETest.h"
	#include "test_utils/gl_raii.h"

	namespace angle
	{

	static constexpr GLint kDefaultAttribList[3][3] = {
	{GL_NONE, GL_NONE, GL_NONE},
	{GL_SURFACE_COMPRESSION_EXT, GL_SURFACE_COMPRESSION_FIXED_RATE_NONE_EXT, GL_NONE},
	{GL_SURFACE_COMPRESSION_EXT, GL_SURFACE_COMPRESSION_FIXED_RATE_DEFAULT_EXT, GL_NONE},
	};

	// Return its name by value for easy printing
	static const char *Name(int value)
	{
	#define NAME(ERR) \
	case ERR: \
	return #ERR;
	switch (value)
	{
	NAME(GL_SURFACE_COMPRESSION_FIXED_RATE_NONE_EXT)
	NAME(GL_SURFACE_COMPRESSION_FIXED_RATE_DEFAULT_EXT)
	NAME(GL_SURFACE_COMPRESSION_FIXED_RATE_1BPC_EXT)
	NAME(GL_SURFACE_COMPRESSION_FIXED_RATE_2BPC_EXT)
	NAME(GL_SURFACE_COMPRESSION_FIXED_RATE_3BPC_EXT)
	NAME(GL_SURFACE_COMPRESSION_FIXED_RATE_4BPC_EXT)
	NAME(GL_SURFACE_COMPRESSION_FIXED_RATE_5BPC_EXT)
	NAME(GL_SURFACE_COMPRESSION_FIXED_RATE_6BPC_EXT)
	NAME(GL_SURFACE_COMPRESSION_FIXED_RATE_7BPC_EXT)
	NAME(GL_SURFACE_COMPRESSION_FIXED_RATE_8BPC_EXT)
	NAME(GL_SURFACE_COMPRESSION_FIXED_RATE_9BPC_EXT)
	NAME(GL_SURFACE_COMPRESSION_FIXED_RATE_10BPC_EXT)
	NAME(GL_SURFACE_COMPRESSION_FIXED_RATE_11BPC_EXT)
	NAME(GL_SURFACE_COMPRESSION_FIXED_RATE_12BPC_EXT)
	}
	return "UNKNOW";
	#undef NAME
	}

	class TextureFixedRateCompressionTest : public ANGLETest<>
	{
	protected:
	void invalidTestHelper(const GLint *attribs);
	void basicTestHelper(const GLint *attribs);
	void RenderToTexture(const GLenum internalFormat, const GLint *attribs);
	};

	void TextureFixedRateCompressionTest::invalidTestHelper(const GLint *attribs)
	{
	GLTexture tex;
	glBindTexture(GL_TEXTURE_2D, tex);
	ASSERT_GL_NO_ERROR();

	glTexStorageAttribs2DEXT(GL_TEXTURE_2D, 1, GL_RGBA8, 16, 16, attribs);
	ASSERT_GL_NO_ERROR();

	/* Query compression rate */
	GLint compressRate = GL_SURFACE_COMPRESSION_FIXED_RATE_NONE_EXT;
	glGetTexParameteriv(GL_TEXTURE_2D, GL_SURFACE_COMPRESSION_EXT, &compressRate);
	ASSERT_GL_NO_ERROR();

	glBindImageTexture(0, tex, 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA8);
	if (nullptr == attribs)
	{
	/* Default attrib which is non-compressed formats will return GL_NO_ERROR. */
	ASSERT_GL_NO_ERROR();
	}
	else if (compressRate == GL_SURFACE_COMPRESSION_FIXED_RATE_DEFAULT_EXT \|\|
	(compressRate >= GL_SURFACE_COMPRESSION_FIXED_RATE_1BPC_EXT &&
	compressRate <= GL_SURFACE_COMPRESSION_FIXED_RATE_12BPC_EXT))
	{
	/* Compressed texture is not supported in glBindImageTexture. */
	ASSERT_GL_ERROR(GL_INVALID_VALUE);
	}
	else if (attribs[1] == GL_SURFACE_COMPRESSION_FIXED_RATE_NONE_EXT \|\| attribs[0] == GL_NONE)
	{
	/* Default attrib which is non-compressed formats will return GL_NO_ERROR. */
	ASSERT_GL_NO_ERROR();
	}
	}

	void TextureFixedRateCompressionTest::basicTestHelper(const GLint *attribs)
	{
	GLTexture texture;
	glBindTexture(GL_TEXTURE_2D, texture);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	ASSERT_GL_NO_ERROR();

	glTexStorageAttribs2DEXT(GL_TEXTURE_2D, 1, GL_RGBA8, 16, 16, attribs);
	ASSERT_GL_NO_ERROR();

	/* Query and check the compression rate */
	GLint compressRate;
	glGetTexParameteriv(GL_TEXTURE_2D, GL_SURFACE_COMPRESSION_EXT, &compressRate);
	ASSERT_GL_NO_ERROR();

	if (nullptr != attribs && compressRate != GL_SURFACE_COMPRESSION_FIXED_RATE_NONE_EXT &&
	attribs[1] != GL_SURFACE_COMPRESSION_FIXED_RATE_DEFAULT_EXT)
	{
	EXPECT_EQ(compressRate, attribs[1]);
	}

	GLFramebuffer fbo;
	glBindFramebuffer(GL_FRAMEBUFFER, fbo);
	ASSERT_GL_NO_ERROR();
	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
	ASSERT_GL_NO_ERROR();
	ASSERT_GL_FRAMEBUFFER_COMPLETE(GL_FRAMEBUFFER);

	ANGLE_GL_PROGRAM(drawRed, essl1_shaders::vs::Simple(), essl1_shaders::fs::Red());
	drawQuad(drawRed, essl1_shaders::PositionAttrib(), 0);
	EXPECT_PIXEL_RECT_EQ(0, 0, 16, 16, GLColor::red);
	ASSERT_GL_NO_ERROR();
	}

	// Invalid attrib list, GL_INVALID_VALUE is generated.
	TEST_P(TextureFixedRateCompressionTest, Invalidate)
	{
	ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_EXT_texture_storage_compression"));

	constexpr GLint kAttribListInvalid[3] = {GL_SURFACE_COMPRESSION_EXT, GL_SURFACE_COMPRESSION_EXT,
	GL_NONE};

	GLTexture texture;
	glBindTexture(GL_TEXTURE_2D, texture);
	ASSERT_GL_NO_ERROR();

	glTexStorageAttribs2DEXT(GL_TEXTURE_2D, 1, GL_RGBA8, 16, 16, kAttribListInvalid);
	ASSERT_GL_ERROR(GL_INVALID_VALUE);

	for (const GLint *attribs : kDefaultAttribList)
	{
	invalidTestHelper(attribs);
	}
	invalidTestHelper(nullptr);
	}

	// Test basic usage of glTexStorageAttribs2DEXT
	TEST_P(TextureFixedRateCompressionTest, TexStorageAttribs2DEXT)
	{
	ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_EXT_texture_storage_compression"));

	for (const GLint *attribs : kDefaultAttribList)
	{
	basicTestHelper(attribs);
	}
	}

	void TextureFixedRateCompressionTest::RenderToTexture(const GLenum internalFormat,
	const GLint *attribs)
	{
	GLint compressRate = 0;
	ASSERT(attribs != nullptr);

	GLTexture texture;
	glBindTexture(GL_TEXTURE_2D, texture);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	ASSERT_GL_NO_ERROR();

	glTexStorageAttribs2DEXT(GL_TEXTURE_2D, 1, internalFormat, 16, 16, attribs);
	ASSERT_GL_NO_ERROR();

	GLFramebuffer fbo;
	glBindFramebuffer(GL_FRAMEBUFFER, fbo);
	ASSERT_GL_NO_ERROR();
	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
	ASSERT_GL_NO_ERROR();
	ASSERT_GL_FRAMEBUFFER_COMPLETE(GL_FRAMEBUFFER);

	// Query and check the compression rate
	glGetTexParameteriv(GL_TEXTURE_2D, GL_SURFACE_COMPRESSION_EXT, &compressRate);
	ASSERT_GL_NO_ERROR();
	ASSERT_EQ(compressRate, attribs[1])
	<< "Compression rate of original texture: " << Name(compressRate);

	ANGLE_GL_PROGRAM(drawRed, essl1_shaders::vs::Simple(), essl1_shaders::fs::Red());
	drawQuad(drawRed, essl1_shaders::PositionAttrib(), 0);
	EXPECT_PIXEL_RECT_EQ(0, 0, 16, 16, GLColor::red);
	ASSERT_GL_NO_ERROR();

	// Query and check the compression rate after render
	glGetTexParameteriv(GL_TEXTURE_2D, GL_SURFACE_COMPRESSION_EXT, &compressRate);
	ASSERT_GL_NO_ERROR();
	ASSERT_EQ(compressRate, attribs[1])
	<< "Compression rate of texture after render: " << Name(compressRate);
	}

	// Test render to texture with fixed compression
	TEST_P(TextureFixedRateCompressionTest, RenderToTexture)
	{
	ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_EXT_texture_storage_compression"));

	static GLint attribList[] = {GL_SURFACE_COMPRESSION_EXT,
	GL_SURFACE_COMPRESSION_FIXED_RATE_1BPC_EXT, GL_NONE};
	GLint numRates = 0;
	constexpr GLenum internalFormats[] = {GL_RGBA4, GL_R8, GL_RG8, GL_RGB8, GL_RGBA8};

	for (GLenum internalFormat : internalFormats)
	{
	// Test attrib list generated from internal format query.
	glGetInternalformativ(GL_TEXTURE_2D, internalFormat,
	GL_NUM_SURFACE_COMPRESSION_FIXED_RATES_EXT, 1, &numRates);
	ASSERT_GL_NO_ERROR();
	if (numRates > 0)
	{
	std::vector<GLint> rates(numRates);
	glGetInternalformativ(GL_TEXTURE_2D, internalFormat, GL_SURFACE_COMPRESSION_EXT,
	numRates, rates.data());
	ASSERT_GL_NO_ERROR();

	for (int i = 0; i < numRates; ++i)
	{
	attribList[1] = rates[i];
	RenderToTexture(internalFormat, attribList);
	}
	}
	}
	}

	GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(TextureFixedRateCompressionTest);
	// Use this to select which configurations (e.g. which renderer, which GLES major version) these
	// tests should be run against.
	ANGLE_INSTANTIATE_TEST_ES31_AND(TextureFixedRateCompressionTest);

	} // namespace angle