blob: e7e37f8b96b0221400a98ec410d1ea39860155c9 [file] [log] [blame]
/*-------------------------------------------------------------------------
* 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 Utilities.
*//*--------------------------------------------------------------------*/
#include "rsgUtils.hpp"
#include <set>
#include <string>
using std::set;
using std::string;
using std::vector;
namespace rsg
{
void addNewUniforms (vector<const ShaderInput*>& uniforms, set<string>& addedUniforms, const Shader& shader)
{
const vector<ShaderInput*>& shaderUniforms = shader.getUniforms();
for (vector<ShaderInput*>::const_iterator i = shaderUniforms.begin(); i != shaderUniforms.end(); i++)
{
const ShaderInput* uniform = *i;
if (addedUniforms.find(uniform->getVariable()->getName()) == addedUniforms.end())
{
addedUniforms.insert(uniform->getVariable()->getName());
uniforms.push_back(uniform);
}
}
}
void computeUnifiedUniforms (const Shader& vertexShader, const Shader& fragmentShader, std::vector<const ShaderInput*>& uniforms)
{
set<string> addedUniforms;
addNewUniforms(uniforms, addedUniforms, vertexShader);
addNewUniforms(uniforms, addedUniforms, fragmentShader);
}
void computeRandomValue (de::Random& rnd, ValueAccess dst, ConstValueRangeAccess valueRange)
{
const VariableType& type = dst.getType();
switch (type.getBaseType())
{
case VariableType::TYPE_FLOAT:
for (int ndx = 0; ndx < type.getNumElements(); ndx++)
{
const float quantizeStep = 1.0f/8.0f;
float minVal = valueRange.component(ndx).getMin().asFloat();
float maxVal = valueRange.component(ndx).getMax().asFloat();
dst.component(ndx).asFloat() = getQuantizedFloat(rnd, minVal, maxVal, quantizeStep);
}
break;
case VariableType::TYPE_BOOL:
for (int ndx = 0; ndx < type.getNumElements(); ndx++)
{
int minVal = valueRange.component(ndx).getMin().asBool() ? 1 : 0;
int maxVal = valueRange.component(ndx).getMin().asBool() ? 1 : 0;
dst.component(ndx).asBool() = rnd.getInt(minVal, maxVal) == 1;
}
break;
case VariableType::TYPE_INT:
case VariableType::TYPE_SAMPLER_2D:
case VariableType::TYPE_SAMPLER_CUBE:
for (int ndx = 0; ndx < type.getNumElements(); ndx++)
{
int minVal = valueRange.component(ndx).getMin().asInt();
int maxVal = valueRange.component(ndx).getMax().asInt();
dst.component(ndx).asInt() = rnd.getInt(minVal, maxVal);
}
break;
case VariableType::TYPE_ARRAY:
{
int numElements = type.getNumElements();
for (int ndx = 0; ndx < numElements; ndx++)
computeRandomValue(rnd, dst.arrayElement(ndx), valueRange.arrayElement(ndx));
break;
}
case VariableType::TYPE_STRUCT:
{
int numMembers = (int)type.getMembers().size();
for (int ndx = 0; ndx < numMembers; ndx++)
computeRandomValue(rnd, dst.member(ndx), valueRange.member(ndx));
break;
}
default:
TCU_FAIL("Invalid type");
}
}
void computeUniformValues (de::Random& rnd, std::vector<VariableValue>& values, const std::vector<const ShaderInput*>& uniforms)
{
DE_ASSERT(values.empty());
for (vector<const ShaderInput*>::const_iterator i = uniforms.begin(); i != uniforms.end(); i++)
{
const ShaderInput* uniform = *i;
values.push_back(VariableValue(uniform->getVariable()));
computeRandomValue(rnd, values[values.size()-1].getValue(), uniform->getValueRange());
}
}
bool isUndefinedValueRange (ConstValueRangeAccess valueRange)
{
switch (valueRange.getType().getBaseType())
{
case VariableType::TYPE_FLOAT:
case VariableType::TYPE_INT:
{
bool isFloat = valueRange.getType().getBaseType() == VariableType::TYPE_FLOAT;
Scalar infMin = isFloat ? Scalar::min<float>() : Scalar::min<int>();
Scalar infMax = isFloat ? Scalar::max<float>() : Scalar::max<int>();
for (int ndx = 0; ndx < valueRange.getType().getNumElements(); ndx++)
{
if (valueRange.getMin().component(ndx).asScalar() != infMin ||
valueRange.getMax().component(ndx).asScalar() != infMax)
return false;
}
return true;
}
case VariableType::TYPE_BOOL:
return false;
default:
TCU_FAIL("Unsupported type");
}
}
VariableType computeRandomType (GeneratorState& state, int maxScalars)
{
DE_ASSERT(maxScalars >= 1);
static const VariableType::Type baseTypes[] =
{
VariableType::TYPE_BOOL,
VariableType::TYPE_INT,
VariableType::TYPE_FLOAT
// \todo [pyry] Other types
};
VariableType::Type baseType = VariableType::TYPE_LAST;
state.getRandom().choose(baseTypes, baseTypes + DE_LENGTH_OF_ARRAY(baseTypes), &baseType, 1);
switch (baseType)
{
case VariableType::TYPE_BOOL:
case VariableType::TYPE_INT:
case VariableType::TYPE_FLOAT:
{
const int minVecLength = 1;
const int maxVecLength = 4;
return VariableType(baseType, state.getRandom().getInt(minVecLength, de::min(maxScalars, maxVecLength)));
}
default:
DE_ASSERT(DE_FALSE);
throw Exception("computeRandomType(): Unsupported type");
}
}
void computeRandomValueRange (GeneratorState& state, ValueRangeAccess valueRange)
{
const VariableType& type = valueRange.getType();
de::Random& rnd = state.getRandom();
switch (type.getBaseType())
{
case VariableType::TYPE_BOOL:
for (int ndx = 0; ndx < type.getNumElements(); ndx++)
{
bool minVal = rnd.getBool();
bool maxVal = minVal ? true : rnd.getBool();
valueRange.getMin().component(ndx).asBool() = minVal;
valueRange.getMax().component(ndx).asBool() = maxVal;
}
break;
case VariableType::TYPE_INT:
for (int ndx = 0; ndx < type.getNumElements(); ndx++)
{
const int minIntVal = -16;
const int maxIntVal = 16;
const int maxRangeLen = maxIntVal - minIntVal;
int rangeLen = rnd.getInt(0, maxRangeLen);
int minVal = minIntVal + rnd.getInt(0, maxRangeLen-rangeLen);
int maxVal = minVal + rangeLen;
valueRange.getMin().component(ndx).asInt() = minVal;
valueRange.getMax().component(ndx).asInt() = maxVal;
}
break;
case VariableType::TYPE_FLOAT:
for (int ndx = 0; ndx < type.getNumElements(); ndx++)
{
const float step = 0.1f;
const int maxSteps = 320;
const float minFloatVal = -16.0f;
int rangeLen = rnd.getInt(0, maxSteps);
int minStep = rnd.getInt(0, maxSteps-rangeLen);
float minVal = minFloatVal + step*(float)minStep;
float maxVal = minVal + step*(float)rangeLen;
valueRange.getMin().component(ndx).asFloat() = minVal;
valueRange.getMax().component(ndx).asFloat() = maxVal;
}
break;
default:
DE_ASSERT(DE_FALSE);
throw Exception("computeRandomValueRange(): Unsupported type");
}
}
int getTypeConstructorDepth (const VariableType& type)
{
switch (type.getBaseType())
{
case VariableType::TYPE_STRUCT:
{
const vector<VariableType::Member>& members = type.getMembers();
int maxDepth = 0;
for (vector<VariableType::Member>::const_iterator i = members.begin(); i != members.end(); i++)
{
const VariableType& memberType = i->getType();
int depth = 0;
switch (memberType.getBaseType())
{
case VariableType::TYPE_STRUCT:
depth = getTypeConstructorDepth(memberType);
break;
case VariableType::TYPE_BOOL:
case VariableType::TYPE_FLOAT:
case VariableType::TYPE_INT:
depth = memberType.getNumElements() == 1 ? 1 : 2;
break;
default:
DE_ASSERT(DE_FALSE);
break;
}
maxDepth = de::max(maxDepth, depth);
}
return maxDepth + 1;
}
case VariableType::TYPE_BOOL:
case VariableType::TYPE_FLOAT:
case VariableType::TYPE_INT:
return 2; // One node for ctor, another for value
default:
DE_ASSERT(DE_FALSE);
return 0;
}
}
int getConservativeValueExprDepth (const GeneratorState& state, ConstValueRangeAccess valueRange)
{
// \todo [2011-03-22 pyry] Do a look-up into variable manager?
DE_UNREF(state);
return getTypeConstructorDepth(valueRange.getType());
}
static float computeRangeLengthSum (ConstValueRangeAccess valueRange)
{
const VariableType& type = valueRange.getType();
float rangeLength = 0.0f;
switch (type.getBaseType())
{
case VariableType::TYPE_FLOAT:
for (int ndx = 0; ndx < type.getNumElements(); ndx++)
{
float minVal = valueRange.component(ndx).getMin().asFloat();
float maxVal = valueRange.component(ndx).getMax().asFloat();
rangeLength += maxVal - minVal;
}
break;
case VariableType::TYPE_BOOL:
for (int ndx = 0; ndx < type.getNumElements(); ndx++)
{
int minVal = valueRange.component(ndx).getMin().asBool() ? 1 : 0;
int maxVal = valueRange.component(ndx).getMin().asBool() ? 1 : 0;
rangeLength += (float)(maxVal - minVal);
}
break;
case VariableType::TYPE_INT:
case VariableType::TYPE_SAMPLER_2D:
case VariableType::TYPE_SAMPLER_CUBE:
for (int ndx = 0; ndx < type.getNumElements(); ndx++)
{
int minVal = valueRange.component(ndx).getMin().asInt();
int maxVal = valueRange.component(ndx).getMax().asInt();
rangeLength += (float)(maxVal - minVal);
}
break;
case VariableType::TYPE_ARRAY:
{
int numElements = type.getNumElements();
for (int ndx = 0; ndx < numElements; ndx++)
rangeLength += computeRangeLengthSum(valueRange.arrayElement(ndx));
break;
}
case VariableType::TYPE_STRUCT:
{
int numMembers = (int)type.getMembers().size();
for (int ndx = 0; ndx < numMembers; ndx++)
rangeLength += computeRangeLengthSum(valueRange.member(ndx));
break;
}
default:
TCU_FAIL("Invalid type");
}
return rangeLength;
}
float computeDynamicRangeWeight (ConstValueRangeAccess valueRange)
{
const VariableType& type = valueRange.getType();
float rangeLenSum = computeRangeLengthSum(valueRange);
int numScalars = type.getScalarSize();
return rangeLenSum / (float)numScalars;
}
} // rsg