xref: /external/deqp/modules/gles3/functional/es3fShaderMatrixTests.cpp

/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL ES 3.0 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 Shader matrix arithmetic tests.
 *
 * Variables:
 *  + operation
 *    - mat OP mat
 *    - mat OP vec
 *    - vec OP mat
 *    - mat OP scalar
 *    - OP ( mat )
 *    - vec OP vec
 *    - OP mat
 *  + matrix source
 *    - constant (ctor)
 *    - uniform
 *    - vertex input
 *    - fragment input
 *  + other operand: always dynamic data?
 *  + how to reduce to vec3?
 *//*--------------------------------------------------------------------*/

#include "es3fShaderMatrixTests.hpp"
#include "glsShaderRenderCase.hpp"
#include "gluShaderUtil.hpp"
#include "tcuVector.hpp"
#include "tcuMatrix.hpp"
#include "tcuMatrixUtil.hpp"
#include "deStringUtil.hpp"

#include "glwEnums.hpp"
#include "glwFunctions.hpp"

namespace deqp
{
namespace gles3
{
namespace Functional
{

using std::string;
using std::vector;
using namespace glu;
using namespace deqp::gls;

using tcu::Vec2;
using tcu::Vec3;
using tcu::Vec4;
using tcu::Mat2;
using tcu::Mat2x3;
using tcu::Mat2x4;
using tcu::Mat3x2;
using tcu::Mat3;
using tcu::Mat3x4;
using tcu::Mat4x2;
using tcu::Mat4x3;
using tcu::Mat4;

// Uniform / constant values for tests.
// \note Input1 should not contain 0 components as it is used as divisor in div cases.
// \todo [2012-02-14 pyry] Make these dynamic.
static const float	s_constInFloat[2]	= { 0.5f, -0.2f };
static const Vec2	s_constInVec2[2]	= { Vec2(1.2f, 0.5f), Vec2(0.5f, 1.0f) };
static const Vec3	s_constInVec3[2]	= { Vec3(1.1f, 0.1f, 0.5f), Vec3(-0.2f, 0.5f, 0.8f) };
static const Vec4	s_constInVec4[2]	= { Vec4(1.4f, 0.2f, -0.5f, 0.7f), Vec4(0.2f, -1.0f, 0.5f, 0.8f) };

static const float s_constInMat2x2[2][4] =
{
	{
		-0.1f,  1.0f,
		-0.2f,  0.0f,
	},
	{
		 0.8f,  0.1f,
		 0.5f, -0.9f,
	},
};
static const float s_constInMat3x2[2][6] =
{
	{
		 0.8f, -0.3f,  0.3f,
		 1.0f,  1.2f, -1.2f,
	},
	{
		 1.2f, -1.0f,  0.5f,
		-0.8f,  1.1f,  0.3f,
	},
};
static const float s_constInMat4x2[2][8] =
{
	{
		-0.2f,  0.5f, 0.0f, -1.0f,
		 1.2f, -0.5f, 0.3f, -0.9f,
	},
	{
		1.0f,  0.1f, -1.1f,  0.6f,
		0.8f, -1.2f, -1.1f,  0.7f,
	},
};
static const float s_constInMat2x3[2][6] =
{
	{
		-0.6f, -0.1f,
		-0.7f, -1.2f,
		-0.2f,  0.0f,
	},
	{
		 1.1f,  0.6f,
		 0.8f,  1.0f,
		 0.7f,  0.1f,
	},
};
static const float s_constInMat3x3[2][9] =
{
	{
		-0.2f,  1.1f, 1.2f,
		-1.0f,  1.2f, 0.5f,
		 0.7f, -0.2f, 1.0f,
	},
	{
		-0.1f, -0.1f,  0.1f,
		-0.1f, -0.2f,  1.0f,
		-0.5f,  0.1f, -0.4f,
	},
};
static const float s_constInMat4x3[2][12] =
{
	{
		-0.9f,  0.0f,  0.6f,  0.2f,
		 0.9f, -0.1f, -0.3f, -0.7f,
		-0.1f,  0.1f,  1.0f,  0.0f,
	},
	{
		 0.5f,  0.7f,  0.7f,  1.2f,
		 1.1f,  0.1f,  1.0f, -1.0f,
		-0.2f, -0.2f, -0.3f, -0.5f,
	},
};
static const float s_constInMat2x4[2][8] =
{
	{
		-0.6f, -1.1f,
		-0.6f, -0.6f,
		-0.2f, -0.6f,
		-0.1f, -0.1f,
	},
	{
		-1.2f, -1.0f,
		 0.7f, -1.0f,
		 0.7f,  0.7f,
		-0.4f, -0.3f,
	},
};
static const float s_constInMat3x4[2][12] =
{
	{
		 0.6f, -0.4f,  1.2f,
		 0.9f,  0.8f,  0.4f,
		 1.1f,  0.3f,  0.5f,
		-0.2f,  0.0f,  1.1f,
	},
	{
		-0.8f,  1.2f, -0.2f,
		-1.1f, -0.9f, -0.5f,
		-1.2f,  1.0f,  1.2f,
		 0.1f, -0.7f, -0.5f,
	},
};
static const float s_constInMat4x4[2][16] =
{
	{
		 0.3f,  0.9f, -0.2f,  1.0f,
		-0.4f, -0.6f,  0.6f, -1.0f,
		-0.9f, -0.1f,  0.3f, -0.2f,
		-0.3f, -0.9f,  1.0f,  0.1f,
	},
	{
		 0.4f, -0.7f, -0.8f,  0.7f,
		-0.4f, -0.8f,  0.6f, -0.3f,
		 0.7f, -1.0f,  0.1f, -0.3f,
		 0.2f,  0.6f,  0.4f, -1.0f,
	},
};

namespace MatrixCaseUtils
{

enum InputType
{
	INPUTTYPE_CONST = 0,
	INPUTTYPE_UNIFORM,
	INPUTTYPE_DYNAMIC,

