Work in progress for cross platform image template through test heuri…

…stics

CMakeLists.txt

@@ -1,5 +1,8 @@
 cmake_minimum_required(VERSION 2.8 FATAL_ERROR)
 cmake_policy(VERSION 2.8)
+if (NOT CMAKE_VERSION VERSION_LESS "3.1")
+	cmake_policy(SET CMP0054 NEW)
+endif()
 
 set(OGL_SAMPLES_NAME ogl-samples)
 set(FRAMEWORK_NAME framework)

framework/compiler.cpp

@@ -94,7 +94,7 @@ std::string compiler::commandline::getDefines() const
 
 std::string compiler::parser::operator()(commandline const & CommandLine, std::string const & Filename) const
 {
-	std::string Source = loadFile(Filename);
+	std::string Source = load_file(Filename);
 	assert(!Source.empty());
 
 	std::stringstream Stream;
@@ -142,7 +142,7 @@ std::string compiler::parser::operator()(commandline const & CommandLine, std::s
 			for(std::size_t i = 0; i < Includes.size(); ++i)
 			{
 				std::string PathName = Includes[i] + Include;
-				std::string IncludeSource = loadFile(PathName);
+				std::string IncludeSource = load_file(PathName);
 				if (!IncludeSource.empty())
 				{
 					Text += IncludeSource;
@@ -224,7 +224,7 @@ bool compiler::destroy(GLuint const & Name)
 	return true;
 }
 
-bool compiler::validateProgram(GLuint ProgramName) const
+bool compiler::validate_program(GLuint ProgramName) const
 {
 	if(!ProgramName)
 		return false;
@@ -249,7 +249,7 @@ bool compiler::validateProgram(GLuint ProgramName) const
 	return Result == GL_TRUE;
 }
 
-bool compiler::checkProgram(GLuint ProgramName) const
+bool compiler::check_program(GLuint ProgramName) const
 {
 	if(!ProgramName)
 		return false;
@@ -320,7 +320,7 @@ void compiler::clear()
 	this->PendingChecks.clear();
 }
 
-std::string loadFile(std::string const & Filename)
+std::string load_file(std::string const & Filename)
 {
 	std::string Result;
 
@@ -339,7 +339,7 @@ std::string loadFile(std::string const & Filename)
 	return Result;
 }
 
-bool loadBinary
+bool load_binary
 (
 	std::string const & Filename,
 	GLenum & Format,
@@ -353,17 +353,20 @@ bool loadBinary
 	{
 		fread(&Format, sizeof(GLenum), 1, File);
 		fread(&Size, sizeof(Size), 1, File);
-		Data.resize(Size);
-		fread(&Data[0], Size, 1, File);
+		if(Size > 0)
+		{
+			Data.resize(Size);
+			fread(&Data[0], Size, 1, File);
+			return true;
+		}
 		fclose(File);
-		return true;
 	}
 	return false;
 }
 
-bool saveBinary
+bool save_binary
 (
-	std::string const & Filename, 
+	std::string const & Filename,
 	GLenum const & Format,
 	std::vector<glm::uint8> const & Data,
 	GLint const & Size

framework/compiler.hpp

@@ -78,8 +78,8 @@ class compiler
 	GLuint create(GLenum Type, std::string const & Filename, std::string const & Arguments = std::string());
 	bool destroy(GLuint const & Name);
 
-	bool checkProgram(GLuint ProgramName) const;
-	bool validateProgram(GLuint ProgramName) const;
+	bool check_program(GLuint ProgramName) const;
+	bool validate_program(GLuint ProgramName) const;
 
 	bool check();
 	// TODO: Not defined
@@ -92,6 +92,6 @@ class compiler
 	names_map PendingChecks;
 };
 
-std::string loadFile(std::string const & Filename);
-bool loadBinary(std::string const & Filename, GLenum & Format, std::vector<glm::uint8> & Data, GLint & Size);
-bool saveBinary(std::string const & Filename, GLenum const & Format, std::vector<glm::uint8> const & Data, GLint const & Size);
+std::string load_file(std::string const & Filename);
+bool load_binary(std::string const & Filename, GLenum & Format, std::vector<glm::uint8> & Data, GLint & Size);
+bool save_binary(std::string const & Filename, GLenum const & Format, std::vector<glm::uint8> const & Data, GLint const & Size);

framework/test.cpp

@@ -24,6 +24,7 @@
 #include "test.hpp"
 #include "png.hpp"
 #include <glm/gtc/matrix_transform.hpp>
+#include <gli/generate_mipmaps.hpp>
 #include <fstream>
 
 namespace
@@ -359,7 +360,7 @@ glm::vec3 test::cameraPosition() const
 
 namespace
 {
-	gli::texture absolute_difference(gli::texture const & A, gli::texture const & B)
+	gli::texture absolute_difference(gli::texture const& A, gli::texture const& B, glm::u8 Scale)
 	{
 		assert(A.format() == gli::FORMAT_RGB8_UNORM_PACK8 && B.format() == gli::FORMAT_RGB8_UNORM_PACK8);
 
@@ -368,11 +369,84 @@ namespace
 		{
 			glm::u8vec3 const TexelA = *(A.data<glm::u8vec3>() + TexelIndex);
 			glm::u8vec3 const TexelB = *(B.data<glm::u8vec3>() + TexelIndex);
-			glm::u8vec3 const TexelResult = glm::mix(TexelA - TexelB, TexelB - TexelA, glm::greaterThan(TexelB, TexelA)) * glm::u8vec3(8);
+			glm::u8vec3 const TexelResult = glm::mix(TexelA - TexelB, TexelB - TexelA, glm::greaterThan(TexelB, TexelA)) * glm::u8vec3(Scale);
 			*(Result.data<glm::u8vec3>() + TexelIndex) = TexelResult;
 		}
 		return Result;
 	}
+
+	struct heuristic
+	{
+		virtual bool test(gli::texture const& A, gli::texture const& B) const = 0;
+	};
+
+	struct heuristic_equal : public heuristic
+	{
+		bool test(gli::texture const& A, gli::texture const& B) const override
+		{
+			return A == B;
+		}
+	};
+
+	struct heuristic_absolute_difference_max_one
+	{
+		bool test(gli::texture const& A, gli::texture const& B) const
+		{
+			gli::texture Texture = absolute_difference(A, B, 1);
+			glm::u8vec3 AbsDiffMax(0);
+			glm::u32vec3 AbsDiffCount(0);
+			for(std::size_t TexelIndex = 0, TexelCount = Texture.size<glm::u8vec3>(); TexelIndex < TexelCount; ++TexelIndex)
+			{
+				glm::u8vec3 AbsDiff = *(Texture.data<glm::u8vec3>() + TexelIndex);
+				if(AbsDiff.x > 0)
+					++AbsDiffCount.x;
+				if(AbsDiff.y > 0)
+					++AbsDiffCount.y;
+				if(AbsDiff.z > 0)
+					++AbsDiffCount.z;
+				AbsDiffMax = glm::max(AbsDiff, AbsDiffMax);
+			}
+			return glm::all(glm::lessThanEqual(AbsDiffMax, glm::u8vec3(1)));
+		}
+	};
+
+	struct heuristic_mipmaps_absolute_difference_max_one
+	{
+		bool test(gli::texture const& A, gli::texture const& B) const
+		{
+			gli::texture2d TextureA(A);
+			gli::texture2d TextureB(B);
+			gli::texture2d MipmapsA(TextureA.format(), TextureA.extent());
+			gli::texture2d MipmapsB(TextureB.format(), TextureB.extent());
+			memcpy(MipmapsA.data(), TextureA.data(), TextureA.size());
+			memcpy(MipmapsB.data(), TextureB.data(), TextureB.size());
+			gli::texture2d GeneratedA = gli::generate_mipmaps(MipmapsA, gli::FILTER_LINEAR);
+			gli::texture2d GeneratedB = gli::generate_mipmaps(MipmapsB, gli::FILTER_LINEAR);
+			gli::texture ViewA = gli::view(GeneratedA, 3, 3);
+			gli::texture ViewB = gli::view(GeneratedB, 3, 3);
+			gli::texture Texture = absolute_difference(ViewA, ViewB, 1);
+			glm::u8vec3 AbsDiffMax(0);
+			glm::u32vec3 AbsDiffCount(0);
+			for(std::size_t TexelIndex = 0, TexelCount = Texture.size<glm::u8vec3>(); TexelIndex < TexelCount; ++TexelIndex)
+			{
+				glm::u8vec3 AbsDiff = *(Texture.data<glm::u8vec3>() + TexelIndex);
+				if(AbsDiff.x > 0)
+					++AbsDiffCount.x;
+				if(AbsDiff.y > 0)
+					++AbsDiffCount.y;
+				if(AbsDiff.z > 0)
+					++AbsDiffCount.z;
+				AbsDiffMax = glm::max(AbsDiff, AbsDiffMax);
+			}
+			return glm::all(glm::lessThanEqual(AbsDiffMax, glm::u8vec3(1)));
+		}
+	};
+
+	template <typename heuristic>
+	bool compare(gli::texture const& A, gli::texture const& B, heuristic const& Euristic)
+	{
+		return Euristic.test(A, B);
+	}
 }//namespace
 
 bool test::checkTemplate(GLFWwindow* pWindow, char const * Title)
@@ -415,18 +489,15 @@ bool test::checkTemplate(GLFWwindow* pWindow, char const * Title)
 		gli::texture Template(load_png((getDataDirectory() + "templates/" + Title + ".png").c_str()));
 
 		if(Success)
-		{
 			Success = Success && !Template.empty();
 
-		}
-
 		if(Success)
-			Success = Success && (Template == TextureRGB);
+			Success = Success && compare(Template, TextureRGB, heuristic_mipmaps_absolute_difference_max_one());
 
 		// Save abs diff
 		if(!Success && !Template.empty())
 		{
-			gli::texture Diff = ::absolute_difference(Template, TextureRGB);
+			gli::texture Diff = ::absolute_difference(Template, TextureRGB, 8);
 			save_png(Template, (getBinaryDirectory() + "/" + Title + "-template.png").c_str());
 			save_png(TextureRGB, (getBinaryDirectory() + "/" + Title + "-generated.png").c_str());
 			save_png(gli::texture2d(Diff), (getBinaryDirectory() + "/" + Title + "-diff.png").c_str());

micro/test_buffer.cpp

@@ -558,7 +558,7 @@ class test_buffer : public test
 			glLinkProgram(this->ProgramName);
 
 			Validated = Validated && Compiler.check();
-			Validated = Validated && Compiler.checkProgram(this->ProgramName);
+			Validated = Validated && Compiler.check_program(this->ProgramName);
 		}
 
 		if(Validated)

micro/test_buffer_interleaved.cpp

@@ -621,7 +621,7 @@ class test_buffer_interleaved : public test
 			glLinkProgram(this->ProgramName);
 
 			Validated = Validated && Compiler.check();
-			Validated = Validated && Compiler.checkProgram(this->ProgramName);
+			Validated = Validated && Compiler.check_program(this->ProgramName);
 		}
 
 		if(Validated)

micro/test_buffer_separated.cpp

@@ -387,7 +387,7 @@ class test_buffer_separated : public test
 			glLinkProgram(this->ProgramName);
 
 			Validated = Validated && Compiler.check();
-			Validated = Validated && Compiler.checkProgram(this->ProgramName);
+			Validated = Validated && Compiler.check_program(this->ProgramName);
 		}
 
 		if(Validated)

micro/test_compiler.cpp

@@ -102,7 +102,7 @@ bool testCompiler::render()
 
 			Compiler.check();
 			for(std::size_t ProgramIndex = 0; ProgramIndex < ProgramName.size(); ++ProgramIndex)
-				Compiler.checkProgram(ProgramName[ProgramIndex]);
+				Compiler.check_program(ProgramName[ProgramIndex]);
 		}
 		break;
 		case DUALTHREADED:
