framework/randomshaders/rsgShader.hpp

#ifndef _RSGSHADER_HPP
#define _RSGSHADER_HPP
/*-------------------------------------------------------------------------
 * 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 Shader Class.
 *//*--------------------------------------------------------------------*/

#include "rsgDefs.hpp"
#include "rsgVariable.hpp"
#include "rsgStatement.hpp"
#include "rsgVariableManager.hpp"
#include "rsgToken.hpp"
#include "rsgExecutionContext.hpp"

#include <vector>
#include <string>

namespace rsg
{

class Function
{
public:
								Function			(void);
								Function			(const char* name);
								~Function			(void);

	const VariableType&			getReturnType		(void) const				{ return m_returnType;		}
	void						setReturnType		(const VariableType& type)	{ m_returnType = type;		}

	void						addParameter		(Variable* variable);

	BlockStatement&				getBody				(void)			{ return m_functionBlock;	}
	const BlockStatement&		getBody				(void) const	{ return m_functionBlock;	}

	void						tokenize			(GeneratorState& state, TokenStream& stream) const;

private:
	std::string					m_name;
	std::vector<Variable*>		m_parameters;
	VariableType				m_returnType;

	BlockStatement				m_functionBlock;
};

class ShaderInput
{
public:
								ShaderInput			(const Variable* variable, ConstValueRangeAccess valueRange);
								~ShaderInput		(void) {}

	const Variable*				getVariable			(void) const	{ return m_variable;	}
	ConstValueRangeAccess		getValueRange		(void) const	{ return ConstValueRangeAccess(m_variable->getType(), &m_min[0], &m_max[0]);	}
	ValueRangeAccess			getValueRange		(void)			{ return ValueRangeAccess(m_variable->getType(), &m_min[0], &m_max[0]);			}

private:
	const Variable*				m_variable;
	std::vector<Scalar>			m_min;
	std::vector<Scalar>			m_max;
};

class Shader
{
public:
	enum Type
	{
		TYPE_VERTEX = 0,
		TYPE_FRAGMENT,

		TYPE_LAST
	};

								Shader				(Type type);
								~Shader				(void);

	Type						getType				(void) const	{ return m_type;				}
	const char*					getSource			(void) const	{ return m_source.c_str();		}

	void						execute				(ExecutionContext& execCtx) const;

	// For generator implementation only
	Function&					getMain				(void)			{ return m_mainFunction;		}
	Function&					allocateFunction	(void);

	VariableScope&				getGlobalScope		(void)			{ return m_globalScope;			}
	std::vector<Statement*>&	getGlobalStatements	(void)			{ return m_globalStatements;	}

	void						tokenize			(GeneratorState& state, TokenStream& str) const;
	void						setSource			(const char* source) { m_source = source;		}

	std::vector<ShaderInput*>&	getInputs			(void)			{ return m_inputs;				}
	std::vector<ShaderInput*>&	getUniforms			(void)			{ return m_uniforms;			}

	// For executor
	const std::vector<ShaderInput*>&	getInputs	(void) const	{ return m_inputs;				}
	const std::vector<ShaderInput*>&	getUniforms	(void) const	{ return m_uniforms;			}
	void								getOutputs	(std::vector<const Variable*>& outputs) const;

private:
	Type						m_type;

	VariableScope				m_globalScope;
	std::vector<Statement*>		m_globalStatements;

	std::vector<ShaderInput*>	m_inputs;
	std::vector<ShaderInput*>	m_uniforms;

	std::vector<Function*>		m_functions;
	Function					m_mainFunction;

	std::string					m_source;
};

} // rsg

#endif // _RSGSHADER_HPP