	INPUTTYPE_LAST
};

struct ShaderInput
{
	ShaderInput (InputType inputType_, DataType dataType_, Precision precision_)
		: inputType	(inputType_)
		, dataType	(dataType_)
		, precision	(precision_)
	{
	}

	InputType		inputType;
	DataType		dataType;
	Precision		precision;
};

enum MatrixOp
{
	OP_ADD = 0,
	OP_SUB,
	OP_MUL,
	OP_DIV,
	OP_COMP_MUL,
	OP_OUTER_PRODUCT,
	OP_TRANSPOSE,
	OP_INVERSE,
	OP_DETERMINANT,
	OP_UNARY_PLUS,
	OP_NEGATION,
	OP_PRE_INCREMENT,
	OP_PRE_DECREMENT,
	OP_POST_INCREMENT,
	OP_POST_DECREMENT,
	OP_ADD_INTO,
	OP_SUBTRACT_FROM,
	OP_MULTIPLY_INTO,
	OP_DIVIDE_INTO,
	OP_LAST
};

// Type traits.

template <int DataT>
struct TypeTraits;

#define DECLARE_TYPE_TRAIT(DATATYPE, TYPE)	\
template<>									\
struct TypeTraits<DATATYPE> {				\
	typedef TYPE Type;						\
}

DECLARE_TYPE_TRAIT(TYPE_FLOAT,			float);
DECLARE_TYPE_TRAIT(TYPE_FLOAT_VEC2,		tcu::Vec2);
DECLARE_TYPE_TRAIT(TYPE_FLOAT_VEC3,		tcu::Vec3);
DECLARE_TYPE_TRAIT(TYPE_FLOAT_VEC4,		tcu::Vec4);
DECLARE_TYPE_TRAIT(TYPE_FLOAT_MAT2,		tcu::Mat2);
DECLARE_TYPE_TRAIT(TYPE_FLOAT_MAT2X3,	tcu::Mat2x3);
DECLARE_TYPE_TRAIT(TYPE_FLOAT_MAT2X4,	tcu::Mat2x4);
DECLARE_TYPE_TRAIT(TYPE_FLOAT_MAT3X2,	tcu::Mat3x2);
DECLARE_TYPE_TRAIT(TYPE_FLOAT_MAT3,		tcu::Mat3);
DECLARE_TYPE_TRAIT(TYPE_FLOAT_MAT3X4,	tcu::Mat3x4);
DECLARE_TYPE_TRAIT(TYPE_FLOAT_MAT4X2,	tcu::Mat4x2);
DECLARE_TYPE_TRAIT(TYPE_FLOAT_MAT4X3,	tcu::Mat4x3);
DECLARE_TYPE_TRAIT(TYPE_FLOAT_MAT4,		tcu::Mat4);

// Operation info

enum OperationType
{
	OPERATIONTYPE_BINARY_OPERATOR = 0,
	OPERATIONTYPE_BINARY_FUNCTION,
	OPERATIONTYPE_UNARY_PREFIX_OPERATOR,
	OPERATIONTYPE_UNARY_POSTFIX_OPERATOR,
	OPERATIONTYPE_UNARY_FUNCTION,
	OPERATIONTYPE_ASSIGNMENT,