@@ -120,7 +120,7 @@ bool testCompiler::render()
 				glAttachShader(ProgramName[ProgramIndex], VertShaderName[ProgramIndex]);
 				glAttachShader(ProgramName[ProgramIndex], FragShaderName[ProgramIndex]);
 				glLinkProgram(ProgramName[ProgramIndex]);
-				Compiler.checkProgram(ProgramName[ProgramIndex]);
+				Compiler.check_program(ProgramName[ProgramIndex]);
 			}
 		}
 		break;
@@ -136,7 +136,7 @@ bool testCompiler::render()
 				glAttachShader(ProgramName[ProgramIndex], VertShaderName[ProgramIndex]);
 				glAttachShader(ProgramName[ProgramIndex], FragShaderName[ProgramIndex]);
 				glLinkProgram(ProgramName[ProgramIndex]);
-				Compiler.checkProgram(ProgramName[ProgramIndex]);
+				Compiler.check_program(ProgramName[ProgramIndex]);
 			}
 		}
 		break;

micro/test_draw_arrays.cpp

@@ -127,7 +127,7 @@ bool testDrawArrays::initProgram()
 	glAttachShader(this->ProgramName, VertShaderName);
 	glAttachShader(this->ProgramName, FragShaderName);
 	glLinkProgram(this->ProgramName);
