framework/randomshaders/rsgVariableType.cpp

/*-------------------------------------------------------------------------
 * drawElements Quality Program Random Shader Generator
 * ----------------------------------------------------
 *
 * 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 Variable Type class.
 *//*--------------------------------------------------------------------*/

#include "rsgVariableType.hpp"
#include "rsgToken.hpp"

using std::vector;

namespace rsg
{

VariableType& VariableType::operator= (const VariableType& other)
{
	if (this == &other)
		return *this;

	delete m_elementType;

	m_elementType	= DE_NULL;
	m_baseType		= other.m_baseType;
	m_precision		= other.m_precision;
	m_typeName		= other.m_typeName;
	m_numElements	= other.m_numElements;
	m_members		= other.m_members;
	m_elementType	= DE_NULL;

	if (other.m_elementType)
		m_elementType = new VariableType(*other.m_elementType);

	return *this;
}

VariableType::VariableType (const VariableType& other)
	: m_elementType(DE_NULL)
{
	*this = other;
}

bool VariableType::operator!= (const VariableType& other) const
{
	if (m_baseType != other.m_baseType)
		return true;
	if (m_precision != other.m_precision)
		return true;
	if (m_numElements != other.m_numElements)
		return true;
	if (!!m_elementType != !!other.m_elementType)
		return true;
	if (m_elementType && *m_elementType != *other.m_elementType)
		return true;
	if (m_members != other.m_members)
		return true;
	return false;
}

bool VariableType::operator== (const VariableType& other) const
{
	return !(*this != other);
}

int VariableType::getScalarSize (void) const
{
	switch (m_baseType)
	{
		case TYPE_VOID:
		case TYPE_FLOAT:
		case TYPE_INT:
		case TYPE_BOOL:
		case TYPE_SAMPLER_2D:
		case TYPE_SAMPLER_CUBE:
			return m_numElements;

		case TYPE_STRUCT:
		{
			int sum = 0;
			for (vector<Member>::const_iterator i = m_members.begin(); i != m_members.end(); i++)
				sum += i->getType().getScalarSize();
			return sum;
		}

		case TYPE_ARRAY:
		{
			DE_ASSERT(m_elementType);
			return m_elementType->getScalarSize() * m_numElements;
		}

		default:
			DE_ASSERT(false);
			return 0;
	}
}

int VariableType::getMemberScalarOffset (int memberNdx) const
{
	DE_ASSERT(isStruct());

	int curOffset = 0;
	for (vector<Member>::const_iterator i = m_members.begin(); i != m_members.begin() + memberNdx; i++)
		curOffset += i->getType().getScalarSize();

	return curOffset;
}

int VariableType::getElementScalarOffset (int elementNdx) const
{
	DE_ASSERT(isArray());
	return elementNdx * getElementType().getScalarSize();
}

const VariableType& VariableType::getScalarType (Type baseType)
{
	switch (baseType)
	{
		case TYPE_FLOAT:
		{
			static const VariableType s_floatTypes[] =
			{
				VariableType(TYPE_FLOAT, 1)
				// \todo [pyry] Extend with different precision variants?
			};
			return s_floatTypes[0];
		}

		case TYPE_INT:
		{
			static const VariableType s_intTypes[] =
			{
				VariableType(TYPE_INT, 1)
			};
			return s_intTypes[0];
		}

		case TYPE_BOOL:
		{
			static const VariableType s_boolTypes[] =
			{
				VariableType(TYPE_BOOL, 1)
			};
			return s_boolTypes[0];
		}

		case TYPE_SAMPLER_2D:
		{
			static const VariableType sampler2DType = VariableType(TYPE_SAMPLER_2D, 1);
			return sampler2DType;
		}

		case TYPE_SAMPLER_CUBE:
		{
			static const VariableType samplerCubeType = VariableType(TYPE_SAMPLER_CUBE, 1);
			return samplerCubeType;
		}

		default:
			DE_ASSERT(DE_FALSE);
			throw Exception("VariableType::getScalarType(): unsupported type");
	}
}

const VariableType& VariableType::getElementType (void) const
{
	DE_ASSERT(m_precision == PRECISION_NONE); // \todo [pyry] Precision
	switch (m_baseType)
	{
		case TYPE_FLOAT:
		case TYPE_INT:
		case TYPE_BOOL:
		case TYPE_SAMPLER_2D:
		case TYPE_SAMPLER_CUBE:
			return getScalarType(m_baseType);

		case TYPE_ARRAY:
		{
			DE_ASSERT(m_elementType);
			return *m_elementType;
		}

		default:
			DE_ASSERT(DE_FALSE);
			throw Exception("VariableType::getElementType(): unsupported type");
	}
}

void VariableType::tokenizeShortType (TokenStream& str) const
{
	switch (m_precision)
	{
		case PRECISION_LOW:		str << Token::LOW_PRECISION;	break;
		case PRECISION_MEDIUM:	str << Token::MEDIUM_PRECISION;	break;
		case PRECISION_HIGH:	str << Token::HIGH_PRECISION;	break;
		default:				/* nothing */					break;
	}

	switch (m_baseType)
	{
		case TYPE_VOID:
			str << Token::VOID;
			break;

		case TYPE_FLOAT:
			switch (m_numElements)
			{
				case 1:		str << Token::FLOAT;		break;
				case 2:		str << Token::VEC2;			break;
				case 3:		str << Token::VEC3;			break;
				case 4:		str << Token::VEC4;			break;
				default:	DE_ASSERT(DE_FALSE);		break;
			}
			break;

		case TYPE_INT:
			switch (m_numElements)
			{
				case 1:		str << Token::INT;			break;
				case 2:		str << Token::IVEC2;		break;
				case 3:		str << Token::IVEC3;		break;
				case 4:		str << Token::IVEC4;		break;
				default:	DE_ASSERT(DE_FALSE);		break;
			}
			break;

		case TYPE_BOOL:
			switch (m_numElements)
			{
				case 1:		str << Token::BOOL;			break;
				case 2:		str << Token::BVEC2;		break;
				case 3:		str << Token::BVEC3;		break;
				case 4:		str << Token::BVEC4;		break;
				default:	DE_ASSERT(DE_FALSE);		break;
			}
			break;

		case TYPE_SAMPLER_2D:		str << Token::SAMPLER2D;	break;
		case TYPE_SAMPLER_CUBE:		str << Token::SAMPLERCUBE;	break;

		case TYPE_STRUCT:
			DE_ASSERT(m_typeName != "");
			str << Token(m_typeName.c_str());
			break;

		case TYPE_ARRAY:
			DE_ASSERT(m_elementType);
			m_elementType->tokenizeShortType(str);
			str << Token::LEFT_BRACKET << Token(m_numElements) << Token::RIGHT_BRACKET;
			break;

		default:
			DE_ASSERT(DE_FALSE);
			break;
	}
}

} // rsg