modules/gles31/functional/es31fProgramInterfaceDefinition.cpp

/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL ES 3.1 Module
 * -------------------------------------------------
 *
 * Copyright 2014 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.
 *
 *//*!
 * \file
 * \brief Program interface
 *//*--------------------------------------------------------------------*/

#include "es31fProgramInterfaceDefinition.hpp"
#include "gluVarType.hpp"
#include "gluShaderProgram.hpp"
#include "deSTLUtil.hpp"
#include "glwEnums.hpp"

#include <set>

namespace deqp
{
namespace gles31
{
namespace Functional
{
namespace ProgramInterfaceDefinition
{
namespace
{

static const glu::ShaderType s_shaderStageOrder[] =
{
	glu::SHADERTYPE_COMPUTE,

	glu::SHADERTYPE_VERTEX,
	glu::SHADERTYPE_TESSELLATION_CONTROL,
	glu::SHADERTYPE_TESSELLATION_EVALUATION,
	glu::SHADERTYPE_GEOMETRY,
	glu::SHADERTYPE_FRAGMENT
};

// s_shaderStageOrder does not contain ShaderType_LAST
DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_shaderStageOrder) == glu::SHADERTYPE_LAST);

static bool containsMatchingSubtype (const glu::VarType& varType, bool (*predicate)(glu::DataType))
{
	if (varType.isBasicType() && predicate(varType.getBasicType()))
		return true;

	if (varType.isArrayType())
		return containsMatchingSubtype(varType.getElementType(), predicate);

	if (varType.isStructType())
		for (int memberNdx = 0; memberNdx < varType.getStructPtr()->getNumMembers(); ++memberNdx)
			if (containsMatchingSubtype(varType.getStructPtr()->getMember(memberNdx).getType(), predicate))
				return true;

	return false;
}

static bool containsMatchingSubtype (const std::vector<glu::VariableDeclaration>& decls, bool (*predicate)(glu::DataType))
{
	for (int varNdx = 0; varNdx < (int)decls.size(); ++varNdx)
		if (containsMatchingSubtype(decls[varNdx].varType, predicate))
			return true;
	return false;
}

static bool isOpaqueType (glu::DataType type)
{
	return	glu::isDataTypeAtomicCounter(type)	||
			glu::isDataTypeImage(type)			||
			glu::isDataTypeSampler(type);
}

static int getShaderStageIndex (glu::ShaderType stage)
{
	const glu::ShaderType* const it = std::find(DE_ARRAY_BEGIN(s_shaderStageOrder), DE_ARRAY_END(s_shaderStageOrder), stage);

	if (it == DE_ARRAY_END(s_shaderStageOrder))
		return -1;
	else
	{
		const int index = (int)(it - DE_ARRAY_BEGIN(s_shaderStageOrder));
		return index;
	}
}

} // anonymous

Shader::Shader (glu::ShaderType type, glu::GLSLVersion version)
	: m_shaderType	(type)
	, m_version		(version)
{
}

Shader::~Shader (void)
{
}

static bool isIllegalVertexInput (const glu::VarType& varType)
{
	// booleans, opaque types, arrays, structs are not allowed as inputs
	if (!varType.isBasicType())
		return true;
	if (glu::isDataTypeBoolOrBVec(varType.getBasicType()))
		return true;
	return false;
}

static bool isIllegalVertexOutput (const glu::VarType& varType, bool insideAStruct = false, bool insideAnArray = false)
{
	// booleans, opaque types, arrays of arrays, arrays of structs, array in struct, struct struct are not allowed as vertex outputs

	if (varType.isBasicType())
	{
		const bool isOpaqueType = !glu::isDataTypeScalar(varType.getBasicType()) && !glu::isDataTypeVector(varType.getBasicType()) && !glu::isDataTypeMatrix(varType.getBasicType());

		if (glu::isDataTypeBoolOrBVec(varType.getBasicType()))
			return true;

		if (isOpaqueType)
			return true;

		return false;
	}
	else if (varType.isArrayType())
	{
		if (insideAnArray || insideAStruct)
			return true;

		return isIllegalVertexOutput(varType.getElementType(), insideAStruct, true);
	}
	else if (varType.isStructType())
	{
		if (insideAnArray || insideAStruct)
			return true;

		for (int ndx = 0; ndx < varType.getStructPtr()->getNumMembers(); ++ndx)
			if (isIllegalVertexOutput(varType.getStructPtr()->getMember(ndx).getType(), true, insideAnArray))
				return true;

		return false;
	}
	else
	{
		DE_ASSERT(false);
		return true;
	}
}

static bool isIllegalFragmentInput (const glu::VarType& varType)
{
	return isIllegalVertexOutput(varType);
}

static bool isIllegalFragmentOutput (const glu::VarType& varType, bool insideAnArray = false)
{
	// booleans, opaque types, matrices, structs, arrays of arrays are not allowed as outputs

	if (varType.isBasicType())
	{
		const bool isOpaqueType = !glu::isDataTypeScalar(varType.getBasicType()) && !glu::isDataTypeVector(varType.getBasicType()) && !glu::isDataTypeMatrix(varType.getBasicType());

		if (glu::isDataTypeBoolOrBVec(varType.getBasicType()) || isOpaqueType || glu::isDataTypeMatrix(varType.getBasicType()))
			return true;
		return false;
	}
	else if (varType.isArrayType())
	{
		if (insideAnArray)
			return true;
		return isIllegalFragmentOutput(varType.getElementType(), true);
	}
	else if (varType.isStructType())
		return true;
	else
	{
		DE_ASSERT(false);
		return true;
	}
}

static bool isTypeIntegerOrContainsIntegers (const glu::VarType& varType)
{
	if (varType.isBasicType())
		return glu::isDataTypeIntOrIVec(varType.getBasicType()) || glu::isDataTypeUintOrUVec(varType.getBasicType());
	else if (varType.isArrayType())
		return isTypeIntegerOrContainsIntegers(varType.getElementType());
	else if (varType.isStructType())
	{
		for (int ndx = 0; ndx < varType.getStructPtr()->getNumMembers(); ++ndx)
			if (isTypeIntegerOrContainsIntegers(varType.getStructPtr()->getMember(ndx).getType()))
				return true;
		return false;
	}
	else
	{
		DE_ASSERT(false);
		return true;
	}
}

bool Shader::isValid (void) const
{
	// Default block variables
	{
		for (int varNdx = 0; varNdx < (int)m_defaultBlock.variables.size(); ++varNdx)
		{
			// atomic declaration in the default block without binding
			if (m_defaultBlock.variables[varNdx].layout.binding == -1 &&
				containsMatchingSubtype(m_defaultBlock.variables[varNdx].varType, glu::isDataTypeAtomicCounter))
				return false;

			// atomic declaration in a struct
			if (m_defaultBlock.variables[varNdx].varType.isStructType() &&
				containsMatchingSubtype(m_defaultBlock.variables[varNdx].varType, glu::isDataTypeAtomicCounter))
				return false;

			// Unsupported layout qualifiers

			if (m_defaultBlock.variables[varNdx].layout.matrixOrder != glu::MATRIXORDER_LAST)
				return false;

			if (containsMatchingSubtype(m_defaultBlock.variables[varNdx].varType, glu::isDataTypeSampler))
			{
				const glu::Layout layoutWithLocationAndBinding(m_defaultBlock.variables[varNdx].layout.location, m_defaultBlock.variables[varNdx].layout.binding);

				if (m_defaultBlock.variables[varNdx].layout != layoutWithLocationAndBinding)
					return false;
			}
		}
	}

	// Interface blocks
	{
		for (int interfaceNdx = 0; interfaceNdx < (int)m_defaultBlock.interfaceBlocks.size(); ++interfaceNdx)
		{
			// ES31 disallows interface block array arrays
			if (m_defaultBlock.interfaceBlocks[interfaceNdx].dimensions.size() > 1)
				return false;

			// Interface block arrays must have instance name
			if (!m_defaultBlock.interfaceBlocks[interfaceNdx].dimensions.empty() && m_defaultBlock.interfaceBlocks[interfaceNdx].instanceName.empty())
				return false;

			// Opaque types in interface block
			if (containsMatchingSubtype(m_defaultBlock.interfaceBlocks[interfaceNdx].variables, isOpaqueType))
				return false;
		}
	}

	// Shader type specific

	if (m_shaderType == glu::SHADERTYPE_VERTEX)
	{
		for (int varNdx = 0; varNdx < (int)m_defaultBlock.variables.size(); ++varNdx)
		{
			if (m_defaultBlock.variables[varNdx].storage == glu::STORAGE_IN && isIllegalVertexInput(m_defaultBlock.variables[varNdx].varType))
				return false;
			if (m_defaultBlock.variables[varNdx].storage == glu::STORAGE_OUT && isIllegalVertexOutput(m_defaultBlock.variables[varNdx].varType))
				return false;
			if (m_defaultBlock.variables[varNdx].storage == glu::STORAGE_OUT && m_defaultBlock.variables[varNdx].interpolation != glu::INTERPOLATION_FLAT && isTypeIntegerOrContainsIntegers(m_defaultBlock.variables[varNdx].varType))
				return false;
		}
	}
	else if (m_shaderType == glu::SHADERTYPE_FRAGMENT)
	{
		for (int varNdx = 0; varNdx < (int)m_defaultBlock.variables.size(); ++varNdx)
		{
			if (m_defaultBlock.variables[varNdx].storage == glu::STORAGE_IN && isIllegalFragmentInput(m_defaultBlock.variables[varNdx].varType))
				return false;
			if (m_defaultBlock.variables[varNdx].storage == glu::STORAGE_IN && m_defaultBlock.variables[varNdx].interpolation != glu::INTERPOLATION_FLAT && isTypeIntegerOrContainsIntegers(m_defaultBlock.variables[varNdx].varType))
				return false;
			if (m_defaultBlock.variables[varNdx].storage == glu::STORAGE_OUT && isIllegalFragmentOutput(m_defaultBlock.variables[varNdx].varType))
				return false;
		}
	}

	return true;
}

Program::Program (void)
	: m_separable	(false)
	, m_xfbMode		(0)
{
}

static void collectStructPtrs (std::set<const glu::StructType*>& dst, const glu::VarType& type)
{
	if (type.isArrayType())
		collectStructPtrs(dst, type.getElementType());
	else if (type.isStructType())
	{
		dst.insert(type.getStructPtr());

		for (int memberNdx = 0; memberNdx < type.getStructPtr()->getNumMembers(); ++memberNdx)
			collectStructPtrs(dst, type.getStructPtr()->getMember(memberNdx).getType());
	}
}

Program::~Program (void)
{
	// delete shader struct types, need to be done by the program since shaders might share struct types
	{
		std::set<const glu::StructType*> structTypes;

		for (int shaderNdx = 0; shaderNdx < (int)m_shaders.size(); ++shaderNdx)
		{
			for (int varNdx = 0; varNdx < (int)m_shaders[shaderNdx]->m_defaultBlock.variables.size(); ++varNdx)
				collectStructPtrs(structTypes, m_shaders[shaderNdx]->m_defaultBlock.variables[varNdx].varType);

			for (int interfaceNdx = 0; interfaceNdx < (int)m_shaders[shaderNdx]->m_defaultBlock.interfaceBlocks.size(); ++interfaceNdx)
				for (int varNdx = 0; varNdx < (int)m_shaders[shaderNdx]->m_defaultBlock.interfaceBlocks[interfaceNdx].variables.size(); ++varNdx)
					collectStructPtrs(structTypes, m_shaders[shaderNdx]->m_defaultBlock.interfaceBlocks[interfaceNdx].variables[varNdx].varType);
		}

		for (std::set<const glu::StructType*>::iterator it = structTypes.begin(); it != structTypes.end(); ++it)
			delete *it;
	}

	for (int shaderNdx = 0; shaderNdx < (int)m_shaders.size(); ++shaderNdx)
		delete m_shaders[shaderNdx];
	m_shaders.clear();
}

Shader* Program::addShader (glu::ShaderType type, glu::GLSLVersion version)
{
	Shader* shader;

	// make sure push_back() cannot throw
	m_shaders.reserve(m_shaders.size() + 1);

	shader = new Shader(type, version);
	m_shaders.push_back(shader);

	return shader;
}

void Program::setSeparable (bool separable)
{
	m_separable = separable;
}

bool Program::isSeparable (void) const
{
	return m_separable;
}

const std::vector<Shader*>& Program::getShaders (void) const
{
	return m_shaders;
}

glu::ShaderType Program::getFirstStage (void) const
{
	const int	nullValue	= DE_LENGTH_OF_ARRAY(s_shaderStageOrder);
	int			firstStage	= nullValue;

	for (int shaderNdx = 0; shaderNdx < (int)m_shaders.size(); ++shaderNdx)
	{
		const int index = getShaderStageIndex(m_shaders[shaderNdx]->getType());
		if (index != -1)
			firstStage = de::min(firstStage, index);
	}

	if (firstStage == nullValue)
		return glu::SHADERTYPE_LAST;
	else
		return s_shaderStageOrder[firstStage];
}

glu::ShaderType Program::getLastStage (void) const
{
	const int	nullValue	= -1;
	int			lastStage	= nullValue;

	for (int shaderNdx = 0; shaderNdx < (int)m_shaders.size(); ++shaderNdx)
	{
		const int index = getShaderStageIndex(m_shaders[shaderNdx]->getType());
		if (index != -1)
			lastStage = de::max(lastStage, index);
	}

	if (lastStage == nullValue)
		return glu::SHADERTYPE_LAST;
	else
		return s_shaderStageOrder[lastStage];
}

void Program::addTransformFeedbackVarying (const std::string& varName)
{
	m_xfbVaryings.push_back(varName);
}

const std::vector<std::string>& Program::getTransformFeedbackVaryings (void) const
{
	return m_xfbVaryings;
}

void Program::setTransformFeedbackMode (deUint32 mode)
{
	m_xfbMode = mode;
}

deUint32 Program::getTransformFeedbackMode (void) const
{
	return m_xfbMode;
}

bool Program::isValid (void) const
{
	bool computePresent = false;

	if (m_shaders.empty())
		return false;

	for (int ndx = 0; ndx < (int)m_shaders.size(); ++ndx)
		if (!m_shaders[ndx]->isValid())
			return false;

	// same version
	for (int ndx = 1; ndx < (int)m_shaders.size(); ++ndx)
		if (m_shaders[0]->getVersion() != m_shaders[ndx]->getVersion())
			return false;

	// compute present -> no other stages present
	{
		bool nonComputePresent = false;

		for (int ndx = 0; ndx < (int)m_shaders.size(); ++ndx)
		{
			if (m_shaders[ndx]->getType() == glu::SHADERTYPE_COMPUTE)
				computePresent = true;
			else
				nonComputePresent = true;
		}

		if (computePresent && nonComputePresent)
			return false;
	}

	// must contain both vertex and fragment shaders
	if (!computePresent && !m_separable)
	{
		bool vertexPresent = false;
		bool fragmentPresent = false;

		for (int ndx = 0; ndx < (int)m_shaders.size(); ++ndx)
		{
			if (m_shaders[ndx]->getType() == glu::SHADERTYPE_VERTEX)
				vertexPresent = true;
			else if (m_shaders[ndx]->getType() == glu::SHADERTYPE_FRAGMENT)
				fragmentPresent = true;
		}

		if (!vertexPresent || !fragmentPresent)
			return false;
	}

	// tess.Eval present <=> tess.Control present
	{
		bool tessEvalPresent = false;
		bool tessControlPresent = false;

		for (int ndx = 0; ndx < (int)m_shaders.size(); ++ndx)
		{
			if (m_shaders[ndx]->getType() == glu::SHADERTYPE_TESSELLATION_EVALUATION)
				tessEvalPresent = true;
			else if (m_shaders[ndx]->getType() == glu::SHADERTYPE_TESSELLATION_CONTROL)
				tessControlPresent = true;
		}

		if (tessEvalPresent != tessControlPresent)
			return false;
	}

	return true;
}

} // ProgramInterfaceDefinition
} // Functional
} // gles31
} // deqp