Implement full occlusion queries for the Nexus 9.

GLES3 spec is worthless and only returns a boolean result for occlusion queries. This is fine for simple cellular games but we need more than a
boolean result.
Thankfully Nvidia exposes GL_NV_occlusion_queries under a OpenGL ES extension, which allows us to get full samples rendered.
The only device this change affects is the Nexus 9, since it is an Nvidia K1 crippled to only support OpenGL ES.
No other OpenGL ES device that I know of supports this extension.

1 files changed, 153 insertions, 38 deletions

diff --git a/Source/Core/VideoBackends/OGL/PerfQuery.cpp b/Source/Core/VideoBackends/OGL/PerfQuery.cpp
index 178ef7108e..372cd17cf8 100644
--- a/Source/Core/VideoBackends/OGL/PerfQuery.cpp
+++ b/Source/Core/VideoBackends/OGL/PerfQuery.cpp
@@ -9,24 +9,90 @@
 
 namespace OGL
 {
+PerfQueryBase* GetPerfQuery()
+{
+	if (GLInterface->GetMode() == GLInterfaceMode::MODE_OPENGLES3 &&
+	    GLExtensions::Supports("GL_NV_occlusion_query_samples"))
+		return new PerfQueryGLESNV();
+	else if (GLInterface->GetMode() == GLInterfaceMode::MODE_OPENGLES3)
+		return new PerfQueryGL(GL_ANY_SAMPLES_PASSED);
+	else
+		return new PerfQueryGL(GL_SAMPLES_PASSED);
+}
 
 PerfQuery::PerfQuery()
 	: m_query_read_pos()
 	, m_query_count()
 {
+	ResetQuery();
+}
+
+void PerfQuery::EnableQuery(PerfQueryGroup type)
+{
+	m_query->EnableQuery(type);
+}
+
+void PerfQuery::DisableQuery(PerfQueryGroup type)
+{
+	m_query->DisableQuery(type);
+}
+
+bool PerfQuery::IsFlushed() const
+{
+	return 0 == m_query_count;
+}
+
+// TODO: could selectively flush things, but I don't think that will do much
+void PerfQuery::FlushResults()
+{
+	m_query->FlushResults();
+}
+
+void PerfQuery::ResetQuery()
+{
+	m_query_count = 0;
+	std::fill_n(m_results, ArraySize(m_results), 0);
+}
+
+u32 PerfQuery::GetQueryResult(PerfQueryType type)
+{
+	u32 result = 0;
+
+	if (type == PQ_ZCOMP_INPUT_ZCOMPLOC || type == PQ_ZCOMP_OUTPUT_ZCOMPLOC)
+	{
+		result = m_results[PQG_ZCOMP_ZCOMPLOC];
+	}
+	else if (type == PQ_ZCOMP_INPUT || type == PQ_ZCOMP_OUTPUT)
+	{
+		result = m_results[PQG_ZCOMP];
+	}
+	else if (type == PQ_BLEND_INPUT)
+	{
+		result = m_results[PQG_ZCOMP] + m_results[PQG_ZCOMP_ZCOMPLOC];
+	}
+	else if (type == PQ_EFB_COPY_CLOCKS)
+	{
+		result = m_results[PQG_EFB_COPY_CLOCKS];
+	}
+
+	return result / 4;
+}
+
+// Implementations
+PerfQueryGL::PerfQueryGL(GLenum query_type)
+	: m_query_type(query_type)
+{
 	for (ActiveQuery& query : m_query_buffer)
 		glGenQueries(1, &query.query_id);
-
-	ResetQuery();
 }
 
-PerfQuery::~PerfQuery()
+PerfQueryGL::~PerfQueryGL()
 {
 	for (ActiveQuery& query : m_query_buffer)
 		glDeleteQueries(1, &query.query_id);
 }
 
-void PerfQuery::EnableQuery(PerfQueryGroup type)
+void PerfQueryGL::EnableQuery(PerfQueryGroup type)
 {
 	// Is this sane?
 	if (m_query_count > m_query_buffer.size() / 2)
@@ -43,28 +109,42 @@ void PerfQuery::EnableQuery(PerfQueryGroup type)
 	{
 		auto& entry = m_query_buffer[(m_query_read_pos + m_query_count) % m_query_buffer.size()];
 
-		glBeginQuery(GLInterface->GetMode() == GLInterfaceMode::MODE_OPENGL ? GL_SAMPLES_PASSED : GL_ANY_SAMPLES_PASSED, entry.query_id);
+		glBeginQuery(m_query_type, entry.query_id);
 		entry.query_type = type;
 
 		++m_query_count;
 	}
 }
-
-void PerfQuery::DisableQuery(PerfQueryGroup type)
+void PerfQueryGL::DisableQuery(PerfQueryGroup type)
 {
 	// stop query
 	if (type == PQG_ZCOMP_ZCOMPLOC || type == PQG_ZCOMP)
 	{
-		glEndQuery(GLInterface->GetMode() == GLInterfaceMode::MODE_OPENGL ? GL_SAMPLES_PASSED : GL_ANY_SAMPLES_PASSED);
+		glEndQuery(m_query_type);
 	}
 }
 
-bool PerfQuery::IsFlushed() const
+void PerfQueryGL::WeakFlush()
 {
-	return 0 == m_query_count;
+	while (!IsFlushed())
+	{
+		auto& entry = m_query_buffer[m_query_read_pos];
+
+		GLuint result = GL_FALSE;
+		glGetQueryObjectuiv(entry.query_id, GL_QUERY_RESULT_AVAILABLE, &result);
+
+		if (GL_TRUE == result)
+		{
+			FlushOne();
+		}
+		else
+		{
+			break;
+		}
+	}
 }
 
-void PerfQuery::FlushOne()
+void PerfQueryGL::FlushOne()
 {
 	auto& entry = m_query_buffer[m_query_read_pos];
 
@@ -79,20 +159,64 @@ void PerfQuery::FlushOne()
 }
 
 // TODO: could selectively flush things, but I don't think that will do much
-void PerfQuery::FlushResults()
+void PerfQueryGL::FlushResults()
 {
 	while (!IsFlushed())
 		FlushOne();
 }
 
-void PerfQuery::WeakFlush()
+PerfQueryGLESNV::PerfQueryGLESNV()
+{
+	for (ActiveQuery& query : m_query_buffer)
+		glGenOcclusionQueriesNV(1, &query.query_id);
+}
+
+PerfQueryGLESNV::~PerfQueryGLESNV()
+{
+	for (ActiveQuery& query : m_query_buffer)
+		glDeleteOcclusionQueriesNV(1, &query.query_id);
+}
+
+void PerfQueryGLESNV::EnableQuery(PerfQueryGroup type)
+{
+	// Is this sane?
+	if (m_query_count > m_query_buffer.size() / 2)
+		WeakFlush();
+
+	if (m_query_buffer.size() == m_query_count)
+	{
+		FlushOne();
+		//ERROR_LOG(VIDEO, "Flushed query buffer early!");
+	}
+
+	// start query
+	if (type == PQG_ZCOMP_ZCOMPLOC || type == PQG_ZCOMP)
+	{
+		auto& entry = m_query_buffer[(m_query_read_pos + m_query_count) % m_query_buffer.size()];
+
+		glBeginOcclusionQueryNV(entry.query_id);
+		entry.query_type = type;
+
+		++m_query_count;
+	}
+}
+void PerfQueryGLESNV::DisableQuery(PerfQueryGroup type)
+{
+	// stop query
+	if (type == PQG_ZCOMP_ZCOMPLOC || type == PQG_ZCOMP)
+	{
+		glEndOcclusionQueryNV();
+	}
+}
+
+void PerfQueryGLESNV::WeakFlush()
 {
 	while (!IsFlushed())
 	{
 		auto& entry = m_query_buffer[m_query_read_pos];
 
 		GLuint result = GL_FALSE;
-		glGetQueryObjectuiv(entry.query_id, GL_QUERY_RESULT_AVAILABLE, &result);
+		glGetOcclusionQueryuivNV(entry.query_id, GL_PIXEL_COUNT_AVAILABLE_NV, &result);
 
 		if (GL_TRUE == result)
 		{
@@ -105,34 +229,25 @@ void PerfQuery::WeakFlush()
 	}
 }
 
-void PerfQuery::ResetQuery()
+void PerfQueryGLESNV::FlushOne()
 {
-	m_query_count = 0;
-	std::fill_n(m_results, ArraySize(m_results), 0);
-}
+	auto& entry = m_query_buffer[m_query_read_pos];
 
-u32 PerfQuery::GetQueryResult(PerfQueryType type)
-{
-	u32 result = 0;
+	GLuint result = 0;
+	glGetOcclusionQueryuivNV(entry.query_id, GL_OCCLUSION_TEST_RESULT_HP, &result);
 
-	if (type == PQ_ZCOMP_INPUT_ZCOMPLOC || type == PQ_ZCOMP_OUTPUT_ZCOMPLOC)
-	{
-		result = m_results[PQG_ZCOMP_ZCOMPLOC];
-	}
-	else if (type == PQ_ZCOMP_INPUT || type == PQ_ZCOMP_OUTPUT)
-	{
-		result = m_results[PQG_ZCOMP];
-	}
-	else if (type == PQ_BLEND_INPUT)
-	{
-		result = m_results[PQG_ZCOMP] + m_results[PQG_ZCOMP_ZCOMPLOC];
-	}
-	else if (type == PQ_EFB_COPY_CLOCKS)
-	{
-		result = m_results[PQG_EFB_COPY_CLOCKS];
-	}
+	// NOTE: Reported pixel metrics should be referenced to native resolution
+	m_results[entry.query_type] += (u64)result * EFB_WIDTH / g_renderer->GetTargetWidth() * EFB_HEIGHT / g_renderer->GetTargetHeight();
 
-	return result / 4;
+	m_query_read_pos = (m_query_read_pos + 1) % m_query_buffer.size();
+	--m_query_count;
+}
+
+// TODO: could selectively flush things, but I don't think that will do much
+void PerfQueryGLESNV::FlushResults()
+{
+	while (!IsFlushed())
+		FlushOne();
 }
 
 } // namespace