es31fShaderSharedVarTests.cpp - Android社区 - https://www.androidos.net.cn/

/*-------------------------------------------------------------------------
 * 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 GLSL Shared variable tests.
 *//*--------------------------------------------------------------------*/

#include "es31fShaderSharedVarTests.hpp"
#include "es31fShaderAtomicOpTests.hpp"
#include "gluShaderProgram.hpp"
#include "gluShaderUtil.hpp"
#include "gluRenderContext.hpp"
#include "gluObjectWrapper.hpp"
#include "gluProgramInterfaceQuery.hpp"
#include "tcuVector.hpp"
#include "tcuTestLog.hpp"
#include "tcuVectorUtil.hpp"
#include "tcuFormatUtil.hpp"
#include "deRandom.hpp"
#include "deArrayUtil.hpp"
#include "glwFunctions.hpp"
#include "glwEnums.hpp"

#include <algorithm>
#include <set>

namespace deqp
{
namespace gles31
{
namespace Functional
{

using std::string;
using std::vector;
using tcu::TestLog;
using tcu::UVec3;
using std::set;
using namespace glu;

enum
{
	MAX_VALUE_ARRAY_LENGTH	= 15	// * 2 * sizeof(mat4) + sizeof(int) = 481 uniform components (limit 512)
};

template<typename T, int Size>
static inline T product (const tcu::Vector<T, Size>& v)
{
	T res = v[0];
	for (int ndx = 1; ndx < Size; ndx++)
		res *= v[ndx];
	return res;
}

class SharedBasicVarCase : public TestCase
{
public:
							SharedBasicVarCase		(Context& context, const char* name, DataType basicType, Precision precision, const tcu::UVec3& workGroupSize);
							~SharedBasicVarCase		(void);

void					init					(void);
	void					deinit					(void);
	IterateResult			iterate					(void);

private:
							SharedBasicVarCase		(const SharedBasicVarCase& other);
	SharedBasicVarCase&		operator=				(const SharedBasicVarCase& other);

const DataType			m_basicType;
	const Precision			m_precision;
	const tcu::UVec3		m_workGroupSize;

ShaderProgram*			m_program;
};

static std::string getBasicCaseDescription (DataType basicType, Precision precision, const tcu::UVec3& workGroupSize)
{
	std::ostringstream str;
	if (precision != PRECISION_LAST)
		str << getPrecisionName(precision) << " ";
	str << getDataTypeName(basicType) << ", work group size = " << workGroupSize;
	return str.str();
}

SharedBasicVarCase::SharedBasicVarCase (Context& context, const char* name, DataType basicType, Precision precision, const tcu::UVec3& workGroupSize)
	: TestCase			(context, name, getBasicCaseDescription(basicType, precision, workGroupSize).c_str())
	, m_basicType		(basicType)
	, m_precision		(precision)
	, m_workGroupSize	(workGroupSize)
	, m_program			(DE_NULL)
{
}

SharedBasicVarCase::~SharedBasicVarCase (void)
{
	SharedBasicVarCase::deinit();
}

void SharedBasicVarCase::init (void)
{
	const int			valArrayLength	= de::min<int>(MAX_VALUE_ARRAY_LENGTH, product(m_workGroupSize));
	const char*			precName		= m_precision != glu::PRECISION_LAST ? getPrecisionName(m_precision) : "";
	const char*			typeName		= getDataTypeName(m_basicType);
	std::ostringstream	src;

src << "#version 310 es\n"
		<< "layout (local_size_x = " << m_workGroupSize[0]
		<< ", local_size_y = " << m_workGroupSize[1]
		<< ", local_size_z = " << m_workGroupSize[2]
		<< ") in;\n"
		<< "const uint LOCAL_SIZE = gl_WorkGroupSize.x*gl_WorkGroupSize.y*gl_WorkGroupSize.z;\n"
		<< "shared " << precName << " " << typeName << " s_var;\n"
		<< "uniform " << precName << " " << typeName << " u_val[" << valArrayLength << "];\n"
		<< "uniform " << precName << " " << typeName << " u_ref[" << valArrayLength << "];\n"
		<< "uniform uint u_numIters;\n"
		<< "layout(binding = 0) buffer Result\n"
		<< "{\n"
		<< "	bool isOk[LOCAL_SIZE];\n"
		<< "};\n"
		<< "\n"
		<< "void main (void)\n"
		<< "{\n"
		<< "	bool allOk = true;\n"
		<< "	for (uint ndx = 0u; ndx < u_numIters; ndx++)\n"
		<< "	{\n"
		<< "		if (ndx == gl_LocalInvocationIndex)\n"
		<< "			s_var = u_val[ndx%uint(u_val.length())];\n"
		<< "\n"
		<< "		barrier();\n"
		<< "\n"
		<< "		if (s_var != u_ref[ndx%uint(u_ref.length())])\n"
		<< "			allOk = false;\n"
		<< "\n"
		<< "		barrier();\n"
		<< "	}\n"
		<< "\n"
		<< "	isOk[gl_LocalInvocationIndex] = allOk;\n"
		<< "}\n";

DE_ASSERT(!m_program);
	m_program = new ShaderProgram(m_context.getRenderContext(), ProgramSources() << ComputeSource(src.str()));

m_testCtx.getLog() << *m_program;

if (!m_program->isOk())
	{
		delete m_program;
		m_program = DE_NULL;
		throw tcu::TestError("Compile failed");
	}
}

void SharedBasicVarCase::deinit (void)
{
	delete m_program;
	m_program = DE_NULL;
}

SharedBasicVarCase::IterateResult SharedBasicVarCase::iterate (void)
{
	const glw::Functions&		gl				= m_context.getRenderContext().getFunctions();
	const deUint32				program			= m_program->getProgram();
	Buffer						outputBuffer	(m_context.getRenderContext());
	const deUint32				outBlockNdx		= gl.getProgramResourceIndex(program, GL_SHADER_STORAGE_BLOCK, "Result");
	const InterfaceBlockInfo	outBlockInfo	= getProgramInterfaceBlockInfo(gl, program, GL_SHADER_STORAGE_BLOCK, outBlockNdx);

gl.useProgram(program);

// Setup input values.
	{
		const int		numValues		= (int)product(m_workGroupSize);
		const int		valLoc			= gl.getUniformLocation(program, "u_val[0]");
		const int		refLoc			= gl.getUniformLocation(program, "u_ref[0]");
		const int		iterCountLoc	= gl.getUniformLocation(program, "u_numIters");
		const int		scalarSize		= getDataTypeScalarSize(m_basicType);

if (isDataTypeFloatOrVec(m_basicType))
		{
			const int		maxInt			= m_precision == glu::PRECISION_LOWP ? 2 : 1024;
			const int		minInt			= -de::min(numValues/2, maxInt);
			vector<float>	values			(numValues*scalarSize);

for (int ndx = 0; ndx < (int)values.size(); ndx++)
				values[ndx] = float(minInt + (ndx % (maxInt-minInt+1)));