-	Validated = Validated && Compiler.checkProgram(this->ProgramName);
+	Validated = Validated && Compiler.check_program(this->ProgramName);
 
 	UniformDiffuse0 = glGetUniformLocation(ProgramName, "Diffuse0");
 	UniformDiffuse1 = glGetUniformLocation(ProgramName, "Diffuse1");

micro/test_draw_arrays_vao.cpp

@@ -100,7 +100,7 @@ bool testDrawArraysVAO::initProgram()
 	glAttachShader(this->ProgramName, VertShaderName);
 	glAttachShader(this->ProgramName, FragShaderName);
 	glLinkProgram(this->ProgramName);
-	Validated = Validated && Compiler.checkProgram(this->ProgramName);
+	Validated = Validated && Compiler.check_program(this->ProgramName);
 
 	if(Validated)
 	{

micro/test_draw_call.cpp

@@ -121,7 +121,7 @@ class test_draw_call : public test
 			glLinkProgram(this->ProgramName);
 
 			Validated = Validated && Compiler.check();
-			Validated = Validated && Compiler.checkProgram(this->ProgramName);
+			Validated = Validated && Compiler.check_program(this->ProgramName);
 		}
 
 		if(Validated)

micro/test_draw_elements.cpp

@@ -101,7 +101,7 @@ bool testDrawElements::initProgram()
 	glAttachShader(this->ProgramName, VertShaderName);
 	glAttachShader(this->ProgramName, FragShaderName);
 	glLinkProgram(this->ProgramName);