	OPERATIONTYPE_LAST
};

static const char* getOperationName (MatrixOp op)
{
	switch (op)
	{
		case OP_ADD:			return "+";
		case OP_SUB:			return "-";
		case OP_MUL:			return "*";
		case OP_DIV:			return "/";
		case OP_COMP_MUL:		return "matrixCompMult";
		case OP_OUTER_PRODUCT:	return "outerProduct";
		case OP_TRANSPOSE:		return "transpose";
		case OP_INVERSE:		return "inverse";
		case OP_DETERMINANT:	return "determinant";
		case OP_UNARY_PLUS:		return "+";
		case OP_NEGATION:		return "-";
		case OP_PRE_INCREMENT:	return "++";
		case OP_PRE_DECREMENT:	return "--";
		case OP_POST_INCREMENT:	return "++";
		case OP_POST_DECREMENT:	return "--";
		case OP_ADD_INTO:		return "+=";
		case OP_SUBTRACT_FROM:	return "-=";
		case OP_MULTIPLY_INTO:	return "*=";
		case OP_DIVIDE_INTO:	return "/=";

		default:
			DE_ASSERT(DE_FALSE);
			return "";
	}
}

static OperationType getOperationType (MatrixOp op)
{
	switch (op)
	{
		case OP_ADD:			return OPERATIONTYPE_BINARY_OPERATOR;
		case OP_SUB:			return OPERATIONTYPE_BINARY_OPERATOR;
		case OP_MUL:			return OPERATIONTYPE_BINARY_OPERATOR;
		case OP_DIV:			return OPERATIONTYPE_BINARY_OPERATOR;
		case OP_COMP_MUL:		return OPERATIONTYPE_BINARY_FUNCTION;
		case OP_OUTER_PRODUCT:	return OPERATIONTYPE_BINARY_FUNCTION;
		case OP_TRANSPOSE:		return OPERATIONTYPE_UNARY_FUNCTION;
		case OP_INVERSE:		return OPERATIONTYPE_UNARY_FUNCTION;
		case OP_DETERMINANT:	return OPERATIONTYPE_UNARY_FUNCTION;
		case OP_UNARY_PLUS:		return OPERATIONTYPE_UNARY_PREFIX_OPERATOR;
		case OP_NEGATION:		return OPERATIONTYPE_UNARY_PREFIX_OPERATOR;
		case OP_PRE_INCREMENT:	return OPERATIONTYPE_UNARY_PREFIX_OPERATOR;
		case OP_PRE_DECREMENT:	return OPERATIONTYPE_UNARY_PREFIX_OPERATOR;
		case OP_POST_INCREMENT:	return OPERATIONTYPE_UNARY_POSTFIX_OPERATOR;
		case OP_POST_DECREMENT:	return OPERATIONTYPE_UNARY_POSTFIX_OPERATOR;
		case OP_ADD_INTO:		return OPERATIONTYPE_ASSIGNMENT;
		case OP_SUBTRACT_FROM:	return OPERATIONTYPE_ASSIGNMENT;
		case OP_MULTIPLY_INTO:	return OPERATIONTYPE_ASSIGNMENT;
		case OP_DIVIDE_INTO:	return OPERATIONTYPE_ASSIGNMENT;
		default:
			DE_ASSERT(DE_FALSE);
			return OPERATIONTYPE_LAST;
	}
}

enum TestMatrixType
{
	TESTMATRIXTYPE_DEFAULT = 0,
	TESTMATRIXTYPE_NEGATED,
	TESTMATRIXTYPE_INCREMENTED,
	TESTMATRIXTYPE_DECREMENTED,
	TESTMATRIXTYPE_NEGATED_INCREMENTED,
	TESTMATRIXTYPE_INCREMENTED_LESS,

	TESTMATRIXTYPE_LAST
};

static TestMatrixType getOperationTestMatrixType (MatrixOp op)
{
	switch(op)
	{
		case OP_ADD:			return TESTMATRIXTYPE_DEFAULT;
		case OP_SUB:			return TESTMATRIXTYPE_DEFAULT;
		case OP_MUL:			return TESTMATRIXTYPE_DEFAULT;
		case OP_DIV:			return TESTMATRIXTYPE_DEFAULT;
		case OP_COMP_MUL:		return TESTMATRIXTYPE_DEFAULT;
		case OP_OUTER_PRODUCT:	return TESTMATRIXTYPE_DEFAULT;
		case OP_TRANSPOSE:		return TESTMATRIXTYPE_DEFAULT;
		case OP_INVERSE:		return TESTMATRIXTYPE_DEFAULT;
		case OP_DETERMINANT:	return TESTMATRIXTYPE_DEFAULT;
		case OP_UNARY_PLUS:		return TESTMATRIXTYPE_DECREMENTED;
		case OP_NEGATION:		return TESTMATRIXTYPE_NEGATED_INCREMENTED;
		case OP_PRE_INCREMENT:	return TESTMATRIXTYPE_NEGATED;
		case OP_PRE_DECREMENT:	return TESTMATRIXTYPE_INCREMENTED;
		case OP_POST_INCREMENT:	return TESTMATRIXTYPE_NEGATED;
		case OP_POST_DECREMENT:	return TESTMATRIXTYPE_DEFAULT;
		case OP_ADD_INTO:		return TESTMATRIXTYPE_DEFAULT;
		case OP_SUBTRACT_FROM:	return TESTMATRIXTYPE_INCREMENTED_LESS;
		case OP_MULTIPLY_INTO:	return TESTMATRIXTYPE_NEGATED;
		case OP_DIVIDE_INTO:	return TESTMATRIXTYPE_DECREMENTED;

		default:
			DE_ASSERT(DE_FALSE);
			return TESTMATRIXTYPE_LAST;
	}
}

static bool isOperationBinary (MatrixOp op)
{
	return getOperationType(op) == OPERATIONTYPE_BINARY_OPERATOR ||
	       getOperationType(op) == OPERATIONTYPE_BINARY_FUNCTION ||
	       getOperationType(op) == OPERATIONTYPE_ASSIGNMENT;
}

static bool isOperationMatrixScalar (MatrixOp op)
{
	return op == OP_ADD || op == OP_SUB || op == OP_MUL || op == OP_DIV;
}

static bool isOperationMatrixVector (MatrixOp op)
{
	return op == OP_MUL;
}

static bool isOperationArithmeticMatrixMatrix (MatrixOp op)
{
	return op == OP_MUL;
}

static bool isOperationComponentwiseMatrixMatrix (MatrixOp op)
{
	return op == OP_ADD || op == OP_SUB || op == OP_MUL || op == OP_DIV || op == OP_COMP_MUL;
}

static bool isOperationVectorVector (MatrixOp op)
{
	return op == OP_OUTER_PRODUCT;
}

static bool isOperationUnaryAnyMatrix (MatrixOp op)
{
	return  op == OP_TRANSPOSE			 ||
			op == OP_UNARY_PLUS			 ||
			op == OP_NEGATION			 ||
			op == OP_PRE_INCREMENT		 ||
			op == OP_PRE_DECREMENT		 ||
			op == OP_POST_INCREMENT		 ||
			op == OP_POST_DECREMENT;
}

static bool isOperationUnarySymmetricMatrix (MatrixOp op)
{
	return op == OP_INVERSE || op == OP_DETERMINANT;
}

static bool isOperationValueModifying (MatrixOp op)
{
	return  op == OP_PRE_INCREMENT		 ||
			op == OP_PRE_DECREMENT		 ||
			op == OP_POST_INCREMENT		 ||
			op == OP_POST_DECREMENT;
}

static bool isOperationAssignment (MatrixOp op)
{
	return  op == OP_ADD_INTO		 ||
			op == OP_SUBTRACT_FROM	 ||
			op == OP_MULTIPLY_INTO	 ||
			op == OP_DIVIDE_INTO;
}

static bool isOperationAssignmentAnyMatrix (MatrixOp op)
{
	return  op == OP_ADD_INTO		 ||
			op == OP_SUBTRACT_FROM	 ||
			op == OP_DIVIDE_INTO;
}

static bool isOperationAssignmentSymmetricMatrix (MatrixOp op)
{
	return op == OP_MULTIPLY_INTO;
}

// Operation nature

enum OperationNature
{
	OPERATIONNATURE_PURE = 0,
	OPERATIONNATURE_MUTATING,
	OPERATIONNATURE_ASSIGNMENT,

