blob: 4ab69ff914f4364e3710736a49e7b2e9c7e65e1d [file] [log] [blame] [edit]
/*-------------------------------------------------------------------------
* 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 Statements.
*//*--------------------------------------------------------------------*/
#include "rsgStatement.hpp"
#include "rsgExpressionGenerator.hpp"
#include "rsgUtils.hpp"
#include <typeinfo>
using std::vector;
namespace rsg
{
namespace
{
inline bool isCurrentTopStatementBlock (const GeneratorState& state)
{
int stackDepth = state.getStatementDepth();
return dynamic_cast<const BlockStatement*>(state.getStatementStackEntry(stackDepth-1)) != DE_NULL;
}
template <class T> float getWeight (const GeneratorState& state) { return T::getWeight(state); }
template <class T> Statement* create (GeneratorState& state) { return new T(state); }
struct StatementSpec
{
float (*getWeight) (const GeneratorState& state);
Statement* (*create) (GeneratorState& state);
};
const StatementSpec* chooseStatement (GeneratorState& state)
{
static const StatementSpec statementSpecs[] =
{
{ getWeight<BlockStatement>, create<BlockStatement> },
{ getWeight<ExpressionStatement>, create<ExpressionStatement> },
{ getWeight<DeclarationStatement>, create<DeclarationStatement> },
{ getWeight<ConditionalStatement>, create<ConditionalStatement> }
};
float weights[DE_LENGTH_OF_ARRAY(statementSpecs)];
// Compute weights
float sum = 0.0f;
for (int ndx = 0; ndx < (int)DE_LENGTH_OF_ARRAY(statementSpecs); ndx++)
{
weights[ndx] = statementSpecs[ndx].getWeight(state);
sum += weights[ndx];
}
DE_ASSERT(sum > 0.0f);
// Random number in range
float p = state.getRandom().getFloat(0.0f, sum);
const StatementSpec* spec = DE_NULL;
const StatementSpec* lastNonZero = DE_NULL;
// Find element in that point
sum = 0.0f;
for (int ndx = 0; ndx < (int)DE_LENGTH_OF_ARRAY(statementSpecs); ndx++)
{
sum += weights[ndx];
if (p < sum)
{
spec = &statementSpecs[ndx];
break;
}
else if (weights[ndx] > 0.0f)
lastNonZero = &statementSpecs[ndx];
}
if (!spec)
spec = lastNonZero;
return spec;
}
Statement* createStatement (GeneratorState& state)
{
return chooseStatement(state)->create(state);
}
} // anonymous
Statement::Statement (void)
{
}
Statement::~Statement (void)
{
}
ExpressionStatement::ExpressionStatement (GeneratorState& state)
: m_expression(DE_NULL)
{
ExpressionGenerator generator(state);
m_expression = generator.generate(ValueRange(VariableType(VariableType::TYPE_VOID)));
}
ExpressionStatement::~ExpressionStatement (void)
{
delete m_expression;
}
float ExpressionStatement::getWeight (const GeneratorState& state)
{
DE_UNREF(state);
return 1.0f;
}
void ExpressionStatement::execute (ExecutionContext& execCtx) const
{
m_expression->evaluate(execCtx);
}
BlockStatement::BlockStatement (GeneratorState& state)
{
init(state);
}
void BlockStatement::init (GeneratorState& state)
{
// Select number of children statements to construct
m_numChildrenToCreate = state.getRandom().getInt(0, state.getShaderParameters().maxStatementsPerBlock);
// Push scope
state.getVariableManager().pushVariableScope(m_scope);
}
BlockStatement::~BlockStatement (void)
{
for (vector<Statement*>::iterator i = m_children.begin(); i != m_children.end(); i++)
delete *i;
m_children.clear();
}
void BlockStatement::addChild (Statement* statement)
{
try
{
m_children.push_back(statement);
}
catch (const std::exception&)
{
delete statement;
throw;
}
}
Statement* BlockStatement::createNextChild (GeneratorState& state)
{
if ((int)m_children.size() < m_numChildrenToCreate)
{
// Select and create a new child
Statement* child = createStatement(state);
addChild(child);
return child;
}
else
{
// Done, pop scope
state.getVariableManager().popVariableScope();
return DE_NULL;
}
}
float BlockStatement::getWeight (const GeneratorState& state)
{
if (state.getStatementDepth()+1 < state.getShaderParameters().maxStatementDepth)
{
if (isCurrentTopStatementBlock(state))
return 0.2f; // Low probability for anonymous blocks.
else
return 1.0f;
}
else
return 0.0f;
}
void BlockStatement::tokenize (GeneratorState& state, TokenStream& str) const
{
str << Token::LEFT_BRACE << Token::NEWLINE << Token::INDENT_INC;
for (vector<Statement*>::const_reverse_iterator i = m_children.rbegin(); i != m_children.rend(); i++)
(*i)->tokenize(state, str);
str << Token::INDENT_DEC << Token::RIGHT_BRACE << Token::NEWLINE;
}
void BlockStatement::execute (ExecutionContext& execCtx) const
{
for (vector<Statement*>::const_reverse_iterator i = m_children.rbegin(); i != m_children.rend(); i++)
(*i)->execute(execCtx);
}
void ExpressionStatement::tokenize (GeneratorState& state, TokenStream& str) const
{
DE_ASSERT(m_expression);
m_expression->tokenize(state, str);
str << Token::SEMICOLON << Token::NEWLINE;
}
namespace
{
inline bool canDeclareVariable (const Variable* variable)
{
return variable->getStorage() == Variable::STORAGE_LOCAL;
}
bool hasDeclarableVars (const VariableManager& varMgr)
{
const vector<Variable*>& liveVars = varMgr.getLiveVariables();
for (vector<Variable*>::const_iterator i = liveVars.begin(); i != liveVars.end(); i++)
{
if (canDeclareVariable(*i))
return true;
}
return false;
}
} // anonymous
DeclarationStatement::DeclarationStatement (GeneratorState& state, Variable* variable)
: m_variable (DE_NULL)
, m_expression (DE_NULL)
{
if (variable == DE_NULL)
{
// Choose random
// \todo [2011-02-03 pyry] Allocate a new here?
// \todo [2011-05-26 pyry] Weights?
const vector<Variable*>& liveVars = state.getVariableManager().getLiveVariables();
vector<Variable*> candidates;
for (vector<Variable*>::const_iterator i = liveVars.begin(); i != liveVars.end(); i++)
{
if (canDeclareVariable(*i))
candidates.push_back(*i);
}
variable = state.getRandom().choose<Variable*>(candidates.begin(), candidates.end());
}
DE_ASSERT(variable);
m_variable = variable;
const ValueEntry* value = state.getVariableManager().getValue(variable);
bool createInitializer = false;
switch (m_variable->getStorage())
{
case Variable::STORAGE_CONST:
DE_ASSERT(value);
createInitializer = true;
break;
case Variable::STORAGE_LOCAL:
// \note Currently booleans are always treated as not having undefined range and thus
// initializer is always created.
createInitializer = value && !isUndefinedValueRange(value->getValueRange());
break;
default:
createInitializer = false;
break;
}
if (createInitializer)
{
ExpressionGenerator generator(state);
// Take copy of value range for generating initializer expression
ValueRange valueRange = value->getValueRange();
// Declare (removes value entry)
state.getVariableManager().declareVariable(variable);
bool isConst = m_variable->getStorage() == Variable::STORAGE_CONST;
if (isConst)
state.pushExpressionFlags(state.getExpressionFlags() | CONST_EXPR);
m_expression = generator.generate(valueRange, 1);
if (isConst)
state.popExpressionFlags();
}
else
state.getVariableManager().declareVariable(variable);
}
DeclarationStatement::~DeclarationStatement (void)
{
delete m_expression;
}
float DeclarationStatement::getWeight (const GeneratorState& state)
{
if (!hasDeclarableVars(state.getVariableManager()))
return 0.0f;
if (!isCurrentTopStatementBlock(state))
return 0.0f;
return state.getProgramParameters().declarationStatementBaseWeight;
}
void DeclarationStatement::tokenize (GeneratorState& state, TokenStream& str) const
{
m_variable->tokenizeDeclaration(state, str);
if (m_expression)
{
str << Token::EQUAL;
m_expression->tokenize(state, str);
}
str << Token::SEMICOLON << Token::NEWLINE;
}
void DeclarationStatement::execute (ExecutionContext& execCtx) const
{
if (m_expression)
{
m_expression->evaluate(execCtx);
execCtx.getValue(m_variable) = m_expression->getValue().value();
}
}
ConditionalStatement::ConditionalStatement (GeneratorState&)
: m_condition (DE_NULL)
, m_trueStatement (DE_NULL)
, m_falseStatement (DE_NULL)
{
}
ConditionalStatement::~ConditionalStatement (void)
{
delete m_condition;
delete m_trueStatement;
delete m_falseStatement;
}
bool ConditionalStatement::isElseBlockRequired (const GeneratorState& state) const
{
// If parent is conditional statement with else block and this is the true statement,
// else block must be generated or otherwise parent "else" will end up parsed as else statement for this if.
const ConditionalStatement* curChild = this;
int curStackNdx = state.getStatementDepth()-2;
while (curStackNdx >= 0)
{
const ConditionalStatement* curParent = dynamic_cast<const ConditionalStatement*>(state.getStatementStackEntry(curStackNdx));
if (!curParent)
break; // Not a conditional statement - can end search here.
if (curChild == curParent->m_trueStatement && curParent->m_falseStatement)
return true; // Else block is mandatory.
// Continue search.
curChild = curParent;
curStackNdx -= 1;
}
return false;
}
Statement* ConditionalStatement::createNextChild (GeneratorState& state)
{
// If has neither true or false statements, choose randomly whether to create false block.
if (!m_falseStatement && !m_trueStatement && (isElseBlockRequired(state) || state.getRandom().getBool()))
{
// Construct false statement
state.getVariableManager().pushValueScope(m_conditionalScope);
m_falseStatement = createStatement(state);
return m_falseStatement;
}
else if (!m_trueStatement)
{
if (m_falseStatement)
{
// Pop previous value scope.
state.getVariableManager().popValueScope();
m_conditionalScope.clear();
}
// Construct true statement
state.getVariableManager().pushValueScope(m_conditionalScope);
m_trueStatement = createStatement(state);
return m_trueStatement;
}
else
{
// Pop conditional scope.
state.getVariableManager().popValueScope();
m_conditionalScope.clear();
// Create condition
DE_ASSERT(!m_condition);
ExpressionGenerator generator(state);
ValueRange range = ValueRange(VariableType::getScalarType(VariableType::TYPE_BOOL));
range.getMin().asBool() = false;
range.getMax().asBool() = true;
m_condition = generator.generate(range, 1);
return DE_NULL; // Done with this statement
}
}
namespace
{
bool isBlockStatement (const Statement* statement)
{
return dynamic_cast<const BlockStatement*>(statement) != DE_NULL;
}
bool isConditionalStatement (const Statement* statement)
{
return dynamic_cast<const ConditionalStatement*>(statement) != DE_NULL;
}
} // anonymous
void ConditionalStatement::tokenize (GeneratorState& state, TokenStream& str) const
{
DE_ASSERT(m_condition && m_trueStatement);
// if (condition)
str << Token::IF << Token::LEFT_PAREN;
m_condition->tokenize(state, str);
str << Token::RIGHT_PAREN << Token::NEWLINE;
// Statement executed if true
if (!isBlockStatement(m_trueStatement))
{
str << Token::INDENT_INC;
m_trueStatement->tokenize(state, str);
str << Token::INDENT_DEC;
}
else
m_trueStatement->tokenize(state, str);
if (m_falseStatement)
{
str << Token::ELSE;
if (isConditionalStatement(m_falseStatement))
{
m_falseStatement->tokenize(state, str);
}
else if (isBlockStatement(m_falseStatement))
{
str << Token::NEWLINE;
m_falseStatement->tokenize(state, str);
}
else
{
str << Token::NEWLINE << Token::INDENT_INC;
m_falseStatement->tokenize(state, str);
str << Token::INDENT_DEC;
}
}
}
void ConditionalStatement::execute (ExecutionContext& execCtx) const
{
// Evaluate condition
m_condition->evaluate(execCtx);
ExecMaskStorage maskStorage; // Value might change when we are evaluating true block so we have to take a copy.
ExecValueAccess trueMask = maskStorage.getValue();
trueMask = m_condition->getValue().value();
// And mask, execute true statement and pop
execCtx.andExecutionMask(trueMask);
m_trueStatement->execute(execCtx);
execCtx.popExecutionMask();
if (m_falseStatement)
{
// Construct negated mask, execute false statement and pop
ExecMaskStorage tmp;
ExecValueAccess falseMask = tmp.getValue();
for (int i = 0; i < EXEC_VEC_WIDTH; i++)
falseMask.asBool(i) = !trueMask.asBool(i);
execCtx.andExecutionMask(falseMask);
m_falseStatement->execute(execCtx);
execCtx.popExecutionMask();
}
}
float ConditionalStatement::getWeight (const GeneratorState& state)
{
if (!state.getProgramParameters().useConditionals)
return 0.0f;
int availableLevels = state.getShaderParameters().maxStatementDepth - state.getStatementDepth();
return (availableLevels > 1) ? 1.0f : 0.0f;
}
AssignStatement::AssignStatement (const Variable* variable, Expression* value)
: m_variable (variable)
, m_valueExpr (value) // \note Takes ownership of value
{
}
AssignStatement::AssignStatement (GeneratorState& state, const Variable* variable, ConstValueRangeAccess valueRange)
: m_variable (variable)
, m_valueExpr (DE_NULL)
{
// Generate random value
ExpressionGenerator generator(state);
m_valueExpr = generator.generate(valueRange, 1);
}
AssignStatement::~AssignStatement (void)
{
delete m_valueExpr;
}
void AssignStatement::tokenize (GeneratorState& state, TokenStream& str) const
{
str << Token(m_variable->getName()) << Token::EQUAL;
m_valueExpr->tokenize(state, str);
str << Token::SEMICOLON << Token::NEWLINE;
}
void AssignStatement::execute (ExecutionContext& execCtx) const
{
m_valueExpr->evaluate(execCtx);
assignMasked(execCtx.getValue(m_variable), m_valueExpr->getValue(), execCtx.getExecutionMask());
}
} // rsg