host/tests/GLSnapshotVertexAttributes_unittest.cpp - platform/hardware/google/gfxstream - Git at Google

 // Copyright (C) 2018 The Android Open Source Project
 //
 // 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.

 #include "GLSnapshotTestStateUtils.h"
 #include "GLSnapshotTesting.h"
 #include "OpenGLTestContext.h"

 #include <gtest/gtest.h>

 #include <algorithm>

 namespace gfxstream {
 namespace gl {
 namespace {

 enum class GlVertexAttribMode { SingleValue = 0, Array = 1, Buffer = 2 };

 struct GlVertexAttrib {
     GlVertexAttribMode mode;
     GlValues values;
     GLint size;
     GLenum type;
     GLboolean normalized;
     GLsizei stride;
     GLboolean enabled;
     GLvoid* pointer;
     GLuint bufferBinding;
 };

 static const GlVertexAttrib kGLES2DefaultVertexAttrib = {
         .mode = GlVertexAttribMode::SingleValue,
         .values = {.ints = {}, .floats = {0, 0, 0, 1}},
         .size = 4,
         .type = GL_FLOAT,
         .normalized = GL_FALSE,
         .stride = 0,
         .enabled = GL_FALSE,
         .pointer = nullptr,
         .bufferBinding = 0};

 static const GlBufferData kTestAttachedBuffer = {.size = 16,
                                                  .bytes = nullptr,
                                                  .usage = GL_STATIC_DRAW};

 class SnapshotGlVertexAttributesTest
     : public SnapshotSetValueTest<GlVertexAttrib> {
 public:
     virtual void stateCheck(GlVertexAttrib expected) override {
         EXPECT_TRUE(compareIntParameter(GL_VERTEX_ATTRIB_ARRAY_ENABLED,
                                         expected.enabled));
     }

     virtual void stateChange() override {
         GlVertexAttrib changed = *m_changed_value;
         if (changed.enabled) {
             gl->glEnableVertexAttribArray(m_index);
         } else {
             gl->glDisableVertexAttribArray(m_index);
         }
         EXPECT_EQ(GL_NO_ERROR, gl->glGetError());
     }

     void selectIndex(GLuint index) {
         GLint maxAttribs;
         gl->glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxAttribs);
         EXPECT_EQ(GL_NO_ERROR, gl->glGetError());
         if (index >= maxAttribs) {
             fprintf(stderr,
                     "cannot select index %d: GL_MAX_VERTEX_ATTRIBS is %d.\n",
                     index, maxAttribs);
             return;
         }
         m_index = index;
     }

 protected:
     testing::AssertionResult compareFloatParameter(GLenum paramName,
                                                    GLfloat expected) {
         std::vector<GLfloat> v = {expected};
         return compareFloatParameter(paramName, v);
     }

     testing::AssertionResult compareFloatParameter(
             GLenum paramName,
             const std::vector<GLfloat>& expected) {
         std::vector<GLfloat> values;
         values.resize(std::max((GLuint)4, (GLuint)expected.size()));
         gl->glGetVertexAttribfv(m_index, paramName, &(values[0]));
         EXPECT_EQ(GL_NO_ERROR, gl->glGetError());
         return compareVector<GLfloat>(
                 expected, values,
                 "float(s) for parameter " + describeGlEnum(paramName) +
                         " of vertex attribute " + std::to_string(m_index));
     }

     testing::AssertionResult compareIntParameter(GLenum paramName,
                                                  GLint expected) {
         std::vector<GLint> v = {expected};
         return compareIntParameter(paramName, v);
     }

     testing::AssertionResult compareIntParameter(
             GLenum paramName,
             const std::vector<GLint>& expected) {
         std::vector<GLint> values;
         values.resize(std::max((GLuint)4, (GLuint)expected.size()));
         gl->glGetVertexAttribiv(m_index, paramName, &(values[0]));
         EXPECT_EQ(GL_NO_ERROR, gl->glGetError());
         return compareVector<GLint>(
                 expected, values,
                 "int(s) for parameter " + describeGlEnum(paramName) +
                         " of vertex attribute " + std::to_string(m_index));
     }

     GLuint m_index = 0;
 };

 class SnapshotGlVertexAttribSingleValueTest
     : public SnapshotGlVertexAttributesTest {
 public:
     void stateCheck(GlVertexAttrib expected) override {
         SnapshotGlVertexAttributesTest::stateCheck(expected);

         // check current element value
         switch (expected.type) {
             case GL_BYTE:
             case GL_UNSIGNED_BYTE:
             case GL_SHORT:
             case GL_UNSIGNED_SHORT:
             case GL_FIXED:
                 EXPECT_TRUE(compareIntParameter(GL_CURRENT_VERTEX_ATTRIB,
                                                 expected.values.ints));
                 break;
             case GL_FLOAT:
                 EXPECT_TRUE(compareFloatParameter(GL_CURRENT_VERTEX_ATTRIB,
                                                   expected.values.floats));
                 break;
             default:
                 ADD_FAILURE() << "Unexpected type " << expected.type
                               << " for vertex attribute " << m_index;
         }
     }

     void stateChange() override {
         SnapshotGlVertexAttributesTest::stateChange();
         GlVertexAttrib changed = *m_changed_value;
         switch (changed.type) {
             case GL_BYTE:
             case GL_UNSIGNED_BYTE:
             case GL_SHORT:
             case GL_UNSIGNED_SHORT:
             case GL_FIXED:
                 // TODO(benzene): support GLES3+
                 FAIL() << "GLES2 only supports float vertex attributes "
                           "(VertexAttrib{1234}f).";
             case GL_FLOAT:
                 switch (changed.values.floats.size()) {
                     case 1:
                         gl->glVertexAttrib1fv(
                                 m_index, (GLfloat*)&changed.values.floats[0]);
                         break;
                     case 2:
                         gl->glVertexAttrib2fv(
                                 m_index, (GLfloat*)&changed.values.floats[0]);
                         break;
                     case 3:
                         gl->glVertexAttrib3fv(
                                 m_index, (GLfloat*)&changed.values.floats[0]);
                         break;
                     case 4:
                         gl->glVertexAttrib4fv(
                                 m_index, (GLfloat*)&changed.values.floats[0]);
                         break;
                     default:
                         ADD_FAILURE() << "Unsupported size " << changed.size
                                       << " for vertex attribute " << m_index;
                 }
                 break;
             default:
                 ADD_FAILURE() << "Unsupported type " << changed.type
                               << " for vertex attribute " << m_index;
         }
     }
 };

 class SnapshotGlVertexAttribArrayTest : public SnapshotGlVertexAttributesTest {
 public:
     virtual void stateCheck(GlVertexAttrib expected) override {
         SnapshotGlVertexAttributesTest::stateCheck(expected);
         // check parameters
         EXPECT_TRUE(compareIntParameter(GL_VERTEX_ATTRIB_ARRAY_SIZE,
                                         expected.size));
         EXPECT_TRUE(compareIntParameter(GL_VERTEX_ATTRIB_ARRAY_TYPE,
                                         expected.type));
         EXPECT_TRUE(compareIntParameter(GL_VERTEX_ATTRIB_ARRAY_STRIDE,
                                         expected.stride));
         EXPECT_TRUE(compareIntParameter(GL_VERTEX_ATTRIB_ARRAY_NORMALIZED,
                                         expected.normalized));
         EXPECT_TRUE(compareIntParameter(GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING,
                                         expected.bufferBinding));

         GLvoid* pointer;
         gl->glGetVertexAttribPointerv(m_index, GL_VERTEX_ATTRIB_ARRAY_POINTER,
                                       &pointer);
         EXPECT_EQ(GL_NO_ERROR, gl->glGetError());
         EXPECT_EQ(expected.pointer, pointer);
     }

     virtual void stateChange() override {
         SnapshotGlVertexAttributesTest::stateChange();
         GlVertexAttrib changed = *m_changed_value;
         gl->glVertexAttribPointer(m_index, changed.size, changed.type,
                                   changed.normalized, changed.stride,
                                   changed.pointer);
     }
 };

 class SnapshotGlVertexAttribBufferTest
     : public SnapshotGlVertexAttribArrayTest {
 public:
     void stateCheck(GlVertexAttrib expected) override {
         SnapshotGlVertexAttribArrayTest::stateCheck(expected);
     }

     void stateChange() override {
         GlVertexAttrib changed = *m_changed_value;

         // Set up buffer to be bound before glVertexAttribPointer,
         // which will copy ARRAY_BUFFER_BINDING into the attrib's binding
         if (gl->glIsBuffer(changed.bufferBinding) == GL_TRUE) {
             gl->glBindBuffer(GL_ARRAY_BUFFER, changed.bufferBinding);
             EXPECT_EQ(GL_NO_ERROR, gl->glGetError())
                     << "Failed to bind buffer " << changed.bufferBinding;
             GLint bindresult;
             gl->glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &bindresult);
             EXPECT_EQ(GL_NO_ERROR, gl->glGetError());
         } else {
             ADD_FAILURE() << "Tried to bind buffer with vertex attributes but "
                           << changed.bufferBinding << " is not a valid buffer.";
         }

         SnapshotGlVertexAttribArrayTest::stateChange();

         if (changed.bufferBinding != 0) {
             // Clear the array buffer binding
             gl->glBindBuffer(GL_ARRAY_BUFFER, 0);
             EXPECT_EQ(GL_NO_ERROR, gl->glGetError());

             GLint bindresult;
             gl->glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &bindresult);
             EXPECT_EQ(GL_NO_ERROR, gl->glGetError());
         }
     }
 };

 TEST_F(SnapshotGlVertexAttribSingleValueTest, PreserveCurrentFloatAttrib) {
     selectIndex(31);
     GlVertexAttrib testAttrib = kGLES2DefaultVertexAttrib;
     testAttrib.values = {.ints = {}, .floats = {.1, .3}},
     setExpectedValues(kGLES2DefaultVertexAttrib, testAttrib);
     doCheckedSnapshot();
 }

 TEST_F(SnapshotGlVertexAttribArrayTest, DISABLED_PreserveArrayProperties) {
     selectIndex(5);
     GLfloat testArrayContents[] = {2.1f, 2.2f, 2.3f, 2.4f, 2.5f, 2.6f};
     GlVertexAttrib arrayAttrib = kGLES2DefaultVertexAttrib;
     arrayAttrib.mode = GlVertexAttribMode::Array;
     arrayAttrib.size = 3;
     arrayAttrib.stride = sizeof(GLfloat) * 3;
     arrayAttrib.normalized = GL_TRUE;
     arrayAttrib.enabled = GL_TRUE;
     arrayAttrib.pointer = testArrayContents;
     setExpectedValues(kGLES2DefaultVertexAttrib, arrayAttrib);
     doCheckedSnapshot();
 }

 TEST_F(SnapshotGlVertexAttribBufferTest, AttachArrayBuffer) {
     selectIndex(15);
     GLfloat testBuffContents[] = {
             0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f,
             0.9f, 1.0f, 1.1f, 1.2f, 1.3f, 1.4f, 1.5f, 1.6f,
     };
     GlBufferData data = kTestAttachedBuffer;
     data.bytes = testBuffContents;
     GLuint buffer = createBuffer(gl, data);
     GlVertexAttrib withBuffer = kGLES2DefaultVertexAttrib;
     withBuffer.mode = GlVertexAttribMode::Buffer;
     withBuffer.enabled = GL_TRUE;
     withBuffer.pointer = reinterpret_cast<GLvoid*>(2);  // offset
     withBuffer.bufferBinding = buffer;
     setExpectedValues(kGLES2DefaultVertexAttrib, withBuffer);
     doCheckedSnapshot();
 }

 }  // namespace
 }  // namespace gl
 }  // namespace gfxstream
	// Copyright (C) 2018 The Android Open Source Project
	//
	// 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.

	#include "GLSnapshotTestStateUtils.h"
	#include "GLSnapshotTesting.h"
	#include "OpenGLTestContext.h"

	#include <gtest/gtest.h>

	#include <algorithm>

	namespace gfxstream {
	namespace gl {
	namespace {

	enum class GlVertexAttribMode { SingleValue = 0, Array = 1, Buffer = 2 };

	struct GlVertexAttrib {
	GlVertexAttribMode mode;
	GlValues values;
	GLint size;
	GLenum type;
	GLboolean normalized;
	GLsizei stride;
	GLboolean enabled;
	GLvoid* pointer;
	GLuint bufferBinding;
	};

	static const GlVertexAttrib kGLES2DefaultVertexAttrib = {
	.mode = GlVertexAttribMode::SingleValue,
	.values = {.ints = {}, .floats = {0, 0, 0, 1}},
	.size = 4,
	.type = GL_FLOAT,
	.normalized = GL_FALSE,
	.stride = 0,
	.enabled = GL_FALSE,
	.pointer = nullptr,
	.bufferBinding = 0};

	static const GlBufferData kTestAttachedBuffer = {.size = 16,
	.bytes = nullptr,
	.usage = GL_STATIC_DRAW};

	class SnapshotGlVertexAttributesTest
	: public SnapshotSetValueTest<GlVertexAttrib> {
	public:
	virtual void stateCheck(GlVertexAttrib expected) override {
	EXPECT_TRUE(compareIntParameter(GL_VERTEX_ATTRIB_ARRAY_ENABLED,
	expected.enabled));
	}

	virtual void stateChange() override {
	GlVertexAttrib changed = *m_changed_value;
	if (changed.enabled) {
	gl->glEnableVertexAttribArray(m_index);
	} else {
	gl->glDisableVertexAttribArray(m_index);
	}
	EXPECT_EQ(GL_NO_ERROR, gl->glGetError());
	}

	void selectIndex(GLuint index) {
	GLint maxAttribs;
	gl->glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxAttribs);
	EXPECT_EQ(GL_NO_ERROR, gl->glGetError());
	if (index >= maxAttribs) {
	fprintf(stderr,
	"cannot select index %d: GL_MAX_VERTEX_ATTRIBS is %d.\n",
	index, maxAttribs);
	return;
	}
	m_index = index;
	}

	protected:
	testing::AssertionResult compareFloatParameter(GLenum paramName,
	GLfloat expected) {
	std::vector<GLfloat> v = {expected};
	return compareFloatParameter(paramName, v);
	}

	testing::AssertionResult compareFloatParameter(
	GLenum paramName,
	const std::vector<GLfloat>& expected) {
	std::vector<GLfloat> values;
	values.resize(std::max((GLuint)4, (GLuint)expected.size()));
	gl->glGetVertexAttribfv(m_index, paramName, &(values[0]));
	EXPECT_EQ(GL_NO_ERROR, gl->glGetError());
	return compareVector<GLfloat>(
	expected, values,
	"float(s) for parameter " + describeGlEnum(paramName) +
	" of vertex attribute " + std::to_string(m_index));
	}

	testing::AssertionResult compareIntParameter(GLenum paramName,
	GLint expected) {
	std::vector<GLint> v = {expected};
	return compareIntParameter(paramName, v);
	}

	testing::AssertionResult compareIntParameter(
	GLenum paramName,
	const std::vector<GLint>& expected) {
	std::vector<GLint> values;
	values.resize(std::max((GLuint)4, (GLuint)expected.size()));
	gl->glGetVertexAttribiv(m_index, paramName, &(values[0]));
	EXPECT_EQ(GL_NO_ERROR, gl->glGetError());
	return compareVector<GLint>(
	expected, values,
	"int(s) for parameter " + describeGlEnum(paramName) +
	" of vertex attribute " + std::to_string(m_index));
	}

	GLuint m_index = 0;
	};

	class SnapshotGlVertexAttribSingleValueTest
	: public SnapshotGlVertexAttributesTest {
	public:
	void stateCheck(GlVertexAttrib expected) override {
	SnapshotGlVertexAttributesTest::stateCheck(expected);

	// check current element value
	switch (expected.type) {
	case GL_BYTE:
	case GL_UNSIGNED_BYTE:
	case GL_SHORT:
	case GL_UNSIGNED_SHORT:
	case GL_FIXED:
	EXPECT_TRUE(compareIntParameter(GL_CURRENT_VERTEX_ATTRIB,
	expected.values.ints));
	break;
	case GL_FLOAT:
	EXPECT_TRUE(compareFloatParameter(GL_CURRENT_VERTEX_ATTRIB,
	expected.values.floats));
	break;
	default:
	ADD_FAILURE() << "Unexpected type " << expected.type
	<< " for vertex attribute " << m_index;
	}
	}

	void stateChange() override {
	SnapshotGlVertexAttributesTest::stateChange();
	GlVertexAttrib changed = *m_changed_value;
	switch (changed.type) {
	case GL_BYTE:
	case GL_UNSIGNED_BYTE:
	case GL_SHORT:
	case GL_UNSIGNED_SHORT:
	case GL_FIXED:
	// TODO(benzene): support GLES3+
	FAIL() << "GLES2 only supports float vertex attributes "
	"(VertexAttrib{1234}f).";
	case GL_FLOAT:
	switch (changed.values.floats.size()) {
	case 1:
	gl->glVertexAttrib1fv(
	m_index, (GLfloat*)&changed.values.floats[0]);
	break;
	case 2:
	gl->glVertexAttrib2fv(
	m_index, (GLfloat*)&changed.values.floats[0]);
	break;
	case 3:
	gl->glVertexAttrib3fv(
	m_index, (GLfloat*)&changed.values.floats[0]);
	break;
	case 4:
	gl->glVertexAttrib4fv(
	m_index, (GLfloat*)&changed.values.floats[0]);
	break;
	default:
	ADD_FAILURE() << "Unsupported size " << changed.size
	<< " for vertex attribute " << m_index;
	}
	break;
	default:
	ADD_FAILURE() << "Unsupported type " << changed.type
	<< " for vertex attribute " << m_index;
	}
	}
	};

	class SnapshotGlVertexAttribArrayTest : public SnapshotGlVertexAttributesTest {
	public:
	virtual void stateCheck(GlVertexAttrib expected) override {
	SnapshotGlVertexAttributesTest::stateCheck(expected);
	// check parameters
	EXPECT_TRUE(compareIntParameter(GL_VERTEX_ATTRIB_ARRAY_SIZE,
	expected.size));
	EXPECT_TRUE(compareIntParameter(GL_VERTEX_ATTRIB_ARRAY_TYPE,
	expected.type));
	EXPECT_TRUE(compareIntParameter(GL_VERTEX_ATTRIB_ARRAY_STRIDE,
	expected.stride));
	EXPECT_TRUE(compareIntParameter(GL_VERTEX_ATTRIB_ARRAY_NORMALIZED,
	expected.normalized));
	EXPECT_TRUE(compareIntParameter(GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING,
	expected.bufferBinding));

	GLvoid* pointer;
	gl->glGetVertexAttribPointerv(m_index, GL_VERTEX_ATTRIB_ARRAY_POINTER,
	&pointer);
	EXPECT_EQ(GL_NO_ERROR, gl->glGetError());
	EXPECT_EQ(expected.pointer, pointer);
	}

	virtual void stateChange() override {
	SnapshotGlVertexAttributesTest::stateChange();
	GlVertexAttrib changed = *m_changed_value;
	gl->glVertexAttribPointer(m_index, changed.size, changed.type,
	changed.normalized, changed.stride,
	changed.pointer);
	}
	};

	class SnapshotGlVertexAttribBufferTest
	: public SnapshotGlVertexAttribArrayTest {
	public:
	void stateCheck(GlVertexAttrib expected) override {
	SnapshotGlVertexAttribArrayTest::stateCheck(expected);
	}

	void stateChange() override {
	GlVertexAttrib changed = *m_changed_value;

	// Set up buffer to be bound before glVertexAttribPointer,
	// which will copy ARRAY_BUFFER_BINDING into the attrib's binding
	if (gl->glIsBuffer(changed.bufferBinding) == GL_TRUE) {
	gl->glBindBuffer(GL_ARRAY_BUFFER, changed.bufferBinding);
	EXPECT_EQ(GL_NO_ERROR, gl->glGetError())
	<< "Failed to bind buffer " << changed.bufferBinding;
	GLint bindresult;
	gl->glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &bindresult);
	EXPECT_EQ(GL_NO_ERROR, gl->glGetError());
	} else {
	ADD_FAILURE() << "Tried to bind buffer with vertex attributes but "
	<< changed.bufferBinding << " is not a valid buffer.";
	}

	SnapshotGlVertexAttribArrayTest::stateChange();

	if (changed.bufferBinding != 0) {
	// Clear the array buffer binding
	gl->glBindBuffer(GL_ARRAY_BUFFER, 0);
	EXPECT_EQ(GL_NO_ERROR, gl->glGetError());

	GLint bindresult;
	gl->glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &bindresult);
	EXPECT_EQ(GL_NO_ERROR, gl->glGetError());
	}
	}
	};

	TEST_F(SnapshotGlVertexAttribSingleValueTest, PreserveCurrentFloatAttrib) {
	selectIndex(31);
	GlVertexAttrib testAttrib = kGLES2DefaultVertexAttrib;
	testAttrib.values = {.ints = {}, .floats = {.1, .3}},
	setExpectedValues(kGLES2DefaultVertexAttrib, testAttrib);
	doCheckedSnapshot();
	}

	TEST_F(SnapshotGlVertexAttribArrayTest, DISABLED_PreserveArrayProperties) {
	selectIndex(5);
	GLfloat testArrayContents[] = {2.1f, 2.2f, 2.3f, 2.4f, 2.5f, 2.6f};
	GlVertexAttrib arrayAttrib = kGLES2DefaultVertexAttrib;
	arrayAttrib.mode = GlVertexAttribMode::Array;
	arrayAttrib.size = 3;
	arrayAttrib.stride = sizeof(GLfloat) * 3;
	arrayAttrib.normalized = GL_TRUE;
	arrayAttrib.enabled = GL_TRUE;
	arrayAttrib.pointer = testArrayContents;
	setExpectedValues(kGLES2DefaultVertexAttrib, arrayAttrib);
	doCheckedSnapshot();
	}

	TEST_F(SnapshotGlVertexAttribBufferTest, AttachArrayBuffer) {
	selectIndex(15);
	GLfloat testBuffContents[] = {
	0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f,
	0.9f, 1.0f, 1.1f, 1.2f, 1.3f, 1.4f, 1.5f, 1.6f,
	};
	GlBufferData data = kTestAttachedBuffer;
	data.bytes = testBuffContents;
	GLuint buffer = createBuffer(gl, data);
	GlVertexAttrib withBuffer = kGLES2DefaultVertexAttrib;
	withBuffer.mode = GlVertexAttribMode::Buffer;
	withBuffer.enabled = GL_TRUE;
	withBuffer.pointer = reinterpret_cast<GLvoid*>(2); // offset
	withBuffer.bufferBinding = buffer;
	setExpectedValues(kGLES2DefaultVertexAttrib, withBuffer);
	doCheckedSnapshot();
	}

	} // namespace
	} // namespace gl
	} // namespace gfxstream