	OPERATIONNATURE_LAST
};

static OperationNature getOperationNature (MatrixOp op)
{
	if (isOperationAssignment(op))
		return OPERATIONNATURE_ASSIGNMENT;

	if (isOperationValueModifying(op))
		return OPERATIONNATURE_MUTATING;

	return OPERATIONNATURE_PURE;
}

// Input value loader.

template <int InputT, int DataT>
typename TypeTraits<DataT>::Type getInputValue (const ShaderEvalContext& evalCtx, int inputNdx);

template <> inline float		getInputValue<INPUTTYPE_CONST,		TYPE_FLOAT>			(const ShaderEvalContext& evalCtx, int inputNdx) { DE_UNREF(evalCtx); return s_constInFloat[inputNdx];	}
template <> inline tcu::Vec2	getInputValue<INPUTTYPE_CONST,		TYPE_FLOAT_VEC2>	(const ShaderEvalContext& evalCtx, int inputNdx) { DE_UNREF(evalCtx); return s_constInVec2[inputNdx];	}
template <> inline tcu::Vec3	getInputValue<INPUTTYPE_CONST,		TYPE_FLOAT_VEC3>	(const ShaderEvalContext& evalCtx, int inputNdx) { DE_UNREF(evalCtx); return s_constInVec3[inputNdx];	}
template <> inline tcu::Vec4	getInputValue<INPUTTYPE_CONST,		TYPE_FLOAT_VEC4>	(const ShaderEvalContext& evalCtx, int inputNdx) { DE_UNREF(evalCtx); return s_constInVec4[inputNdx];	}

template <> inline tcu::Mat2	getInputValue<INPUTTYPE_CONST,		TYPE_FLOAT_MAT2>	(const ShaderEvalContext& evalCtx, int inputNdx) { DE_UNREF(evalCtx); return tcu::Mat2(s_constInMat2x2[inputNdx]);		}
template <> inline tcu::Mat2x3	getInputValue<INPUTTYPE_CONST,		TYPE_FLOAT_MAT2X3>	(const ShaderEvalContext& evalCtx, int inputNdx) { DE_UNREF(evalCtx); return tcu::Mat2x3(s_constInMat2x3[inputNdx]);	}
template <> inline tcu::Mat2x4	getInputValue<INPUTTYPE_CONST,		TYPE_FLOAT_MAT2X4>	(const ShaderEvalContext& evalCtx, int inputNdx) { DE_UNREF(evalCtx); return tcu::Mat2x4(s_constInMat2x4[inputNdx]);	}
template <> inline tcu::Mat3x2	getInputValue<INPUTTYPE_CONST,		TYPE_FLOAT_MAT3X2>	(const ShaderEvalContext& evalCtx, int inputNdx) { DE_UNREF(evalCtx); return tcu::Mat3x2(s_constInMat3x2[inputNdx]);	}
template <> inline tcu::Mat3	getInputValue<INPUTTYPE_CONST,		TYPE_FLOAT_MAT3>	(const ShaderEvalContext& evalCtx, int inputNdx) { DE_UNREF(evalCtx); return tcu::Mat3(s_constInMat3x3[inputNdx]);		}
template <> inline tcu::Mat3x4	getInputValue<INPUTTYPE_CONST,		TYPE_FLOAT_MAT3X4>	(const ShaderEvalContext& evalCtx, int inputNdx) { DE_UNREF(evalCtx); return tcu::Mat3x4(s_constInMat3x4[inputNdx]);	}
template <> inline tcu::Mat4x2	getInputValue<INPUTTYPE_CONST,		TYPE_FLOAT_MAT4X2>	(const ShaderEvalContext& evalCtx, int inputNdx) { DE_UNREF(evalCtx); return tcu::Mat4x2(s_constInMat4x2[inputNdx]);	}
template <> inline tcu::Mat4x3	getInputValue<INPUTTYPE_CONST,		TYPE_FLOAT_MAT4X3>	(const ShaderEvalContext& evalCtx, int inputNdx) { DE_UNREF(evalCtx); return tcu::Mat4x3(s_constInMat4x3[inputNdx]);	}
template <> inline tcu::Mat4	getInputValue<INPUTTYPE_CONST,		TYPE_FLOAT_MAT4>	(const ShaderEvalContext& evalCtx, int inputNdx) { DE_UNREF(evalCtx); return tcu::Mat4(s_constInMat4x4[inputNdx]);		}

template <> inline float		getInputValue<INPUTTYPE_DYNAMIC,	TYPE_FLOAT>			(const ShaderEvalContext& evalCtx, int inputNdx) { DE_UNREF(inputNdx); return evalCtx.coords.x();					}
template <> inline tcu::Vec2	getInputValue<INPUTTYPE_DYNAMIC,	TYPE_FLOAT_VEC2>	(const ShaderEvalContext& evalCtx, int inputNdx) { DE_UNREF(inputNdx); return evalCtx.coords.swizzle(0, 1);			}
template <> inline tcu::Vec3	getInputValue<INPUTTYPE_DYNAMIC,	TYPE_FLOAT_VEC3>	(const ShaderEvalContext& evalCtx, int inputNdx) { DE_UNREF(inputNdx); return evalCtx.coords.swizzle(0, 1, 2);		}
template <> inline tcu::Vec4	getInputValue<INPUTTYPE_DYNAMIC,	TYPE_FLOAT_VEC4>	(const ShaderEvalContext& evalCtx, int inputNdx) { DE_UNREF(inputNdx); return evalCtx.coords.swizzle(0, 1, 2, 3);	}

template <> inline tcu::Mat2 getInputValue<INPUTTYPE_DYNAMIC, TYPE_FLOAT_MAT2> (const ShaderEvalContext& evalCtx, int inputNdx)
{
	DE_UNREF(inputNdx); // Not used.
	tcu::Mat2 m;
	m.setColumn(0, evalCtx.in[0].swizzle(0,1));
	m.setColumn(1, evalCtx.in[1].swizzle(0,1));
	return m;
}

template <> inline tcu::Mat2x3 getInputValue<INPUTTYPE_DYNAMIC, TYPE_FLOAT_MAT2X3> (const ShaderEvalContext& evalCtx, int inputNdx)
{
	DE_UNREF(inputNdx); // Not used.
	tcu::Mat2x3 m;
	m.setColumn(0, evalCtx.in[0].swizzle(0,1,2));
	m.setColumn(1, evalCtx.in[1].swizzle(0,1,2));
	return m;
}

template <> inline tcu::Mat2x4 getInputValue<INPUTTYPE_DYNAMIC, TYPE_FLOAT_MAT2X4> (const ShaderEvalContext& evalCtx, int inputNdx)
{
	DE_UNREF(inputNdx); // Not used.
	tcu::Mat2x4 m;
	m.setColumn(0, evalCtx.in[0]);
	m.setColumn(1, evalCtx.in[1]);
	return m;
}

template <> inline tcu::Mat3x2 getInputValue<INPUTTYPE_DYNAMIC, TYPE_FLOAT_MAT3X2> (const ShaderEvalContext& evalCtx, int inputNdx)
{
	DE_UNREF(inputNdx); // Not used.
	tcu::Mat3x2 m;
	m.setColumn(0, evalCtx.in[0].swizzle(0,1));
	m.setColumn(1, evalCtx.in[1].swizzle(0,1));
	m.setColumn(2, evalCtx.in[2].swizzle(0,1));
	return m;
}

template <> inline tcu::Mat3 getInputValue<INPUTTYPE_DYNAMIC, TYPE_FLOAT_MAT3> (const ShaderEvalContext& evalCtx, int inputNdx)
{
	DE_UNREF(inputNdx); // Not used.
	tcu::Mat3 m;
	m.setColumn(0, evalCtx.in[0].swizzle(0,1,2));
	m.setColumn(1, evalCtx.in[1].swizzle(0,1,2));
	m.setColumn(2, evalCtx.in[2].swizzle(0,1,2));
	return m;
}

template <> inline tcu::Mat3x4 getInputValue<INPUTTYPE_DYNAMIC, TYPE_FLOAT_MAT3X4> (const ShaderEvalContext& evalCtx, int inputNdx)
{
	DE_UNREF(inputNdx); // Not used.
	tcu::Mat3x4 m;
	m.setColumn(0, evalCtx.in[0]);
	m.setColumn(1, evalCtx.in[1]);
	m.setColumn(2, evalCtx.in[2]);
	return m;
}

template <> inline tcu::Mat4x2 getInputValue<INPUTTYPE_DYNAMIC, TYPE_FLOAT_MAT4X2> (const ShaderEvalContext& evalCtx, int inputNdx)
{
	DE_UNREF(inputNdx); // Not used.
	tcu::Mat4x2 m;
	m.setColumn(0, evalCtx.in[0].swizzle(0,1));
	m.setColumn(1, evalCtx.in[1].swizzle(0,1));
	m.setColumn(2, evalCtx.in[2].swizzle(0,1));
	m.setColumn(3, evalCtx.in[3].swizzle(0,1));
	return m;
}

template <> inline tcu::Mat4x3 getInputValue<INPUTTYPE_DYNAMIC, TYPE_FLOAT_MAT4X3> (const ShaderEvalContext& evalCtx, int inputNdx)
{
	DE_UNREF(inputNdx); // Not used.
	tcu::Mat4x3 m;
	m.setColumn(0, evalCtx.in[0].swizzle(0,1,2));
	m.setColumn(1, evalCtx.in[1].swizzle(0,1,2));
	m.setColumn(2, evalCtx.in[2].swizzle(0,1,2));
	m.setColumn(3, evalCtx.in[3].swizzle(0,1,2));
	return m;
}

template <> inline tcu::Mat4 getInputValue<INPUTTYPE_DYNAMIC, TYPE_FLOAT_MAT4> (const ShaderEvalContext& evalCtx, int inputNdx)
{
	DE_UNREF(inputNdx); // Not used.
	tcu::Mat4 m;
	m.setColumn(0, evalCtx.in[0]);
	m.setColumn(1, evalCtx.in[1]);
	m.setColumn(2, evalCtx.in[2]);
	m.setColumn(3, evalCtx.in[3]);
	return m;
}

// Reduction from expression result to vec3.

inline tcu::Vec3 reduceToVec3 (const tcu::Vec2& value)		{ return value.swizzle(0,1,0); }
inline tcu::Vec3 reduceToVec3 (const tcu::Vec3& value)		{ return value; }
inline tcu::Vec3 reduceToVec3 (const tcu::Vec4& value)		{ return tcu::Vec3(value.x(), value.y(), value.z()+value.w()); }
inline tcu::Vec3 reduceToVec3 (const tcu::Mat2& value)		{ return tcu::Vec3(value(0, 0), value(0, 1), value(1, 0)+value(1, 1)); }
inline tcu::Vec3 reduceToVec3 (const tcu::Mat2x3& value)	{ return value.getColumn(0) + value.getColumn(1); }
inline tcu::Vec3 reduceToVec3 (const tcu::Mat2x4& value)	{ return value.getColumn(0).swizzle(0,1,2) + value.getColumn(1).swizzle(1,2,3); }
inline tcu::Vec3 reduceToVec3 (const tcu::Mat3x2& value)	{ return tcu::Vec3(value(0,0)+value(1,0), value(0,1)+value(1,1), value(0,2)+value(1,2)); }
inline tcu::Vec3 reduceToVec3 (const tcu::Mat3& value)		{ return value.getColumn(0) + value.getColumn(1) + value.getColumn(2); }
inline tcu::Vec3 reduceToVec3 (const tcu::Mat3x4& value)	{ return value.getColumn(0).swizzle(0,1,2) + value.getColumn(1).swizzle(1,2,3) + value.getColumn(2).swizzle(2,3,0); }
inline tcu::Vec3 reduceToVec3 (const tcu::Mat4x2& value)	{ return tcu::Vec3(value(0,0)+value(1,0)+value(0,3), value(0,1)+value(1,1)+value(1,3), value(0,2)+value(1,2)); }
inline tcu::Vec3 reduceToVec3 (const tcu::Mat4x3& value)	{ return value.getColumn(0) + value.getColumn(1) + value.getColumn(2) + value.getColumn(3); }
inline tcu::Vec3 reduceToVec3 (const tcu::Mat4& value)		{ return value.getColumn(0).swizzle(0,1,2) + value.getColumn(1).swizzle(1,2,3) + value.getColumn(2).swizzle(2,3,0) + value.getColumn(3).swizzle(3,0,1); }

// matrixCompMult

template <typename T, int Rows, int Cols>
tcu::Matrix<T, Rows, Cols> matrixCompMult (const tcu::Matrix<T, Rows, Cols>& a, const tcu::Matrix<T, Rows, Cols>& b)
{
	tcu::Matrix<T, Rows, Cols> retVal;

	for (int r = 0; r < Rows; ++r)
		for (int c = 0; c < Cols; ++c)
			retVal(r,c) = a(r,c) * b(r, c);

	return retVal;
}

// transpose

template <typename T, int Rows, int Cols>
tcu::Matrix<T, Cols, Rows> transpose (const tcu::Matrix<T, Rows, Cols>& mat)
{
	tcu::Matrix<T, Cols, Rows> retVal;

	for (int r = 0; r < Rows; ++r)
		for (int c = 0; c < Cols; ++c)
			retVal(c, r) = mat(r, c);

	return retVal;
}

// outerProduct

template <typename T, int Rows, int Cols>
tcu::Matrix<T, Cols, Rows> outerProduct (const tcu::Vector<T, Cols>& a, const tcu::Vector<T, Rows>& b)
{
	tcu::Matrix<T, Rows, Cols> retVal;

	for (int r = 0; r < Rows; ++r)
		for (int c = 0; c < Cols; ++c)
			retVal(r,c) = a[c] * b[r];

	return transpose(retVal); // to gl-form (column-major)
}

// Determinant

template <int Size>
float determinant (const tcu::Matrix<float, Size, Size>& mat);

template <>
float determinant<2> (const tcu::Matrix<float, 2, 2>& mat)
{
	return mat(0,0) * mat(1,1) - mat(1,0) * mat(0,1);
}

template <>
float determinant<3> (const tcu::Matrix<float, 3, 3>& mat)
{
	return	+ mat(0,0) * mat(1,1) * mat(2,2)
			+ mat(0,1) * mat(1,2) * mat(2,0)
			+ mat(0,2) * mat(1,0) * mat(2,1)
			- mat(0,0) * mat(1,2) * mat(2,1)
			- mat(0,1) * mat(1,0) * mat(2,2)
			- mat(0,2) * mat(1,1) * mat(2,0);
}

template <>
float determinant<4> (const tcu::Matrix<float, 4, 4>& mat)
{
	const float minorMatrices[4][3*3] =
	{
		{
			mat(1,1),	mat(2,1),	mat(3,1),
			mat(1,2),	mat(2,2),	mat(3,2),
			mat(1,3),	mat(2,3),	mat(3,3),
		},
		{
			mat(1,0),	mat(2,0),	mat(3,0),
			mat(1,2),	mat(2,2),	mat(3,2),
			mat(1,3),	mat(2,3),	mat(3,3),
		},
		{
			mat(1,0),	mat(2,0),	mat(3,0),
			mat(1,1),	mat(2,1),	mat(3,1),
			mat(1,3),	mat(2,3),	mat(3,3),
		},
		{
			mat(1,0),	mat(2,0),	mat(3,0),
			mat(1,1),	mat(2,1),	mat(3,1),
			mat(1,2),	mat(2,2),	mat(3,2),
		}
	};

	return	+ mat(0,0) * determinant(tcu::Mat3(minorMatrices[0]))
			- mat(0,1) * determinant(tcu::Mat3(minorMatrices[1]))
			+ mat(0,2) * determinant(tcu::Mat3(minorMatrices[2]))
			- mat(0,3) * determinant(tcu::Mat3(minorMatrices[3]));
}

// Inverse

template <int Size>
tcu::Matrix<float, Size, Size> inverse (const tcu::Matrix<float, Size, Size>& mat);

template <>
tcu::Matrix<float, 2, 2> inverse<2> (const tcu::Matrix<float, 2, 2>& mat)
{
	const float					det		= determinant(mat);
	tcu::Matrix<float, 2, 2>	retVal;

	DE_ASSERT(det != 0.0f);

	retVal(0, 0) =  mat(1, 1) / det;
	retVal(0, 1) = -mat(0, 1) / det;
	retVal(1, 0) = -mat(1, 0) / det;
	retVal(1, 1) =  mat(0, 0) / det;

	return retVal;
}

template <>
tcu::Matrix<float, 3, 3> inverse<3> (const tcu::Matrix<float, 3, 3>& mat)
{
	// Blockwise inversion

	DE_ASSERT(determinant(mat) != 0.0f);

	const float areaA[2*2] =
	{
		mat(0,0),	mat(0,1),
		mat(1,0),	mat(1,1)
	};
	const float areaB[2] =
	{
		mat(0,2),
		mat(1,2),
	};
	const float areaC[2] =
	{
		mat(2,0),	mat(2,1),
	};
	const float areaD[1] =
	{
		mat(2,2)
	};
	const float nullField[4] = { 0.0f };

	const tcu::Matrix<float, 2, 2>	invA = inverse(tcu::Matrix<float, 2, 2>(areaA));
	const tcu::Matrix<float, 2, 1>	matB =         tcu::Matrix<float, 2, 1>(areaB);
	const tcu::Matrix<float, 1, 2>	matC =         tcu::Matrix<float, 1, 2>(areaC);
	const tcu::Matrix<float, 1, 1>	matD =         tcu::Matrix<float, 1, 1>(areaD);

	const float						schurComplement = 1.0f / (matD - matC*invA*matB)(0,0);
	const tcu::Matrix<float, 2, 2>	zeroMat         = Mat2(nullField);

	const tcu::Matrix<float, 2, 2>	blockA = invA + invA*matB*schurComplement*matC*invA;
	const tcu::Matrix<float, 2, 1>	blockB = (zeroMat-invA)*matB*schurComplement;
	const tcu::Matrix<float, 1, 2>	blockC = matC*invA*(-schurComplement);
	const float						blockD = schurComplement;

	const float result[3*3] =
	{
		blockA(0,0),	blockA(0,1),	blockB(0,0),
		blockA(1,0),	blockA(1,1),	blockB(1,0),
		blockC(0,0),	blockC(0,1),	blockD,
	};

	return Mat3(result);
}

template <>
tcu::Matrix<float, 4, 4> inverse<4> (const tcu::Matrix<float, 4, 4>& mat)
{
	// Blockwise inversion

	DE_ASSERT(determinant(mat) != 0.0f);

	const float areaA[2*2] =
	{
		mat(0,0),	mat(0,1),
		mat(1,0),	mat(1,1)
	};
	const float areaB[2*2] =
	{
		mat(0,2),	mat(0,3),
		mat(1,2),	mat(1,3)
	};
	const float areaC[2*2] =
	{
		mat(2,0),	mat(2,1),
		mat(3,0),	mat(3,1)
	};
	const float areaD[2*2] =
	{
		mat(2,2),	mat(2,3),
		mat(3,2),	mat(3,3)
	};
	const float nullField[4] = { 0.0f };

	const tcu::Matrix<float, 2, 2> invA = inverse(Mat2(areaA));
	const tcu::Matrix<float, 2, 2> matB =         Mat2(areaB);
	const tcu::Matrix<float, 2, 2> matC =         Mat2(areaC);
	const tcu::Matrix<float, 2, 2> matD =         Mat2(areaD);

	const tcu::Matrix<float, 2, 2> schurComplement = inverse(matD - matC*invA*matB);
	const tcu::Matrix<float, 2, 2> zeroMat         = Mat2(nullField);

	const tcu::Matrix<float, 2, 2> blockA = invA + invA*matB*schurComplement*matC*invA;
	const tcu::Matrix<float, 2, 2> blockB = (zeroMat-invA)*matB*schurComplement;
	const tcu::Matrix<float, 2, 2> blockC = (zeroMat-schurComplement)*matC*invA;
	const tcu::Matrix<float, 2, 2> blockD = schurComplement;

	const float result[4*4] =
	{
		blockA(0,0),	blockA(0,1),	blockB(0,0),	blockB(0,1),
		blockA(1,0),	blockA(1,1),	blockB(1,0),	blockB(1,1),
		blockC(0,0),	blockC(0,1),	blockD(0,0),	blockD(0,1),
		blockC(1,0),	blockC(1,1),	blockD(1,0),	blockD(1,1),
	};

	return Mat4(result);
}

// negate

template <typename T, int Rows, int Cols>
tcu::Matrix<T, Rows, Cols> negate (const tcu::Matrix<T, Rows, Cols>& mat)
{
	tcu::Matrix<T, Rows, Cols> retVal;

	for (int r = 0; r < Rows; ++r)
		for (int c = 0; c < Cols; ++c)
			retVal(r,c) = -mat(r, c);

	return retVal;
}

// increment/decrement

template <typename T, int Rows, int Cols>
tcu::Matrix<T, Rows, Cols> increment (const tcu::Matrix<T, Rows, Cols>& mat)
{
	tcu::Matrix<T, Rows, Cols> retVal;

	for (int r = 0; r < Rows; ++r)
		for (int c = 0; c < Cols; ++c)
			retVal(r,c) = mat(r, c) + 1.0f;

	return retVal;
}

template <typename T, int Rows, int Cols>
tcu::Matrix<T, Rows, Cols> decrement (const tcu::Matrix<T, Rows, Cols>& mat)
{
	tcu::Matrix<T, Rows, Cols> retVal;

	for (int r = 0; r < Rows; ++r)
		for (int c = 0; c < Cols; ++c)
			retVal(r,c) = mat(r, c) - 1.0f;

	return retVal;
}

// Evaluator template.

typedef void (*MatrixShaderEvalFunc) (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type);

template <int Op, int In0DataType, int In1DataType>
struct Evaluator;

template <int In0DataType, int In1DataType>
struct Evaluator<OP_ADD, In0DataType, In1DataType>
{
	static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
	{
		typename TypeTraits<In0DataType>::Type	in0	= (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
																				     : getInputValue<INPUTTYPE_CONST,	In0DataType>(evalCtx, 0);
		typename TypeTraits<In1DataType>::Type	in1	= (in1Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In1DataType>(evalCtx, 1)
																				     : getInputValue<INPUTTYPE_CONST,	In1DataType>(evalCtx, 1);
		evalCtx.color.xyz() = reduceToVec3(in0 + in1);
	}
};

template <int In0DataType, int In1DataType>
struct Evaluator<OP_SUB, In0DataType, In1DataType>
{
	static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
	{
		typename TypeTraits<In0DataType>::Type	in0	= (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
																				     : getInputValue<INPUTTYPE_CONST,	In0DataType>(evalCtx, 0);
		typename TypeTraits<In1DataType>::Type	in1	= (in1Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In1DataType>(evalCtx, 1)
																				     : getInputValue<INPUTTYPE_CONST,	In1DataType>(evalCtx, 1);
		evalCtx.color.xyz() = reduceToVec3(in0 - in1);
	}
};

template <int In0DataType, int In1DataType>
struct Evaluator<OP_MUL, In0DataType, In1DataType>
{
	static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
	{
		typename TypeTraits<In0DataType>::Type	in0	= (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
																				     : getInputValue<INPUTTYPE_CONST,	In0DataType>(evalCtx, 0);
		typename TypeTraits<In1DataType>::Type	in1	= (in1Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In1DataType>(evalCtx, 1)
																				     : getInputValue<INPUTTYPE_CONST,	In1DataType>(evalCtx, 1);
		evalCtx.color.xyz() = reduceToVec3(in0 * in1);
	}
};

template <int In0DataType, int In1DataType>
struct Evaluator<OP_DIV, In0DataType, In1DataType>
{
	static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
	{
		typename TypeTraits<In0DataType>::Type	in0	= (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
																				     : getInputValue<INPUTTYPE_CONST,	In0DataType>(evalCtx, 0);
		typename TypeTraits<In1DataType>::Type	in1	= (in1Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In1DataType>(evalCtx, 1)
																				     : getInputValue<INPUTTYPE_CONST,	In1DataType>(evalCtx, 1);
		evalCtx.color.xyz() = reduceToVec3(in0 / in1);
	}
};

template <int In0DataType, int In1DataType>
struct Evaluator<OP_COMP_MUL, In0DataType, In1DataType>
{
	static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
	{
		typename TypeTraits<In0DataType>::Type	in0	= (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
																				     : getInputValue<INPUTTYPE_CONST,	In0DataType>(evalCtx, 0);
		typename TypeTraits<In1DataType>::Type	in1	= (in1Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In1DataType>(evalCtx, 1)
																				     : getInputValue<INPUTTYPE_CONST,	In1DataType>(evalCtx, 1);
		evalCtx.color.xyz() = reduceToVec3(matrixCompMult(in0, in1));
	}
};