-	Validated = Validated && Compiler.checkProgram(this->ProgramName);
+	Validated = Validated && Compiler.check_program(this->ProgramName);
 
 	if(Validated)
 		glUseProgramStages(this->PipelineName, GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName);

micro/test_draw_indexing.cpp

@@ -94,7 +94,7 @@ bool testDrawIndexing::initProgram()
 		glAttachShader(this->ProgramName, VertShaderName);
 		glAttachShader(this->ProgramName, FragShaderName);
 		glLinkProgram(this->ProgramName);
-		Validated = Validated && Compiler.checkProgram(this->ProgramName);
+		Validated = Validated && Compiler.check_program(this->ProgramName);
 	}
 
 	if(Validated)

micro/test_screenspace_coherence.cpp

@@ -89,7 +89,7 @@ bool testScreenspaceCoherence::initProgram()
 	glAttachShader(this->ProgramName, VertShaderName);
 	glAttachShader(this->ProgramName, FragShaderName);
 	glLinkProgram(this->ProgramName);
-	Validated = Validated && Compiler.checkProgram(this->ProgramName);
+	Validated = Validated && Compiler.check_program(this->ProgramName);
 
 	if(Validated)
 		glUseProgramStages(this->PipelineName, GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName);

micro/test_small_primitive.cpp

@@ -111,7 +111,7 @@ class test_small_primitive : public test
 			glLinkProgram(this->ProgramName);
 
 			Validated = Validated && Compiler.check();
-			Validated = Validated && Compiler.checkProgram(this->ProgramName);
+			Validated = Validated && Compiler.check_program(this->ProgramName);
 		}
 
 		if(Validated)

micro/test_uniform_caching.cpp

@@ -112,7 +112,7 @@ class test_uniform_caching : public test
 			glLinkProgram(this->ProgramName);
 
 			Validated = Validated && Compiler.check();
-			Validated = Validated && Compiler.checkProgram(this->ProgramName);
+			Validated = Validated && Compiler.check_program(this->ProgramName);
 		}
 
 		if(Validated)

tests/CMakeLists.txt

@@ -424,6 +424,8 @@ set(GL_SHADER_GTC query-occlusion.vert query-occlusion.frag)
 glCreateSampleGTC(query-occlusion)
 set(GL_SHADER_GTC sampler-wrap.vert sampler-wrap.frag)
 glCreateSampleGTC(sampler-wrap)
+set(GL_SHADER_GTC sampler-wrap.vert sampler-wrap.frag)
+glCreateSampleGTC(sampler-wrap-ext)
 set(GL_SHADER_GTC texture-2d.vert texture-2d.frag)
 glCreateSampleGTC(texture-compressed)
 set(GL_SHADER_GTC transform-feedback-transform.vert transform-feedback-feedback.vert transform-feedback-feedback.frag)

tests/es-200-draw-elements.cpp

@@ -89,7 +89,7 @@ class es_200_draw_elements : public test
 			glLinkProgram(ProgramName);
 
 			Validated = Validated && Compiler.check();
-			Validated = Validated && Compiler.checkProgram(ProgramName);
+			Validated = Validated && Compiler.check_program(ProgramName);
 		}
 
 		// Get variables locations

tests/es-300-draw-elements.cpp

@@ -92,7 +92,7 @@ class es_300_draw_elements : public test
 			glLinkProgram(ProgramName);
 
 			Validated = Validated && Compiler.check();
-			Validated = Validated && Compiler.checkProgram(ProgramName);
+			Validated = Validated && Compiler.check_program(ProgramName);
 		}
 
 		// Get variables locations

tests/es-300-fbo-srgb.cpp

@@ -147,8 +147,8 @@ class es_300_fbo_srgb : public test
 		if(Validated)
 		{
 			Validated = Validated && Compiler.check();
-			Validated = Validated && Compiler.checkProgram(ProgramName[program::TEXTURE]);
-			Validated = Validated && Compiler.checkProgram(ProgramName[program::SPLASH]);
+			Validated = Validated && Compiler.check_program(ProgramName[program::TEXTURE]);
+			Validated = Validated && Compiler.check_program(ProgramName[program::SPLASH]);
 		}
 
 		if(Validated)