blob: 7203ee6442e2dd2e283e57b67b3e2186f18d7854 [file] [log] [blame]
#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