| /*------------------------------------------------------------------------- |
| * 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 Expressions. |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "rsgExpression.hpp" |
| #include "rsgVariableManager.hpp" |
| #include "rsgBinaryOps.hpp" |
| #include "rsgBuiltinFunctions.hpp" |
| #include "rsgUtils.hpp" |
| #include "deMath.h" |
| |
| using std::vector; |
| |
| namespace rsg |
| { |
| |
| namespace |
| { |
| |
| class IsReadableEntry |
| { |
| public: |
| typedef ValueEntryIterator<IsReadableEntry> Iterator; |
| |
| IsReadableEntry(uint32_t exprFlags) : m_exprFlags(exprFlags) |
| { |
| } |
| |
| bool operator()(const ValueEntry *entry) const |
| { |
| if ((m_exprFlags & CONST_EXPR) && (entry->getVariable()->getStorage() != Variable::STORAGE_CONST)) |
| return false; |
| |
| return true; |
| } |
| |
| private: |
| uint32_t m_exprFlags; |
| }; |
| |
| class IsReadableIntersectingEntry : public IsReadableEntry |
| { |
| public: |
| typedef ValueEntryIterator<IsReadableIntersectingEntry> Iterator; |
| |
| IsReadableIntersectingEntry(ConstValueRangeAccess valueRange, uint32_t exprFlags) |
| : IsReadableEntry(exprFlags) |
| , m_valueRange(valueRange) |
| { |
| } |
| |
| bool operator()(const ValueEntry *entry) const |
| { |
| if (!IsReadableEntry::operator()(entry)) |
| return false; |
| |
| if (entry->getValueRange().getType() != m_valueRange.getType()) |
| return false; |
| |
| if (!entry->getValueRange().intersects(m_valueRange)) |
| return false; |
| |
| return true; |
| } |
| |
| private: |
| ConstValueRangeAccess m_valueRange; |
| }; |
| |
| class IsWritableIntersectingEntry : public IsWritableEntry |
| { |
| public: |
| typedef ValueEntryIterator<IsWritableIntersectingEntry> Iterator; |
| |
| IsWritableIntersectingEntry(ConstValueRangeAccess valueRange) : m_valueRange(valueRange) |
| { |
| } |
| |
| bool operator()(const ValueEntry *entry) const |
| { |
| return IsWritableEntry::operator()(entry) && entry->getVariable()->getType() == m_valueRange.getType() && |
| entry->getValueRange().intersects(m_valueRange); |
| } |
| |
| private: |
| ConstValueRangeAccess m_valueRange; |
| }; |
| |
| class IsWritableSupersetEntry : public IsWritableEntry |
| { |
| public: |
| typedef ValueEntryIterator<IsWritableSupersetEntry> Iterator; |
| |
| IsWritableSupersetEntry(ConstValueRangeAccess valueRange) : m_valueRange(valueRange) |
| { |
| } |
| |
| bool operator()(const ValueEntry *entry) const |
| { |
| return IsWritableEntry()(entry) && entry->getVariable()->getType() == m_valueRange.getType() && |
| entry->getValueRange().isSupersetOf(m_valueRange); |
| } |
| |
| private: |
| ConstValueRangeAccess m_valueRange; |
| }; |
| |
| class IsSamplerEntry |
| { |
| public: |
| typedef ValueEntryIterator<IsSamplerEntry> Iterator; |
| |
| IsSamplerEntry(VariableType::Type type) : m_type(type) |
| { |
| DE_ASSERT(m_type == VariableType::TYPE_SAMPLER_2D || m_type == VariableType::TYPE_SAMPLER_CUBE); |
| } |
| |
| bool operator()(const ValueEntry *entry) const |
| { |
| if (entry->getVariable()->getType() == VariableType(m_type, 1)) |
| { |
| DE_ASSERT(entry->getVariable()->getStorage() == Variable::STORAGE_UNIFORM); |
| return true; |
| } |
| else |
| return false; |
| } |
| |
| private: |
| VariableType::Type m_type; |
| }; |
| |
| inline bool getWeightedBool(de::Random &random, float trueWeight) |
| { |
| DE_ASSERT(de::inRange<float>(trueWeight, 0.0f, 1.0f)); |
| return (random.getFloat() < trueWeight); |
| } |
| |
| void computeRandomValueRangeForInfElements(GeneratorState &state, ValueRangeAccess valueRange) |
| { |
| const VariableType &type = valueRange.getType(); |
| de::Random &rnd = state.getRandom(); |
| |
| switch (type.getBaseType()) |
| { |
| case VariableType::TYPE_BOOL: |
| // No need to handle bool as it will be false, true |
| break; |
| |
| case VariableType::TYPE_INT: |
| for (int ndx = 0; ndx < type.getNumElements(); ndx++) |
| { |
| if (valueRange.getMin().component(ndx).asScalar() != Scalar::min<int>() || |
| valueRange.getMax().component(ndx).asScalar() != Scalar::max<int>()) |
| continue; |
| |
| 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++) |
| { |
| if (valueRange.getMin().component(ndx).asScalar() != Scalar::min<float>() || |
| valueRange.getMax().component(ndx).asScalar() != Scalar::max<float>()) |
| continue; |
| |
| 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(false); |
| throw Exception("computeRandomValueRangeForInfElements(): unsupported type"); |
| } |
| } |
| |
| void setInfiniteRange(ValueRangeAccess valueRange) |
| { |
| const VariableType &type = valueRange.getType(); |
| |
| switch (type.getBaseType()) |
| { |
| case VariableType::TYPE_BOOL: |
| for (int ndx = 0; ndx < type.getNumElements(); ndx++) |
| { |
| valueRange.getMin().component(ndx) = Scalar::min<bool>(); |
| valueRange.getMax().component(ndx) = Scalar::max<bool>(); |
| } |
| break; |
| |
| case VariableType::TYPE_INT: |
| for (int ndx = 0; ndx < type.getNumElements(); ndx++) |
| { |
| valueRange.getMin().component(ndx) = Scalar::min<int>(); |
| valueRange.getMax().component(ndx) = Scalar::max<int>(); |
| } |
| break; |
| |
| case VariableType::TYPE_FLOAT: |
| for (int ndx = 0; ndx < type.getNumElements(); ndx++) |
| { |
| valueRange.getMin().component(ndx) = Scalar::min<float>(); |
| valueRange.getMax().component(ndx) = Scalar::max<float>(); |
| } |
| break; |
| |
| default: |
| DE_ASSERT(false); |
| throw Exception("setInfiniteRange(): unsupported type"); |
| } |
| } |
| |
| bool canAllocateVariable(const GeneratorState &state, const VariableType &type) |
| { |
| DE_ASSERT(!type.isVoid()); |
| |
| if (state.getExpressionFlags() & NO_VAR_ALLOCATION) |
| return false; |
| |
| if (state.getVariableManager().getNumAllocatedScalars() + type.getScalarSize() > |
| state.getShaderParameters().maxCombinedVariableScalars) |
| return false; |
| |
| return true; |
| } |
| |
| template <class T> |
| float getWeight(const GeneratorState &state, ConstValueRangeAccess valueRange) |
| { |
| return T::getWeight(state, valueRange); |
| } |
| template <class T> |
| Expression *create(GeneratorState &state, ConstValueRangeAccess valueRange) |
| { |
| return new T(state, valueRange); |
| } |
| |
| struct ExpressionSpec |
| { |
| float (*getWeight)(const GeneratorState &state, ConstValueRangeAccess valueRange); |
| Expression *(*create)(GeneratorState &state, ConstValueRangeAccess valueRange); |
| }; |
| |
| static const ExpressionSpec s_expressionSpecs[] = {{getWeight<FloatLiteral>, create<FloatLiteral>}, |
| {getWeight<IntLiteral>, create<IntLiteral>}, |
| {getWeight<BoolLiteral>, create<BoolLiteral>}, |
| {getWeight<ConstructorOp>, create<ConstructorOp>}, |
| {getWeight<AssignOp>, create<AssignOp>}, |
| {getWeight<VariableRead>, create<VariableRead>}, |
| {getWeight<MulOp>, create<MulOp>}, |
| {getWeight<AddOp>, create<AddOp>}, |
| {getWeight<SubOp>, create<SubOp>}, |
| {getWeight<LessThanOp>, create<LessThanOp>}, |
| {getWeight<LessOrEqualOp>, create<LessOrEqualOp>}, |
| {getWeight<GreaterThanOp>, create<GreaterThanOp>}, |
| {getWeight<GreaterOrEqualOp>, create<GreaterOrEqualOp>}, |
| {getWeight<EqualOp>, create<EqualOp>}, |
| {getWeight<NotEqualOp>, create<NotEqualOp>}, |
| {getWeight<SwizzleOp>, create<SwizzleOp>}, |
| {getWeight<SinOp>, create<SinOp>}, |
| {getWeight<CosOp>, create<CosOp>}, |
| {getWeight<TanOp>, create<TanOp>}, |
| {getWeight<AsinOp>, create<AsinOp>}, |
| {getWeight<AcosOp>, create<AcosOp>}, |
| {getWeight<AtanOp>, create<AtanOp>}, |
| {getWeight<ExpOp>, create<ExpOp>}, |
| {getWeight<LogOp>, create<LogOp>}, |
| {getWeight<Exp2Op>, create<Exp2Op>}, |
| {getWeight<Log2Op>, create<Log2Op>}, |
| {getWeight<SqrtOp>, create<SqrtOp>}, |
| {getWeight<InvSqrtOp>, create<InvSqrtOp>}, |
| {getWeight<ParenOp>, create<ParenOp>}, |
| {getWeight<TexLookup>, create<TexLookup>}}; |
| |
| static const ExpressionSpec s_lvalueSpecs[] = {{getWeight<VariableWrite>, create<VariableWrite>}}; |
| |
| #if !defined(DE_MAX) |
| #define DE_MAX(a, b) ((b) > (a) ? (b) : (a)) |
| #endif |
| |
| enum |
| { |
| MAX_EXPRESSION_SPECS = (int)DE_MAX(DE_LENGTH_OF_ARRAY(s_expressionSpecs), DE_LENGTH_OF_ARRAY(s_lvalueSpecs)) |
| }; |
| |
| const ExpressionSpec *chooseExpression(GeneratorState &state, const ExpressionSpec *specs, int numSpecs, |
| ConstValueRangeAccess valueRange) |
| { |
| float weights[MAX_EXPRESSION_SPECS]; |
| |
| DE_ASSERT(numSpecs <= (int)DE_LENGTH_OF_ARRAY(weights)); |
| |
| // Compute weights |
| for (int ndx = 0; ndx < numSpecs; ndx++) |
| weights[ndx] = specs[ndx].getWeight(state, valueRange); |
| |
| // Choose |
| return &state.getRandom().chooseWeighted<const ExpressionSpec &>(specs, specs + numSpecs, weights); |
| } |
| |
| } // namespace |
| |
| Expression::~Expression(void) |
| { |
| } |
| |
| Expression *Expression::createRandom(GeneratorState &state, ConstValueRangeAccess valueRange) |
| { |
| return chooseExpression(state, s_expressionSpecs, (int)DE_LENGTH_OF_ARRAY(s_expressionSpecs), valueRange) |
| ->create(state, valueRange); |
| } |
| |
| Expression *Expression::createRandomLValue(GeneratorState &state, ConstValueRangeAccess valueRange) |
| { |
| return chooseExpression(state, s_lvalueSpecs, (int)DE_LENGTH_OF_ARRAY(s_lvalueSpecs), valueRange) |
| ->create(state, valueRange); |
| } |
| |
| FloatLiteral::FloatLiteral(GeneratorState &state, ConstValueRangeAccess valueRange) |
| : m_value(VariableType::getScalarType(VariableType::TYPE_FLOAT)) |
| { |
| float minVal = -10.0f; |
| float maxVal = +10.0f; |
| float step = 0.25f; |
| |
| if (valueRange.getType() == VariableType(VariableType::TYPE_FLOAT, 1)) |
| { |
| minVal = valueRange.getMin().component(0).asFloat(); |
| maxVal = valueRange.getMax().component(0).asFloat(); |
| |
| if (Scalar::min<float>() == minVal) |
| minVal = -10.0f; |
| |
| if (Scalar::max<float>() == maxVal) |
| maxVal = +10.0f; |
| } |
| |
| int numSteps = (int)((maxVal - minVal) / step) + 1; |
| |
| const float value = deFloatClamp(minVal + step * (float)state.getRandom().getInt(0, numSteps), minVal, maxVal); |
| ExecValueAccess access = m_value.getValue(VariableType::getScalarType(VariableType::TYPE_FLOAT)); |
| |
| for (int ndx = 0; ndx < EXEC_VEC_WIDTH; ndx++) |
| access.asFloat(ndx) = value; |
| } |
| |
| FloatLiteral::FloatLiteral(float customValue) : m_value(VariableType::getScalarType(VariableType::TYPE_FLOAT)) |
| { |
| // This constructor is required to handle corner case in which comparision |
| // of two same floats produced different results - this was resolved by |
| // adding FloatLiteral containing epsilon to one of values |
| ExecValueAccess access = m_value.getValue(VariableType::getScalarType(VariableType::TYPE_FLOAT)); |
| |
| for (int ndx = 0; ndx < EXEC_VEC_WIDTH; ndx++) |
| access.asFloat(ndx) = customValue; |
| } |
| |
| float FloatLiteral::getWeight(const GeneratorState &state, ConstValueRangeAccess valueRange) |
| { |
| DE_UNREF(state); |
| const VariableType &type = valueRange.getType(); |
| if (type == VariableType(VariableType::TYPE_FLOAT, 1)) |
| { |
| float minVal = valueRange.getMin().asFloat(); |
| float maxVal = valueRange.getMax().asFloat(); |
| |
| if (Scalar::min<float>() == minVal && Scalar::max<float>() == maxVal) |
| return 0.1f; |
| |
| // Weight based on value range length |
| float rangeLength = maxVal - minVal; |
| |
| DE_ASSERT(rangeLength >= 0.0f); |
| return deFloatMax(0.1f, 1.0f - rangeLength); |
| } |
| else if (type.isVoid()) |
| return unusedValueWeight; |
| else |
| return 0.0f; |
| } |
| |
| void FloatLiteral::tokenize(GeneratorState &state, TokenStream &str) const |
| { |
| DE_UNREF(state); |
| str << Token(m_value.getValue(VariableType::getScalarType(VariableType::TYPE_FLOAT)).asFloat(0)); |
| } |
| |
| IntLiteral::IntLiteral(GeneratorState &state, ConstValueRangeAccess valueRange) |
| : m_value(VariableType::getScalarType(VariableType::TYPE_INT)) |
| { |
| int minVal = -16; |
| int maxVal = +16; |
| |
| if (valueRange.getType() == VariableType(VariableType::TYPE_INT, 1)) |
| { |
| minVal = valueRange.getMin().component(0).asInt(); |
| maxVal = valueRange.getMax().component(0).asInt(); |
| |
| if (Scalar::min<int>() == minVal) |
| minVal = -16; |
| |
| if (Scalar::max<int>() == maxVal) |
| maxVal = 16; |
| } |
| |
| int value = state.getRandom().getInt(minVal, maxVal); |
| ExecValueAccess access = m_value.getValue(VariableType::getScalarType(VariableType::TYPE_INT)); |
| |
| for (int ndx = 0; ndx < EXEC_VEC_WIDTH; ndx++) |
| access.asInt(ndx) = value; |
| } |
| |
| float IntLiteral::getWeight(const GeneratorState &state, ConstValueRangeAccess valueRange) |
| { |
| DE_UNREF(state); |
| const VariableType &type = valueRange.getType(); |
| if (type == VariableType(VariableType::TYPE_INT, 1)) |
| { |
| int minVal = valueRange.getMin().asInt(); |
| int maxVal = valueRange.getMax().asInt(); |
| |
| if (Scalar::min<int>() == minVal && Scalar::max<int>() == maxVal) |
| return 0.1f; |
| |
| int rangeLength = maxVal - minVal; |
| |
| DE_ASSERT(rangeLength >= 0); |
| return deFloatMax(0.1f, 1.0f - (float)rangeLength / 4.0f); |
| } |
| else if (type.isVoid()) |
| return unusedValueWeight; |
| else |
| return 0.0f; |
| } |
| |
| void IntLiteral::tokenize(GeneratorState &state, TokenStream &str) const |
| { |
| DE_UNREF(state); |
| str << Token(m_value.getValue(VariableType::getScalarType(VariableType::TYPE_INT)).asInt(0)); |
| } |
| |
| BoolLiteral::BoolLiteral(GeneratorState &state, ConstValueRangeAccess valueRange) |
| : m_value(VariableType::getScalarType(VariableType::TYPE_BOOL)) |
| { |
| int minVal = 0; |
| int maxVal = 1; |
| |
| if (valueRange.getType() == VariableType(VariableType::TYPE_BOOL, 1)) |
| { |
| minVal = valueRange.getMin().component(0).asBool() ? 1 : 0; |
| maxVal = valueRange.getMax().component(0).asBool() ? 1 : 0; |
| } |
| |
| bool value = state.getRandom().getInt(minVal, maxVal) == 1; |
| ExecValueAccess access = m_value.getValue(VariableType::getScalarType(VariableType::TYPE_BOOL)); |
| |
| for (int ndx = 0; ndx < EXEC_VEC_WIDTH; ndx++) |
| access.asBool(ndx) = value; |
| } |
| |
| BoolLiteral::BoolLiteral(bool customValue) : m_value(VariableType::getScalarType(VariableType::TYPE_BOOL)) |
| { |
| // This constructor is required to handle corner case in which comparision |
| // of two same floats produced different results - this was resolved by |
| // adding FloatLiteral containing epsilon to one of values |
| ExecValueAccess access = m_value.getValue(VariableType::getScalarType(VariableType::TYPE_BOOL)); |
| |
| for (int ndx = 0; ndx < EXEC_VEC_WIDTH; ndx++) |
| access.asBool(ndx) = customValue; |
| } |
| |
| float BoolLiteral::getWeight(const GeneratorState &state, ConstValueRangeAccess valueRange) |
| { |
| DE_UNREF(state); |
| const VariableType &type = valueRange.getType(); |
| if (type == VariableType(VariableType::TYPE_BOOL, 1)) |
| return 0.5f; |
| else if (type.isVoid()) |
| return unusedValueWeight; |
| else |
| return 0.0f; |
| } |
| |
| void BoolLiteral::tokenize(GeneratorState &state, TokenStream &str) const |
| { |
| DE_UNREF(state); |
| str << Token(m_value.getValue(VariableType::getScalarType(VariableType::TYPE_BOOL)).asBool(0)); |
| } |
| |
| namespace |
| { |
| |
| // \note int-bool and float-bool conversions handled in a special way. |
| template <typename SrcType, typename DstType> |
| inline DstType convert(SrcType src) |
| { |
| if (Scalar::min<SrcType>() == src) |
| return Scalar::min<DstType>().template as<DstType>(); |
| else if (Scalar::max<SrcType>() == src) |
| return Scalar::max<DstType>().template as<DstType>(); |
| else |
| return DstType(src); |
| } |
| |
| // According to GLSL ES spec. |
| template <> |
| inline bool convert<float, bool>(float src) |
| { |
| return src != 0.0f; |
| } |
| template <> |
| inline bool convert<int, bool>(int src) |
| { |
| return src != 0; |
| } |
| template <> |
| inline bool convert<bool, bool>(bool src) |
| { |
| return src; |
| } |
| template <> |
| inline float convert<bool, float>(bool src) |
| { |
| return src ? 1.0f : 0.0f; |
| } |
| template <> |
| inline int convert<bool, int>(bool src) |
| { |
| return src ? 1 : 0; |
| } |
| |
| template <> |
| inline int convert<float, int>(float src) |
| { |
| if (Scalar::min<float>() == src) |
| return Scalar::min<int>().as<int>(); |
| else if (Scalar::max<float>() == src) |
| return Scalar::max<int>().as<int>(); |
| else if (src > 0.0f) |
| return (int)deFloatFloor(src); |
| else |
| return (int)deFloatCeil(src); |
| } |
| |
| template <typename SrcType, typename DstType> |
| inline void convertValueRange(SrcType srcMin, SrcType srcMax, DstType &dstMin, DstType &dstMax) |
| { |
| dstMin = convert<SrcType, DstType>(srcMin); |
| dstMax = convert<SrcType, DstType>(srcMax); |
| } |
| |
| template <> |
| inline void convertValueRange<float, int>(float srcMin, float srcMax, int &dstMin, int &dstMax) |
| { |
| if (Scalar::min<float>() == srcMin) |
| dstMin = Scalar::min<int>().as<int>(); |
| else |
| dstMin = (int)deFloatCeil(srcMin); |
| |
| if (Scalar::max<float>() == srcMax) |
| dstMax = Scalar::max<int>().as<int>(); |
| else |
| dstMax = (int)deFloatFloor(srcMax); |
| } |
| |
| template <> |
| inline void convertValueRange<float, bool>(float srcMin, float srcMax, bool &dstMin, bool &dstMax) |
| { |
| dstMin = srcMin > 0.0f; |
| dstMax = srcMax > 0.0f; |
| } |
| |
| // \todo [pyry] More special cases? |
| |
| // Returns whether it is possible to convert some SrcType value range to given DstType valueRange |
| template <typename SrcType, typename DstType> |
| bool isConversionOk(DstType min, DstType max) |
| { |
| SrcType sMin, sMax; |
| convertValueRange(min, max, sMin, sMax); |
| return sMin <= sMax && de::inRange(convert<SrcType, DstType>(sMin), min, max) && |
| de::inRange(convert<SrcType, DstType>(sMax), min, max); |
| } |
| |
| // Work-around for non-deterministic float behavior |
| template <> |
| bool isConversionOk<float, float>(float, float) |
| { |
| return true; |
| } |
| |
| // \todo [2011-03-26 pyry] Provide this in ValueAccess? |
| template <typename T> |
| T getValueAccessValue(ConstValueAccess access); |
| template <> |
| inline float getValueAccessValue<float>(ConstValueAccess access) |
| { |
| return access.asFloat(); |
| } |
| template <> |
| inline int getValueAccessValue<int>(ConstValueAccess access) |
| { |
| return access.asInt(); |
| } |
| template <> |
| inline bool getValueAccessValue<bool>(ConstValueAccess access) |
| { |
| return access.asBool(); |
| } |
| |
| template <typename T> |
| T &getValueAccessValue(ValueAccess access); |
| template <> |
| inline float &getValueAccessValue<float>(ValueAccess access) |
| { |
| return access.asFloat(); |
| } |
| template <> |
| inline int &getValueAccessValue<int>(ValueAccess access) |
| { |
| return access.asInt(); |
| } |
| template <> |
| inline bool &getValueAccessValue<bool>(ValueAccess access) |
| { |
| return access.asBool(); |
| } |
| |
| template <typename SrcType, typename DstType> |
| bool isConversionOk(ConstValueRangeAccess valueRange) |
| { |
| return isConversionOk<SrcType>(getValueAccessValue<DstType>(valueRange.getMin()), |
| getValueAccessValue<DstType>(valueRange.getMax())); |
| } |
| |
| template <typename SrcType, typename DstType> |
| void convertValueRangeTempl(ConstValueRangeAccess src, ValueRangeAccess dst) |
| { |
| DstType dMin, dMax; |
| convertValueRange(getValueAccessValue<SrcType>(src.getMin()), getValueAccessValue<SrcType>(src.getMax()), dMin, |
| dMax); |
| getValueAccessValue<DstType>(dst.getMin()) = dMin; |
| getValueAccessValue<DstType>(dst.getMax()) = dMax; |
| } |
| |
| template <typename SrcType, typename DstType> |
| void convertExecValueTempl(ExecConstValueAccess src, ExecValueAccess dst) |
| { |
| for (int ndx = 0; ndx < EXEC_VEC_WIDTH; ndx++) |
| dst.as<DstType>(ndx) = convert<SrcType, DstType>(src.as<SrcType>(ndx)); |
| } |
| |
| typedef bool (*IsConversionOkFunc)(ConstValueRangeAccess); |
| typedef void (*ConvertValueRangeFunc)(ConstValueRangeAccess, ValueRangeAccess); |
| typedef void (*ConvertExecValueFunc)(ExecConstValueAccess, ExecValueAccess); |
| |
| inline int getBaseTypeConvNdx(VariableType::Type type) |
| { |
| switch (type) |
| { |
| case VariableType::TYPE_FLOAT: |
| return 0; |
| case VariableType::TYPE_INT: |
| return 1; |
| case VariableType::TYPE_BOOL: |
| return 2; |
| default: |
| return -1; |
| } |
| } |
| |
| bool isConversionOk(VariableType::Type srcType, VariableType::Type dstType, ConstValueRangeAccess valueRange) |
| { |
| // [src][dst] |
| static const IsConversionOkFunc convTable[3][3] = { |
| {isConversionOk<float, float>, isConversionOk<float, int>, isConversionOk<float, bool>}, |
| {isConversionOk<int, float>, isConversionOk<int, int>, isConversionOk<int, bool>}, |
| {isConversionOk<bool, float>, isConversionOk<bool, int>, isConversionOk<bool, bool>}}; |
| return convTable[getBaseTypeConvNdx(srcType)][getBaseTypeConvNdx(dstType)](valueRange); |
| } |
| |
| void convertValueRange(ConstValueRangeAccess src, ValueRangeAccess dst) |
| { |
| // [src][dst] |
| static const ConvertValueRangeFunc convTable[3][3] = { |
| {convertValueRangeTempl<float, float>, convertValueRangeTempl<float, int>, convertValueRangeTempl<float, bool>}, |
| {convertValueRangeTempl<int, float>, convertValueRangeTempl<int, int>, convertValueRangeTempl<int, bool>}, |
| {convertValueRangeTempl<bool, float>, convertValueRangeTempl<bool, int>, convertValueRangeTempl<bool, bool>}}; |
| |
| convTable[getBaseTypeConvNdx(src.getType().getBaseType())][getBaseTypeConvNdx(dst.getType().getBaseType())](src, |
| dst); |
| } |
| |
| void convertExecValue(ExecConstValueAccess src, ExecValueAccess dst) |
| { |
| // [src][dst] |
| static const ConvertExecValueFunc convTable[3][3] = { |
| {convertExecValueTempl<float, float>, convertExecValueTempl<float, int>, convertExecValueTempl<float, bool>}, |
| {convertExecValueTempl<int, float>, convertExecValueTempl<int, int>, convertExecValueTempl<int, bool>}, |
| {convertExecValueTempl<bool, float>, convertExecValueTempl<bool, int>, convertExecValueTempl<bool, bool>}}; |
| |
| convTable[getBaseTypeConvNdx(src.getType().getBaseType())][getBaseTypeConvNdx(dst.getType().getBaseType())](src, |
| dst); |
| } |
| |
| } // namespace |
| |
| ConstructorOp::ConstructorOp(GeneratorState &state, ConstValueRangeAccess valueRange) : m_valueRange(valueRange) |
| { |
| if (valueRange.getType().isVoid()) |
| { |
| // Use random range |
| const int maxScalars = 4; // We don't have to be able to assign this value to anywhere |
| m_valueRange = ValueRange(computeRandomType(state, maxScalars)); |
| computeRandomValueRange(state, m_valueRange.asAccess()); |
| } |
| |
| // \todo [2011-03-26 pyry] Vector conversions |
| // int remainingDepth = state.getShaderParameters().maxExpressionDepth - state.getExpressionDepth(); |
| |
| const VariableType &type = m_valueRange.getType(); |
| VariableType::Type baseType = type.getBaseType(); |
| int numScalars = type.getNumElements(); |
| int curScalarNdx = 0; |
| |
| // \todo [2011-03-26 pyry] Separate op for struct constructors! |
| DE_ASSERT(type.isFloatOrVec() || type.isIntOrVec() || type.isBoolOrVec()); |
| |
| bool scalarConversions = state.getProgramParameters().useScalarConversions; |
| |
| while (curScalarNdx < numScalars) |
| { |
| ConstValueRangeAccess comp = m_valueRange.asAccess().component(curScalarNdx); |
| |
| if (scalarConversions) |
| { |
| int numInTypes = 0; |
| VariableType::Type inTypes[3]; |
| |
| if (isConversionOk(VariableType::TYPE_FLOAT, baseType, comp)) |
| inTypes[numInTypes++] = VariableType::TYPE_FLOAT; |
| if (isConversionOk(VariableType::TYPE_INT, baseType, comp)) |
| inTypes[numInTypes++] = VariableType::TYPE_INT; |
| if (isConversionOk(VariableType::TYPE_BOOL, baseType, comp)) |
| inTypes[numInTypes++] = VariableType::TYPE_BOOL; |
| |
| DE_ASSERT(numInTypes > 0); // At least nop conversion should be ok |
| |
| // Choose random |
| VariableType::Type inType = |
| state.getRandom().choose<VariableType::Type>(&inTypes[0], &inTypes[0] + numInTypes); |
| |
| // Compute converted value range |
| ValueRange inValueRange(VariableType(inType, 1)); |
| convertValueRange(comp, inValueRange); |
| m_inputValueRanges.push_back(inValueRange); |
| |
| curScalarNdx += 1; |
| } |
| else |
| { |
| m_inputValueRanges.push_back(ValueRange(comp)); |
| curScalarNdx += 1; |
| } |
| } |
| } |
| |
| ConstructorOp::~ConstructorOp(void) |
| { |
| for (vector<Expression *>::iterator i = m_inputExpressions.begin(); i != m_inputExpressions.end(); i++) |
| delete *i; |
| } |
| |
| Expression *ConstructorOp::createNextChild(GeneratorState &state) |
| { |
| int numChildren = (int)m_inputExpressions.size(); |
| Expression *child = DE_NULL; |
| |
| // \note Created in reverse order! |
| if (numChildren < (int)m_inputValueRanges.size()) |
| { |
| const ValueRange &inValueRange = m_inputValueRanges[m_inputValueRanges.size() - 1 - numChildren]; |
| child = Expression::createRandom(state, inValueRange); |
| try |
| { |
| m_inputExpressions.push_back(child); |
| } |
| catch (const std::exception &) |
| { |
| delete child; |
| throw; |
| } |
| } |
| |
| return child; |
| } |
| |
| float ConstructorOp::getWeight(const GeneratorState &state, ConstValueRangeAccess valueRange) |
| { |
| if (valueRange.getType().isVoid()) |
| return unusedValueWeight; |
| |
| if (!valueRange.getType().isFloatOrVec() && !valueRange.getType().isIntOrVec() && |
| !valueRange.getType().isBoolOrVec()) |
| return 0.0f; |
| |
| if (state.getExpressionDepth() + getTypeConstructorDepth(valueRange.getType()) > |
| state.getShaderParameters().maxExpressionDepth) |
| return 0.0f; |
| |
| return 1.0f; |
| } |
| |
| void ConstructorOp::tokenize(GeneratorState &state, TokenStream &str) const |
| { |
| const VariableType &type = m_valueRange.getType(); |
| DE_ASSERT(type.getPrecision() == VariableType::PRECISION_NONE); |
| type.tokenizeShortType(str); |
| |
| str << Token::LEFT_PAREN; |
| |
| for (vector<Expression *>::const_reverse_iterator i = m_inputExpressions.rbegin(); i != m_inputExpressions.rend(); |
| i++) |
| { |
| if (i != m_inputExpressions.rbegin()) |
| str << Token::COMMA; |
| (*i)->tokenize(state, str); |
| } |
| |
| str << Token::RIGHT_PAREN; |
| } |
| |
| void ConstructorOp::evaluate(ExecutionContext &evalCtx) |
| { |
| // Evaluate children |
| for (vector<Expression *>::reverse_iterator i = m_inputExpressions.rbegin(); i != m_inputExpressions.rend(); i++) |
| (*i)->evaluate(evalCtx); |
| |
| // Compute value |
| const VariableType &type = m_valueRange.getType(); |
| m_value.setStorage(type); |
| |
| ExecValueAccess dst = m_value.getValue(type); |
| int curScalarNdx = 0; |
| |
| for (vector<Expression *>::reverse_iterator i = m_inputExpressions.rbegin(); i != m_inputExpressions.rend(); i++) |
| { |
| ExecConstValueAccess src = (*i)->getValue(); |
| |
| for (int elemNdx = 0; elemNdx < src.getType().getNumElements(); elemNdx++) |
| convertExecValue(src.component(elemNdx), dst.component(curScalarNdx++)); |
| } |
| } |
| |
| AssignOp::AssignOp(GeneratorState &state, ConstValueRangeAccess valueRange) |
| : m_valueRange(valueRange) |
| , m_lvalueExpr(DE_NULL) |
| , m_rvalueExpr(DE_NULL) |
| { |
| if (m_valueRange.getType().isVoid()) |
| { |
| // Compute random value range |
| int maxScalars = state.getShaderParameters().maxCombinedVariableScalars - |
| state.getVariableManager().getNumAllocatedScalars(); |
| bool useRandomRange = !state.getVariableManager().hasEntry<IsWritableEntry>() || |
| ((maxScalars > 0) && getWeightedBool(state.getRandom(), 0.1f)); |
| |
| if (useRandomRange) |
| { |
| DE_ASSERT(maxScalars > 0); |
| m_valueRange = ValueRange(computeRandomType(state, maxScalars)); |
| computeRandomValueRange(state, m_valueRange.asAccess()); |
| } |
| else |
| { |
| // Use value range from random entry |
| // \todo [2011-02-28 pyry] Give lower weight to entries without range? Choose subtype range? |
| const ValueEntry *entry = |
| state.getRandom().choose<const ValueEntry *>(state.getVariableManager().getBegin<IsWritableEntry>(), |
| state.getVariableManager().getEnd<IsWritableEntry>()); |
| m_valueRange = ValueRange(entry->getValueRange()); |
| |
| computeRandomValueRangeForInfElements(state, m_valueRange.asAccess()); |
| |
| DE_ASSERT(state.getVariableManager().hasEntry(IsWritableIntersectingEntry(m_valueRange.asAccess()))); |
| } |
| } |
| |
| IsWritableIntersectingEntry::Iterator first = |
| state.getVariableManager().getBegin(IsWritableIntersectingEntry(m_valueRange.asAccess())); |
| IsWritableIntersectingEntry::Iterator end = |
| state.getVariableManager().getEnd(IsWritableIntersectingEntry(m_valueRange.asAccess())); |
| |
| bool possiblyCreateVar = canAllocateVariable(state, m_valueRange.getType()) && |
| (first == end || getWeightedBool(state.getRandom(), 0.5f)); |
| |
| if (!possiblyCreateVar) |
| { |
| // Find all possible valueranges matching given type and intersecting with valuerange |
| // \todo [pyry] Actually collect all ValueRanges, currently operates only on whole variables |
| DE_ASSERT(first != end); |
| |
| // Try to select one closest to given range but bigger (eg. superset) |
| bool supersetExists = false; |
| for (IsWritableIntersectingEntry::Iterator i = first; i != end; i++) |
| { |
| if ((*i)->getValueRange().isSupersetOf(m_valueRange.asAccess())) |
| { |
| supersetExists = true; |
| break; |
| } |
| } |
| |
| if (!supersetExists) |
| { |
| // Select some other range and compute intersection |
| // \todo [2011-02-03 pyry] Use some heuristics to select the range? |
| ConstValueRangeAccess selectedRange = |
| state.getRandom().choose<const ValueEntry *>(first, end)->getValueRange(); |
| |
| ValueRange::computeIntersection(m_valueRange.asAccess(), m_valueRange.asAccess(), selectedRange); |
| } |
| } |
| } |
| |
| AssignOp::~AssignOp(void) |
| { |
| delete m_lvalueExpr; |
| delete m_rvalueExpr; |
| } |
| |
| float AssignOp::getWeight(const GeneratorState &state, ConstValueRangeAccess valueRange) |
| { |
| if (!valueRange.getType().isVoid() && !canAllocateVariable(state, valueRange.getType()) && |
| !state.getVariableManager().hasEntry(IsWritableIntersectingEntry(valueRange))) |
| return 0.0f; // Would require creating a new variable |
| |
| if (!valueRange.getType().isVoid() && |
| state.getExpressionDepth() + getTypeConstructorDepth(valueRange.getType()) + 1 >= |
| state.getShaderParameters().maxExpressionDepth) |
| return 0.0f; |
| |
| if (valueRange.getType().isVoid() && !state.getVariableManager().hasEntry<IsWritableEntry>() && |
| state.getVariableManager().getNumAllocatedScalars() >= state.getShaderParameters().maxCombinedVariableScalars) |
| return 0.0f; // Can not allocate a new entry |
| |
| if (state.getExpressionDepth() == 0) |
| return 4.0f; |
| else |
| return 0.0f; // \todo [pyry] Fix assign ops |
| } |
| |
| Expression *AssignOp::createNextChild(GeneratorState &state) |
| { |
| if (m_lvalueExpr == DE_NULL) |
| { |
| // Construct lvalue |
| // \todo [2011-03-14 pyry] Proper l-value generation: |
| // - pure L-value part is generated first |
| // - variable valuerange is made unbound |
| // - R-value is generated |
| // - R-values in L-value are generated |
| m_lvalueExpr = Expression::createRandomLValue(state, m_valueRange.asAccess()); |
| return m_lvalueExpr; |
| } |
| else if (m_rvalueExpr == DE_NULL) |
| { |
| // Construct value expr |
| m_rvalueExpr = Expression::createRandom(state, m_valueRange.asAccess()); |
| return m_rvalueExpr; |
| } |
| else |
| return DE_NULL; |
| } |
| |
| void AssignOp::tokenize(GeneratorState &state, TokenStream &str) const |
| { |
| m_lvalueExpr->tokenize(state, str); |
| str << Token::EQUAL; |
| m_rvalueExpr->tokenize(state, str); |
| } |
| |
| void AssignOp::evaluate(ExecutionContext &evalCtx) |
| { |
| // Evaluate l-value |
| m_lvalueExpr->evaluate(evalCtx); |
| |
| // Evaluate value |
| m_rvalueExpr->evaluate(evalCtx); |
| m_value.setStorage(m_valueRange.getType()); |
| m_value.getValue(m_valueRange.getType()) = m_rvalueExpr->getValue().value(); |
| |
| // Assign |
| assignMasked(m_lvalueExpr->getLValue(), m_value.getValue(m_valueRange.getType()), evalCtx.getExecutionMask()); |
| } |
| |
| namespace |
| { |
| |
| inline bool isShaderInOutSupportedType(const VariableType &type) |
| { |
| // \todo [2011-03-11 pyry] Float arrays, structs? |
| return type.getBaseType() == VariableType::TYPE_FLOAT; |
| } |
| |
| Variable *allocateNewVariable(GeneratorState &state, ConstValueRangeAccess valueRange) |
| { |
| Variable *variable = state.getVariableManager().allocate(valueRange.getType()); |
| |
| // Update value range |
| state.getVariableManager().setValue(variable, valueRange); |
| |
| // Random storage \todo [pyry] Check that scalar count in uniform/input classes is not exceeded |
| static const Variable::Storage storages[] = {Variable::STORAGE_CONST, Variable::STORAGE_UNIFORM, |
| Variable::STORAGE_LOCAL, Variable::STORAGE_SHADER_IN}; |
| float weights[DE_LENGTH_OF_ARRAY(storages)]; |
| |
| // Dynamic vs. constant weight. |
| float dynWeight = computeDynamicRangeWeight(valueRange); |
| int numScalars = valueRange.getType().getScalarSize(); |
| bool uniformOk = state.getVariableManager().getNumAllocatedUniformScalars() + numScalars <= |
| state.getShaderParameters().maxUniformScalars; |
| bool shaderInOk = isShaderInOutSupportedType(valueRange.getType()) && |
| (state.getVariableManager().getNumAllocatedShaderInVariables() + NUM_RESERVED_SHADER_INPUTS < |
| state.getShaderParameters().maxInputVariables); |
| |
| weights[0] = de::max(1.0f - dynWeight, 0.1f); |
| weights[1] = uniformOk ? dynWeight * 0.5f : 0.0f; |
| weights[2] = dynWeight; |
| weights[3] = shaderInOk ? dynWeight * 2.0f : 0.0f; |
| |
| state.getVariableManager().setStorage(variable, |
| state.getRandom().chooseWeighted<Variable::Storage>( |
| &storages[0], &storages[DE_LENGTH_OF_ARRAY(storages)], &weights[0])); |
| |
| return variable; |
| } |
| |
| inline float combineWeight(float curCombinedWeight, float partialWeight) |
| { |
| return curCombinedWeight * partialWeight; |
| } |
| |
| float computeEntryReadWeight(ConstValueRangeAccess entryValueRange, ConstValueRangeAccess readValueRange) |
| { |
| const VariableType &type = entryValueRange.getType(); |
| DE_ASSERT(type == readValueRange.getType()); |
| |
| float weight = 1.0f; |
| |
| switch (type.getBaseType()) |
| { |
| case VariableType::TYPE_FLOAT: |
| { |
| for (int elemNdx = 0; elemNdx < type.getNumElements(); elemNdx++) |
| { |
| float entryMin = entryValueRange.component(elemNdx).getMin().asFloat(); |
| float entryMax = entryValueRange.component(elemNdx).getMax().asFloat(); |
| float readMin = readValueRange.component(elemNdx).getMin().asFloat(); |
| float readMax = readValueRange.component(elemNdx).getMax().asFloat(); |
| |
| // Check for -inf..inf ranges - they don't bring down the weight. |
| if (Scalar::min<float>() == entryMin && Scalar::max<float>() == entryMax) |
| continue; |
| |
| // Intersection to entry value range length ratio. |
| float intersectionMin = deFloatMax(entryMin, readMin); |
| float intersectionMax = deFloatMin(entryMax, readMax); |
| float entryRangeLen = entryMax - entryMin; |
| float readRangeLen = readMax - readMin; |
| float intersectionLen = intersectionMax - intersectionMin; |
| float entryRatio = (entryRangeLen > 0.0f) ? (intersectionLen / entryRangeLen) : 1.0f; |
| float readRatio = (readRangeLen > 0.0f) ? (intersectionLen / readRangeLen) : 1.0f; |
| float elementWeight = 0.5f * readRatio + 0.5f * entryRatio; |
| |
| weight = combineWeight(weight, elementWeight); |
| } |
| break; |
| } |
| |
| case VariableType::TYPE_INT: |
| { |
| for (int elemNdx = 0; elemNdx < type.getNumElements(); elemNdx++) |
| { |
| int entryMin = entryValueRange.component(elemNdx).getMin().asInt(); |
| int entryMax = entryValueRange.component(elemNdx).getMax().asInt(); |
| int readMin = readValueRange.component(elemNdx).getMin().asInt(); |
| int readMax = readValueRange.component(elemNdx).getMax().asInt(); |
| |
| // Check for -inf..inf ranges - they don't bring down the weight. |
| if (Scalar::min<int>() == entryMin && Scalar::max<int>() == entryMax) |
| continue; |
| |
| // Intersection to entry value range length ratio. |
| int intersectionMin = deMax32(entryMin, readMin); |
| int intersectionMax = deMin32(entryMax, readMax); |
| int64_t entryRangeLen = (int64_t)entryMax - (int64_t)entryMin; |
| int64_t readRangeLen = (int64_t)readMax - (int64_t)readMin; |
| int64_t intersectionLen = (int64_t)intersectionMax - (int64_t)intersectionMin; |
| float entryRatio = (entryRangeLen > 0) ? ((float)intersectionLen / (float)entryRangeLen) : 1.0f; |
| float readRatio = (readRangeLen > 0) ? ((float)intersectionLen / (float)readRangeLen) : 1.0f; |
| float elementWeight = 0.5f * readRatio + 0.5f * entryRatio; |
| |
| weight = combineWeight(weight, elementWeight); |
| } |
| break; |
| } |
| |
| case VariableType::TYPE_BOOL: |
| { |
| // \todo |
| break; |
| } |
| |
| case VariableType::TYPE_ARRAY: |
| case VariableType::TYPE_STRUCT: |
| |
| default: |
| TCU_FAIL("Unsupported type"); |
| } |
| |
| return deFloatMax(weight, 0.01f); |
| } |
| |
| } // namespace |
| |
| VariableRead::VariableRead(GeneratorState &state, ConstValueRangeAccess valueRange) |
| { |
| if (valueRange.getType().isVoid()) |
| { |
| IsReadableEntry filter = IsReadableEntry(state.getExpressionFlags()); |
| int maxScalars = state.getShaderParameters().maxCombinedVariableScalars - |
| state.getVariableManager().getNumAllocatedScalars(); |
| bool useRandomRange = !state.getVariableManager().hasEntry(filter) || |
| ((maxScalars > 0) && getWeightedBool(state.getRandom(), 0.5f)); |
| |
| if (useRandomRange) |
| { |
| // Allocate a new variable |
| DE_ASSERT(maxScalars > 0); |
| ValueRange newVarRange(computeRandomType(state, maxScalars)); |
| computeRandomValueRange(state, newVarRange.asAccess()); |
| |
| m_variable = allocateNewVariable(state, newVarRange.asAccess()); |
| } |
| else |
| { |
| // Use random entry \todo [pyry] Handle -inf..inf ranges? |
| m_variable = state.getRandom() |
| .choose<const ValueEntry *>(state.getVariableManager().getBegin(filter), |
| state.getVariableManager().getEnd(filter)) |
| ->getVariable(); |
| } |
| } |
| else |
| { |
| // Find variable that has value range that intersects with given range |
| IsReadableIntersectingEntry::Iterator first = |
| state.getVariableManager().getBegin(IsReadableIntersectingEntry(valueRange, state.getExpressionFlags())); |
| IsReadableIntersectingEntry::Iterator end = |
| state.getVariableManager().getEnd(IsReadableIntersectingEntry(valueRange, state.getExpressionFlags())); |
| |
| const float createOnReadWeight = 0.5f; |
| bool createVar = canAllocateVariable(state, valueRange.getType()) && |
| (first == end || getWeightedBool(state.getRandom(), createOnReadWeight)); |
| |
| if (createVar) |
| { |
| m_variable = allocateNewVariable(state, valueRange); |
| } |
| else |
| { |
| // Copy value entries for computing weights. |
| std::vector<const ValueEntry *> availableVars; |
| std::vector<float> weights; |
| |
| std::copy(first, end, std::inserter(availableVars, availableVars.begin())); |
| |
| // Compute weights. |
| weights.resize(availableVars.size()); |
| for (int ndx = 0; ndx < (int)availableVars.size(); ndx++) |
| weights[ndx] = computeEntryReadWeight(availableVars[ndx]->getValueRange(), valueRange); |
| |
| // Select. |
| const ValueEntry *entry = state.getRandom().chooseWeighted<const ValueEntry *>( |
| availableVars.begin(), availableVars.end(), weights.begin()); |
| m_variable = entry->getVariable(); |
| |
| // Compute intersection |
| ValueRange intersection(m_variable->getType()); |
| ValueRange::computeIntersection(intersection, entry->getValueRange(), valueRange); |
| state.getVariableManager().setValue(m_variable, intersection.asAccess()); |
| } |
| } |
| } |
| |
| VariableRead::VariableRead(const Variable *variable) |
| { |
| m_variable = variable; |
| } |
| |
| float VariableRead::getWeight(const GeneratorState &state, ConstValueRangeAccess valueRange) |
| { |
| if (valueRange.getType().isVoid()) |
| { |
| if (state.getVariableManager().hasEntry(IsReadableEntry(state.getExpressionFlags())) || |
| state.getVariableManager().getNumAllocatedScalars() < |
| state.getShaderParameters().maxCombinedVariableScalars) |
| return unusedValueWeight; |
| else |
| return 0.0f; |
| } |
| |
| if (!canAllocateVariable(state, valueRange.getType()) && |
| !state.getVariableManager().hasEntry(IsReadableIntersectingEntry(valueRange, state.getExpressionFlags()))) |
| return 0.0f; |
| else |
| return 1.0f; |
| } |
| |
| VariableWrite::VariableWrite(GeneratorState &state, ConstValueRangeAccess valueRange) |
| { |
| DE_ASSERT(!valueRange.getType().isVoid()); |
| |
| // Find variable with range that is superset of given range |
| IsWritableSupersetEntry::Iterator first = state.getVariableManager().getBegin(IsWritableSupersetEntry(valueRange)); |
| IsWritableSupersetEntry::Iterator end = state.getVariableManager().getEnd(IsWritableSupersetEntry(valueRange)); |
| |
| const float createOnAssignWeight = 0.1f; // Will essentially create an unused variable |
| bool createVar = canAllocateVariable(state, valueRange.getType()) && |
| (first == end || getWeightedBool(state.getRandom(), createOnAssignWeight)); |
| |
| if (createVar) |
| { |
| m_variable = state.getVariableManager().allocate(valueRange.getType()); |
| // \note Storage will be LOCAL |
| } |
| else |
| { |
| // Choose random |
| DE_ASSERT(first != end); |
| const ValueEntry *entry = state.getRandom().choose<const ValueEntry *>(first, end); |
| m_variable = entry->getVariable(); |
| } |
| |
| DE_ASSERT(m_variable); |
| |
| // Reset value range. |
| const ValueEntry *parentEntry = state.getVariableManager().getParentValue(m_variable); |
| if (parentEntry) |
| { |
| // Use parent value range. |
| state.getVariableManager().setValue(m_variable, parentEntry->getValueRange()); |
| } |
| else |
| { |
| // Use infinite range. |
| ValueRange infRange(m_variable->getType()); |
| setInfiniteRange(infRange); |
| |
| state.getVariableManager().setValue(m_variable, infRange.asAccess()); |
| } |
| } |
| |
| float VariableWrite::getWeight(const GeneratorState &state, ConstValueRangeAccess valueRange) |
| { |
| if (!canAllocateVariable(state, valueRange.getType()) && |
| !state.getVariableManager().hasEntry(IsWritableSupersetEntry(valueRange))) |
| return 0.0f; |
| else |
| return 1.0f; |
| } |
| |
| void VariableAccess::evaluate(ExecutionContext &evalCtx) |
| { |
| m_valueAccess = evalCtx.getValue(m_variable); |
| } |
| |
| ParenOp::ParenOp(GeneratorState &state, ConstValueRangeAccess valueRange) : m_valueRange(valueRange), m_child(DE_NULL) |
| { |
| DE_UNREF(state); |
| } |
| |
| ParenOp::~ParenOp(void) |
| { |
| delete m_child; |
| } |
| |
| Expression *ParenOp::createNextChild(GeneratorState &state) |
| { |
| if (m_child == DE_NULL) |
| { |
| m_child = Expression::createRandom(state, m_valueRange.asAccess()); |
| return m_child; |
| } |
| else |
| return DE_NULL; |
| } |
| |
| void ParenOp::tokenize(GeneratorState &state, TokenStream &str) const |
| { |
| str << Token::LEFT_PAREN; |
| m_child->tokenize(state, str); |
| str << Token::RIGHT_PAREN; |
| } |
| |
| void ParenOp::setChild(Expression *expression) |
| { |
| m_child = expression; |
| } |
| |
| float ParenOp::getWeight(const GeneratorState &state, ConstValueRangeAccess valueRange) |
| { |
| if (valueRange.getType().isVoid()) |
| return state.getExpressionDepth() + 2 <= state.getShaderParameters().maxExpressionDepth ? unusedValueWeight : |
| 0.0f; |
| else |
| { |
| int requiredDepth = 1 + getConservativeValueExprDepth(state, valueRange); |
| return state.getExpressionDepth() + requiredDepth <= state.getShaderParameters().maxExpressionDepth ? 1.0f : |
| 0.0f; |
| } |
| } |
| |
| const int swizzlePrecedence = 2; |
| |
| SwizzleOp::SwizzleOp(GeneratorState &state, ConstValueRangeAccess valueRange) |
| : m_outValueRange(valueRange) |
| , m_numInputElements(0) |
| , m_child(DE_NULL) |
| { |
| DE_ASSERT(!m_outValueRange.getType().isVoid()); // \todo [2011-06-13 pyry] Void support |
| DE_ASSERT(m_outValueRange.getType().isFloatOrVec() || m_outValueRange.getType().isIntOrVec() || |
| m_outValueRange.getType().isBoolOrVec()); |
| |
| m_value.setStorage(m_outValueRange.getType()); |
| |
| int numOutputElements = m_outValueRange.getType().getNumElements(); |
| |
| // \note Swizzle works for vector types only. |
| // \todo [2011-06-13 pyry] Use components multiple times. |
| m_numInputElements = state.getRandom().getInt(deMax32(numOutputElements, 2), 4); |
| |
| std::set<int> availableElements; |
| for (int ndx = 0; ndx < m_numInputElements; ndx++) |
| availableElements.insert(ndx); |
| |
| // Randomize swizzle. |
| for (int elemNdx = 0; elemNdx < (int)DE_LENGTH_OF_ARRAY(m_swizzle); elemNdx++) |
| { |
| if (elemNdx < numOutputElements) |
| { |
| int inElemNdx = state.getRandom().choose<int>(availableElements.begin(), availableElements.end()); |
| availableElements.erase(inElemNdx); |
| m_swizzle[elemNdx] = (uint8_t)inElemNdx; |
| } |
| else |
| m_swizzle[elemNdx] = 0; |
| } |
| } |
| |
| SwizzleOp::~SwizzleOp(void) |
| { |
| delete m_child; |
| } |
| |
| Expression *SwizzleOp::createNextChild(GeneratorState &state) |
| { |
| if (m_child) |
| return DE_NULL; |
| |
| // Compute input value range. |
| VariableType inVarType = VariableType(m_outValueRange.getType().getBaseType(), m_numInputElements); |
| ValueRange inValueRange = ValueRange(inVarType); |
| |
| // Initialize all inputs to -inf..inf |
| setInfiniteRange(inValueRange); |
| |
| // Compute intersections. |
| int numOutputElements = m_outValueRange.getType().getNumElements(); |
| for (int outElemNdx = 0; outElemNdx < numOutputElements; outElemNdx++) |
| { |
| int inElemNdx = m_swizzle[outElemNdx]; |
| ValueRange::computeIntersection(inValueRange.asAccess().component(inElemNdx), |
| inValueRange.asAccess().component(inElemNdx), |
| m_outValueRange.asAccess().component(outElemNdx)); |
| } |
| |
| // Create child. |
| state.pushPrecedence(swizzlePrecedence); |
| m_child = Expression::createRandom(state, inValueRange.asAccess()); |
| state.popPrecedence(); |
| |
| return m_child; |
| } |
| |
| void SwizzleOp::tokenize(GeneratorState &state, TokenStream &str) const |
| { |
| const char *rgbaSet[] = {"r", "g", "b", "a"}; |
| const char *xyzwSet[] = {"x", "y", "z", "w"}; |
| const char *stpqSet[] = {"s", "t", "p", "q"}; |
| const char **swizzleSet = DE_NULL; |
| |
| switch (state.getRandom().getInt(0, 2)) |
| { |
| case 0: |
| swizzleSet = rgbaSet; |
| break; |
| case 1: |
| swizzleSet = xyzwSet; |
| break; |
| case 2: |
| swizzleSet = stpqSet; |
| break; |
| default: |
| DE_ASSERT(false); |
| } |
| |
| std::string swizzleStr; |
| for (int elemNdx = 0; elemNdx < m_outValueRange.getType().getNumElements(); elemNdx++) |
| swizzleStr += swizzleSet[m_swizzle[elemNdx]]; |
| |
| m_child->tokenize(state, str); |
| str << Token::DOT << Token(swizzleStr.c_str()); |
| } |
| |
| float SwizzleOp::getWeight(const GeneratorState &state, ConstValueRangeAccess valueRange) |
| { |
| if (!state.getProgramParameters().useSwizzle) |
| return 0.0f; |
| |
| if (state.getPrecedence() < swizzlePrecedence) |
| return 0.0f; |
| |
| if (!valueRange.getType().isFloatOrVec() && !valueRange.getType().isIntOrVec() && |
| !valueRange.getType().isBoolOrVec()) |
| return 0.0f; |
| |
| int availableLevels = state.getShaderParameters().maxExpressionDepth - state.getExpressionDepth(); |
| |
| // Swizzle + Constructor + Values |
| if (availableLevels < 3) |
| return 0.0f; |
| |
| return 1.0f; |
| } |
| |
| void SwizzleOp::evaluate(ExecutionContext &execCtx) |
| { |
| m_child->evaluate(execCtx); |
| |
| ExecConstValueAccess inValue = m_child->getValue(); |
| ExecValueAccess outValue = m_value.getValue(m_outValueRange.getType()); |
| |
| for (int outElemNdx = 0; outElemNdx < outValue.getType().getNumElements(); outElemNdx++) |
| { |
| int inElemNdx = m_swizzle[outElemNdx]; |
| outValue.component(outElemNdx) = inValue.component(inElemNdx).value(); |
| } |
| } |
| |
| static int countSamplers(const VariableManager &varManager, VariableType::Type samplerType) |
| { |
| int numSamplers = 0; |
| |
| IsSamplerEntry::Iterator i = varManager.getBegin(IsSamplerEntry(samplerType)); |
| IsSamplerEntry::Iterator end = varManager.getEnd(IsSamplerEntry(samplerType)); |
| |
| for (; i != end; i++) |
| numSamplers += 1; |
| |
| return numSamplers; |
| } |
| |
| TexLookup::TexLookup(GeneratorState &state, ConstValueRangeAccess valueRange) |
| : m_type(TYPE_LAST) |
| , m_coordExpr(DE_NULL) |
| , m_lodBiasExpr(DE_NULL) |
| , m_valueType(VariableType::TYPE_FLOAT, 4) |
| , m_value(m_valueType) |
| { |
| DE_ASSERT(valueRange.getType() == VariableType(VariableType::TYPE_FLOAT, 4)); |
| DE_UNREF(valueRange); // Texture output value range is constant. |
| |
| // Select type. |
| vector<Type> typeCandidates; |
| if (state.getShaderParameters().useTexture2D) |
| { |
| typeCandidates.push_back(TYPE_TEXTURE2D); |
| typeCandidates.push_back(TYPE_TEXTURE2D_LOD); |
| typeCandidates.push_back(TYPE_TEXTURE2D_PROJ); |
| typeCandidates.push_back(TYPE_TEXTURE2D_PROJ_LOD); |
| } |
| |
| if (state.getShaderParameters().useTextureCube) |
| { |
| typeCandidates.push_back(TYPE_TEXTURECUBE); |
| typeCandidates.push_back(TYPE_TEXTURECUBE_LOD); |
| } |
| |
| m_type = state.getRandom().choose<Type>(typeCandidates.begin(), typeCandidates.end()); |
| |
| // Select or allocate sampler. |
| VariableType::Type samplerType = VariableType::TYPE_LAST; |
| switch (m_type) |
| { |
| case TYPE_TEXTURE2D: |
| case TYPE_TEXTURE2D_LOD: |
| case TYPE_TEXTURE2D_PROJ: |
| case TYPE_TEXTURE2D_PROJ_LOD: |
| samplerType = VariableType::TYPE_SAMPLER_2D; |
| break; |
| |
| case TYPE_TEXTURECUBE: |
| case TYPE_TEXTURECUBE_LOD: |
| samplerType = VariableType::TYPE_SAMPLER_CUBE; |
| break; |
| |
| default: |
| DE_ASSERT(false); |
| } |
| |
| int sampler2DCount = countSamplers(state.getVariableManager(), VariableType::TYPE_SAMPLER_2D); |
| int samplerCubeCount = countSamplers(state.getVariableManager(), VariableType::TYPE_SAMPLER_CUBE); |
| bool canAllocSampler = sampler2DCount + samplerCubeCount < state.getShaderParameters().maxSamplers; |
| bool hasSampler = samplerType == VariableType::TYPE_SAMPLER_2D ? (sampler2DCount > 0) : (samplerCubeCount > 0); |
| bool allocSampler = !hasSampler || (canAllocSampler && state.getRandom().getBool()); |
| |
| if (allocSampler) |
| { |
| Variable *sampler = state.getVariableManager().allocate(VariableType(samplerType, 1)); |
| state.getVariableManager().setStorage(sampler, Variable::STORAGE_UNIFORM); // Samplers are always uniforms. |
| m_sampler = sampler; |
| } |
| else |
| m_sampler = state.getRandom() |
| .choose<const ValueEntry *>(state.getVariableManager().getBegin(IsSamplerEntry(samplerType)), |
| state.getVariableManager().getEnd(IsSamplerEntry(samplerType))) |
| ->getVariable(); |
| } |
| |
| TexLookup::~TexLookup(void) |
| { |
| delete m_coordExpr; |
| delete m_lodBiasExpr; |
| } |
| |
| Expression *TexLookup::createNextChild(GeneratorState &state) |
| { |
| bool hasLodBias = |
| m_type == TYPE_TEXTURE2D_LOD || m_type == TYPE_TEXTURE2D_PROJ_LOD || m_type == TYPE_TEXTURECUBE_LOD; |
| |
| if (hasLodBias && !m_lodBiasExpr) |
| { |
| ValueRange lodRange(VariableType(VariableType::TYPE_FLOAT, 1)); |
| setInfiniteRange(lodRange); // Any value is valid. |
| |
| m_lodBiasExpr = Expression::createRandom(state, lodRange.asAccess()); |
| return m_lodBiasExpr; |
| } |
| |
| if (!m_coordExpr) |
| { |
| if (m_type == TYPE_TEXTURECUBE || m_type == TYPE_TEXTURECUBE_LOD) |
| { |
| // Make sure major axis selection can be done. |
| int majorAxisNdx = state.getRandom().getInt(0, 2); |
| |
| ValueRange coordRange(VariableType(VariableType::TYPE_FLOAT, 3)); |
| |
| for (int ndx = 0; ndx < 3; ndx++) |
| { |
| if (ndx == majorAxisNdx) |
| { |
| bool neg = state.getRandom().getBool(); |
| coordRange.getMin().component(ndx) = neg ? -4.0f : 2.25f; |
| coordRange.getMax().component(ndx) = neg ? -2.25f : 4.0f; |
| } |
| else |
| { |
| coordRange.getMin().component(ndx) = -2.0f; |
| coordRange.getMax().component(ndx) = 2.0f; |
| } |
| } |
| |
| m_coordExpr = Expression::createRandom(state, coordRange.asAccess()); |
| } |
| else |
| { |
| bool isProj = m_type == TYPE_TEXTURE2D_PROJ || m_type == TYPE_TEXTURE2D_PROJ_LOD; |
| int coordScalarSize = isProj ? 3 : 2; |
| |
| ValueRange coordRange(VariableType(VariableType::TYPE_FLOAT, coordScalarSize)); |
| setInfiniteRange(coordRange); // Initialize base range with -inf..inf |
| |
| if (isProj) |
| { |
| // w coordinate must be something sane, and not 0. |
| bool neg = state.getRandom().getBool(); |
| coordRange.getMin().component(2) = neg ? -4.0f : 0.25f; |
| coordRange.getMax().component(2) = neg ? -0.25f : 4.0f; |
| } |
| |
| m_coordExpr = Expression::createRandom(state, coordRange.asAccess()); |
| } |
| |
| DE_ASSERT(m_coordExpr); |
| return m_coordExpr; |
| } |
| |
| return DE_NULL; // Done. |
| } |
| |
| void TexLookup::tokenize(GeneratorState &state, TokenStream &str) const |
| { |
| bool isVertex = state.getShader().getType() == Shader::TYPE_VERTEX; |
| |
| if (state.getProgramParameters().version == VERSION_300) |
| { |
| switch (m_type) |
| { |
| case TYPE_TEXTURE2D: |
| str << "texture"; |
| break; |
| case TYPE_TEXTURE2D_LOD: |
| str << (isVertex ? "textureLod" : "texture"); |
| break; |
| case TYPE_TEXTURE2D_PROJ: |
| str << "textureProj"; |
| break; |
| case TYPE_TEXTURE2D_PROJ_LOD: |
| str << (isVertex ? "textureProjLod" : "textureProj"); |
| break; |
| case TYPE_TEXTURECUBE: |
| str << "texture"; |
| break; |
| case TYPE_TEXTURECUBE_LOD: |
| str << (isVertex ? "textureLod" : "texture"); |
| break; |
| default: |
| DE_ASSERT(false); |
| } |
| } |
| else |
| { |
| switch (m_type) |
| { |
| case TYPE_TEXTURE2D: |
| str << "texture2D"; |
| break; |
| case TYPE_TEXTURE2D_LOD: |
| str << (isVertex ? "texture2DLod" : "texture2D"); |
| break; |
| case TYPE_TEXTURE2D_PROJ: |
| str << "texture2DProj"; |
| break; |
| case TYPE_TEXTURE2D_PROJ_LOD: |
| str << (isVertex ? "texture2DProjLod" : "texture2DProj"); |
| break; |
| case TYPE_TEXTURECUBE: |
| str << "textureCube"; |
| break; |
| case TYPE_TEXTURECUBE_LOD: |
| str << (isVertex ? "textureCubeLod" : "textureCube"); |
| break; |
| default: |
| DE_ASSERT(false); |
| } |
| } |
| |
| str << Token::LEFT_PAREN; |
| str << m_sampler->getName(); |
| str << Token::COMMA; |
| m_coordExpr->tokenize(state, str); |
| |
| if (m_lodBiasExpr) |
| { |
| str << Token::COMMA; |
| m_lodBiasExpr->tokenize(state, str); |
| } |
| |
| str << Token::RIGHT_PAREN; |
| } |
| |
| float TexLookup::getWeight(const GeneratorState &state, ConstValueRangeAccess valueRange) |
| { |
| if (state.getShaderParameters().texLookupBaseWeight <= 0.0f) |
| return 0.0f; |
| |
| int availableLevels = state.getShaderParameters().maxExpressionDepth - state.getExpressionDepth(); |
| |
| // Lookup + Constructor + Values |
| if (availableLevels < 3) |
| return 0.0f; |
| |
| if (state.getExpressionFlags() & (CONST_EXPR | NO_VAR_ALLOCATION)) |
| return 0.0f; |
| |
| if (valueRange.getType() != VariableType(VariableType::TYPE_FLOAT, 4)) |
| return 0.0f; |
| |
| ValueRange texOutputRange(VariableType(VariableType::TYPE_FLOAT, 4)); |
| for (int ndx = 0; ndx < 4; ndx++) |
| { |
| texOutputRange.getMin().component(ndx) = 0.0f; |
| texOutputRange.getMax().component(ndx) = 1.0f; |
| } |
| |
| if (!valueRange.isSupersetOf(texOutputRange.asAccess())) |
| return 0.0f; |
| |
| return state.getShaderParameters().texLookupBaseWeight; |
| } |
| |
| void TexLookup::evaluate(ExecutionContext &execCtx) |
| { |
| // Evaluate coord and bias. |
| m_coordExpr->evaluate(execCtx); |
| if (m_lodBiasExpr) |
| m_lodBiasExpr->evaluate(execCtx); |
| |
| ExecConstValueAccess coords = m_coordExpr->getValue(); |
| ExecValueAccess dst = m_value.getValue(m_valueType); |
| |
| switch (m_type) |
| { |
| case TYPE_TEXTURE2D: |
| { |
| const Sampler2D &tex = execCtx.getSampler2D(m_sampler); |
| for (int i = 0; i < EXEC_VEC_WIDTH; i++) |
| { |
| float s = coords.component(0).asFloat(i); |
| float t = coords.component(1).asFloat(i); |
| tcu::Vec4 p = tex.sample(s, t, 0.0f); |
| |
| for (int comp = 0; comp < 4; comp++) |
| dst.component(comp).asFloat(i) = p[comp]; |
| } |
| break; |
| } |
| |
| case TYPE_TEXTURE2D_LOD: |
| { |
| ExecConstValueAccess lod = m_lodBiasExpr->getValue(); |
| const Sampler2D &tex = execCtx.getSampler2D(m_sampler); |
| for (int i = 0; i < EXEC_VEC_WIDTH; i++) |
| { |
| float s = coords.component(0).asFloat(i); |
| float t = coords.component(1).asFloat(i); |
| float l = lod.component(0).asFloat(i); |
| tcu::Vec4 p = tex.sample(s, t, l); |
| |
| for (int comp = 0; comp < 4; comp++) |
| dst.component(comp).asFloat(i) = p[comp]; |
| } |
| break; |
| } |
| |
| case TYPE_TEXTURE2D_PROJ: |
| { |
| const Sampler2D &tex = execCtx.getSampler2D(m_sampler); |
| for (int i = 0; i < EXEC_VEC_WIDTH; i++) |
| { |
| float s = coords.component(0).asFloat(i); |
| float t = coords.component(1).asFloat(i); |
| float w = coords.component(2).asFloat(i); |
| tcu::Vec4 p = tex.sample(s / w, t / w, 0.0f); |
| |
| for (int comp = 0; comp < 4; comp++) |
| dst.component(comp).asFloat(i) = p[comp]; |
| } |
| break; |
| } |
| |
| case TYPE_TEXTURE2D_PROJ_LOD: |
| { |
| ExecConstValueAccess lod = m_lodBiasExpr->getValue(); |
| const Sampler2D &tex = execCtx.getSampler2D(m_sampler); |
| for (int i = 0; i < EXEC_VEC_WIDTH; i++) |
| { |
| float s = coords.component(0).asFloat(i); |
| float t = coords.component(1).asFloat(i); |
| float w = coords.component(2).asFloat(i); |
| float l = lod.component(0).asFloat(i); |
| tcu::Vec4 p = tex.sample(s / w, t / w, l); |
| |
| for (int comp = 0; comp < 4; comp++) |
| dst.component(comp).asFloat(i) = p[comp]; |
| } |
| break; |
| } |
| |
| case TYPE_TEXTURECUBE: |
| { |
| const SamplerCube &tex = execCtx.getSamplerCube(m_sampler); |
| for (int i = 0; i < EXEC_VEC_WIDTH; i++) |
| { |
| float s = coords.component(0).asFloat(i); |
| float t = coords.component(1).asFloat(i); |
| float r = coords.component(2).asFloat(i); |
| tcu::Vec4 p = tex.sample(s, t, r, 0.0f); |
| |
| for (int comp = 0; comp < 4; comp++) |
| dst.component(comp).asFloat(i) = p[comp]; |
| } |
| break; |
| } |
| |
| case TYPE_TEXTURECUBE_LOD: |
| { |
| ExecConstValueAccess lod = m_lodBiasExpr->getValue(); |
| const SamplerCube &tex = execCtx.getSamplerCube(m_sampler); |
| for (int i = 0; i < EXEC_VEC_WIDTH; i++) |
| { |
| float s = coords.component(0).asFloat(i); |
| float t = coords.component(1).asFloat(i); |
| float r = coords.component(2).asFloat(i); |
| float l = lod.component(0).asFloat(i); |
| tcu::Vec4 p = tex.sample(s, t, r, l); |
| |
| for (int comp = 0; comp < 4; comp++) |
| dst.component(comp).asFloat(i) = p[comp]; |
| } |
| break; |
| } |
| |
| default: |
| DE_ASSERT(false); |
| } |
| } |
| |
| } // namespace rsg |