Home | History | Annotate | Download | only in randomshaders 
      1 #ifndef _RSGBUILTINFUNCTIONS_HPP
      2 #define _RSGBUILTINFUNCTIONS_HPP
      3 /*-------------------------------------------------------------------------
      4  * drawElements Quality Program Random Shader Generator
      5  * ----------------------------------------------------
      6  *
      7  * Copyright 2014 The Android Open Source Project
      8  *
      9  * Licensed under the Apache License, Version 2.0 (the "License");
     10  * you may not use this file except in compliance with the License.
     11  * You may obtain a copy of the License at
     12  *
     13  *      http://www.apache.org/licenses/LICENSE-2.0
     14  *
     15  * Unless required by applicable law or agreed to in writing, software
     16  * distributed under the License is distributed on an "AS IS" BASIS,
     17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     18  * See the License for the specific language governing permissions and
     19  * limitations under the License.
     20  *
     21  *//*!
     22  * \file
     23  * \brief Built-in Functions.
     24  *//*--------------------------------------------------------------------*/
     25 
     26 #include "rsgDefs.hpp"
     27 #include "rsgExpression.hpp"
     28 #include "rsgUtils.hpp"
     29 #include "deMath.h"
     30 
     31 namespace rsg
     32 {
     33 
     34 // Template for built-in functions with form "GenType func(GenType val)".
     35 template <class GetValueRangeWeight, class ComputeValueRange, class Evaluate>
     36 class UnaryBuiltinVecFunc : public Expression
     37 {
     38 public:
     39 								UnaryBuiltinVecFunc		(GeneratorState& state, const char* function, ConstValueRangeAccess valueRange);
     40 	virtual						~UnaryBuiltinVecFunc	(void);
     41 
     42 	Expression*					createNextChild			(GeneratorState& state);
     43 	void						tokenize				(GeneratorState& state, TokenStream& str) const;
     44 
     45 	void						evaluate				(ExecutionContext& execCtx);
     46 	ExecConstValueAccess		getValue				(void) const { return m_value.getValue(m_inValueRange.getType()); }
     47 
     48 	static float				getWeight				(const GeneratorState& state, ConstValueRangeAccess valueRange);
     49 
     50 private:
     51 	std::string					m_function;
     52 	ValueRange					m_inValueRange;
     53 	ExecValueStorage			m_value;
     54 	Expression*					m_child;
     55 };
     56 
     57 template <class GetValueRangeWeight, class ComputeValueRange, class Evaluate>
     58 UnaryBuiltinVecFunc<GetValueRangeWeight, ComputeValueRange, Evaluate>::UnaryBuiltinVecFunc (GeneratorState& state, const char* function, ConstValueRangeAccess valueRange)
     59 	: m_function		(function)
     60 	, m_inValueRange	(valueRange.getType())
     61 	, m_child			(DE_NULL)
     62 {
     63 	DE_UNREF(state);
     64 	DE_ASSERT(valueRange.getType().isFloatOrVec());
     65 
     66 	m_value.setStorage(valueRange.getType());
     67 
     68 	// Compute input value range
     69 	for (int ndx = 0; ndx < m_inValueRange.getType().getNumElements(); ndx++)
     70 	{
     71 		ConstValueRangeAccess	outRange	= valueRange.component(ndx);
     72 		ValueRangeAccess		inRange		= m_inValueRange.asAccess().component(ndx);
     73 
     74 		ComputeValueRange()(outRange.getMin().asFloat(), outRange.getMax().asFloat(), inRange.getMin().asFloat(), inRange.getMax().asFloat());
     75 	}
     76 }
     77 
     78 template <class GetValueRangeWeight, class ComputeValueRange, class Evaluate>
     79 UnaryBuiltinVecFunc<GetValueRangeWeight, ComputeValueRange, Evaluate>::~UnaryBuiltinVecFunc (void)
     80 {
     81 	delete m_child;
     82 }
     83 
     84 template <class GetValueRangeWeight, class ComputeValueRange, class Evaluate>
     85 Expression* UnaryBuiltinVecFunc<GetValueRangeWeight, ComputeValueRange, Evaluate>::createNextChild (GeneratorState& state)
     86 {
     87 	if (m_child)
     88 		return DE_NULL;
     89 
     90 	m_child = Expression::createRandom(state, m_inValueRange.asAccess());
     91 	return m_child;
     92 }
     93 
     94 template <class GetValueRangeWeight, class ComputeValueRange, class Evaluate>
     95 void UnaryBuiltinVecFunc<GetValueRangeWeight, ComputeValueRange, Evaluate>::tokenize (GeneratorState& state, TokenStream& str) const
     96 {
     97 	str << Token(m_function.c_str()) << Token::LEFT_PAREN;
     98 	m_child->tokenize(state, str);
     99 	str << Token::RIGHT_PAREN;
    100 }
    101 
    102 template <class GetValueRangeWeight, class ComputeValueRange, class Evaluate>
    103 void UnaryBuiltinVecFunc<GetValueRangeWeight, ComputeValueRange, Evaluate>::evaluate (ExecutionContext& execCtx)
    104 {
    105 	m_child->evaluate(execCtx);
    106 
    107 	ExecConstValueAccess	srcValue	= m_child->getValue();
    108 	ExecValueAccess			dstValue	= m_value.getValue(m_inValueRange.getType());
    109 
    110 	for (int elemNdx = 0; elemNdx < m_inValueRange.getType().getNumElements(); elemNdx++)
    111 	{
    112 		ExecConstValueAccess	srcComp		= srcValue.component(elemNdx);
    113 		ExecValueAccess			dstComp		= dstValue.component(elemNdx);
    114 
    115 		for (int compNdx = 0; compNdx < EXEC_VEC_WIDTH; compNdx++)
    116 			dstComp.asFloat(compNdx) = Evaluate()(srcComp.asFloat(compNdx));
    117 	}
    118 }
    119 
    120 template <class GetValueRangeWeight, class ComputeValueRange, class Evaluate>
    121 float UnaryBuiltinVecFunc<GetValueRangeWeight, ComputeValueRange, Evaluate>::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
    122 {
    123 	// \todo [2011-06-14 pyry] Void support?
    124 	if (!valueRange.getType().isFloatOrVec())
    125 		return 0.0f;
    126 
    127 	int availableLevels = state.getShaderParameters().maxExpressionDepth - state.getExpressionDepth();
    128 
    129 	if (availableLevels < getConservativeValueExprDepth(state, valueRange) + 1)
    130 		return 0.0f;
    131 
    132 	// Compute value range weight
    133 	float combinedWeight = 1.0f;
    134 	for (int elemNdx = 0; elemNdx < valueRange.getType().getNumElements(); elemNdx++)
    135 	{
    136 		float elemWeight = GetValueRangeWeight()(valueRange.component(elemNdx).getMin().asFloat(), valueRange.component(elemNdx).getMax().asFloat());
    137 		combinedWeight *= elemWeight;
    138 	}
    139 
    140 	return combinedWeight;
    141 }
    142 
    143 // Proxy template.
    144 template <class C>
    145 struct GetUnaryBuiltinVecWeight
    146 {
    147 	inline float operator() (float outMin, float outMax) const { return C::getCompWeight(outMin, outMax); }
    148 };
    149 
    150 template <class C>
    151 struct ComputeUnaryBuiltinVecRange
    152 {
    153 	inline void operator() (float outMin, float outMax, float& inMin, float& inMax) const { C::computeValueRange(outMin, outMax, inMin, inMax); }
    154 };
    155 
    156 template <class C>
    157 struct EvaluateUnaryBuiltinVec
    158 {
    159 	inline float operator() (float inVal) const { return C::evaluateComp(inVal); }
    160 };
    161 
    162 template <class C>
    163 class UnaryBuiltinVecTemplateProxy : public UnaryBuiltinVecFunc<GetUnaryBuiltinVecWeight<C>, ComputeUnaryBuiltinVecRange<C>, EvaluateUnaryBuiltinVec<C> >
    164 {
    165 public:
    166 	UnaryBuiltinVecTemplateProxy (GeneratorState& state, const char* function, ConstValueRangeAccess valueRange)
    167 		: UnaryBuiltinVecFunc<GetUnaryBuiltinVecWeight<C>, ComputeUnaryBuiltinVecRange<C>, EvaluateUnaryBuiltinVec<C> >(state, function, valueRange)
    168 	{
    169 	}
    170 };
    171 
    172 // Template for trigonometric function group.
    173 template <class C>
    174 class UnaryTrigonometricFunc : public UnaryBuiltinVecTemplateProxy<C>
    175 {
    176 public:
    177 	UnaryTrigonometricFunc (GeneratorState& state, const char* function, ConstValueRangeAccess valueRange)
    178 		: UnaryBuiltinVecTemplateProxy<C>(state, function, valueRange)
    179 	{
    180 	}
    181 
    182 	static inline float getCompWeight (float outMin, float outMax)
    183 	{
    184 		if (Scalar::min<float>() == outMin || Scalar::max<float>() == outMax)
    185 			return 1.0f; // Infinite value range, anything goes
    186 
    187 		// Transform range
    188 		float inMin, inMax;
    189 		if (!C::transformValueRange(outMin, outMax, inMin, inMax))
    190 			return 0.0f; // Not possible to transform value range (out of range perhaps)
    191 
    192 		// Quantize
    193 		if (!quantizeFloatRange(inMin, inMax))
    194 			return 0.0f; // Not possible to quantize - would cause accuracy issues
    195 
    196 		if (outMin == outMax)
    197 			return 1.0f; // Constant value and passed quantization
    198 
    199 		// Evaluate new intersection
    200 		float intersectionLen	= C::evaluateComp(inMax) - C::evaluateComp(inMin);
    201 		float valRangeLen		= outMax - outMin;
    202 
    203 		return deFloatMax(0.1f, intersectionLen/valRangeLen);
    204 	}
    205 
    206 	static inline void computeValueRange (float outMin, float outMax, float& inMin, float& inMax)
    207 	{
    208 		DE_VERIFY(C::transformValueRange(outMin, outMax, inMin, inMax));
    209 		DE_VERIFY(quantizeFloatRange(inMin, inMax));
    210 		DE_ASSERT(inMin <= inMax);
    211 	}
    212 
    213 	static float getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
    214 	{
    215 		if (state.getProgramParameters().trigonometricBaseWeight <= 0.0f)
    216 			return 0.0f;
    217 
    218 		return UnaryBuiltinVecTemplateProxy<C>::getWeight(state, valueRange) * state.getProgramParameters().trigonometricBaseWeight;
    219 	}
    220 };
    221 
    222 class SinOp : public UnaryTrigonometricFunc<SinOp>
    223 {
    224 public:
    225 	SinOp (GeneratorState& state, ConstValueRangeAccess valueRange)
    226 		: UnaryTrigonometricFunc<SinOp>(state, "sin", valueRange)
    227 	{
    228 	}
    229 
    230 	static inline bool transformValueRange (float outMin, float outMax, float& inMin, float& inMax)
    231 	{
    232 		if (outMax < -1.0f || outMin > 1.0f)
    233 			return false;
    234 
    235 		inMin = (outMin >= -1.0f) ? deFloatAsin(outMin) : -0.5f*DE_PI;
    236 		inMax = (outMax <= +1.0f) ? deFloatAsin(outMax) : +0.5f*DE_PI;
    237 
    238 		return true;
    239 	}
    240 
    241 	static inline float evaluateComp (float inVal)
    242 	{
    243 		return deFloatSin(inVal);
    244 	}
    245 };
    246 
    247 class CosOp : public UnaryTrigonometricFunc<CosOp>
    248 {
    249 public:
    250 	CosOp (GeneratorState& state, ConstValueRangeAccess valueRange)
    251 		: UnaryTrigonometricFunc<CosOp>(state, "cos", valueRange)
    252 	{
    253 	}
    254 
    255 	static inline bool transformValueRange (float outMin, float outMax, float& inMin, float& inMax)
    256 	{
    257 		if (outMax < -1.0f || outMin > 1.0f)
    258 			return false;
    259 
    260 		inMax = (outMin >= -1.0f) ? deFloatAcos(outMin) : +DE_PI;
    261 		inMin = (outMax <= +1.0f) ? deFloatAcos(outMax) : -DE_PI;
    262 
    263 		return true;
    264 	}
    265 
    266 	static inline float evaluateComp (float inVal)
    267 	{
    268 		return deFloatCos(inVal);
    269 	}
    270 };
    271 
    272 class TanOp : public UnaryTrigonometricFunc<TanOp>
    273 {
    274 public:
    275 	TanOp (GeneratorState& state, ConstValueRangeAccess valueRange)
    276 		: UnaryTrigonometricFunc<TanOp>(state, "tan", valueRange)
    277 	{
    278 	}
    279 
    280 	static inline bool transformValueRange (float outMin, float outMax, float& inMin, float& inMax)
    281 	{
    282 		// \note Currently tan() is limited to -4..4 range. Otherwise we will run into accuracy issues
    283 		const float rangeMin = -4.0f;
    284 		const float rangeMax = +4.0f;
    285 
    286 		if (outMax < rangeMin || outMin > rangeMax)
    287 			return false;
    288 
    289 		inMin = deFloatAtanOver(deFloatMax(outMin, rangeMin));
    290 		inMax = deFloatAtanOver(deFloatMin(outMax, rangeMax));
    291 
    292 		return true;
    293 	}
    294 
    295 	static inline float evaluateComp (float inVal)
    296 	{
    297 		return deFloatTan(inVal);
    298 	}
    299 };
    300 
    301 class AsinOp : public UnaryTrigonometricFunc<AsinOp>
    302 {
    303 public:
    304 	AsinOp (GeneratorState& state, ConstValueRangeAccess valueRange)
    305 		: UnaryTrigonometricFunc<AsinOp>(state, "asin", valueRange)
    306 	{
    307 	}
    308 
    309 	static inline bool transformValueRange (float outMin, float outMax, float& inMin, float& inMax)
    310 	{
    311 		const float rangeMin = -DE_PI/2.0f;
    312 		const float rangeMax = +DE_PI/2.0f;
    313 
    314 		if (outMax < rangeMin || outMin > rangeMax)
    315 			return false; // Out of range
    316 
    317 		inMin = deFloatSin(deFloatMax(outMin, rangeMin));
    318 		inMax = deFloatSin(deFloatMin(outMax, rangeMax));
    319 
    320 		return true;
    321 	}
    322 
    323 	static inline float evaluateComp (float inVal)
    324 	{
    325 		return deFloatAsin(inVal);
    326 	}
    327 };
    328 
    329 class AcosOp : public UnaryTrigonometricFunc<AcosOp>
    330 {
    331 public:
    332 	AcosOp (GeneratorState& state, ConstValueRangeAccess valueRange)
    333 		: UnaryTrigonometricFunc<AcosOp>(state, "acos", valueRange)
    334 	{
    335 	}
    336 
    337 	static inline bool transformValueRange (float outMin, float outMax, float& inMin, float& inMax)
    338 	{
    339 		const float rangeMin = 0.0f;
    340 		const float rangeMax = DE_PI;
    341 
    342 		if (outMax < rangeMin || outMin > rangeMax)
    343 			return false; // Out of range
    344 
    345 		inMax = deFloatCos(deFloatMax(outMin, rangeMin));
    346 		inMin = deFloatCos(deFloatMin(outMax, rangeMax));
    347 
    348 		return true;
    349 	}
    350 
    351 	static inline float evaluateComp (float inVal)
    352 	{
    353 		return deFloatAcos(inVal);
    354 	}
    355 };
    356 
    357 class AtanOp : public UnaryTrigonometricFunc<AtanOp>
    358 {
    359 public:
    360 	AtanOp (GeneratorState& state, ConstValueRangeAccess valueRange)
    361 		: UnaryTrigonometricFunc<AtanOp>(state, "atan", valueRange)
    362 	{
    363 	}
    364 
    365 	static inline bool transformValueRange (float outMin, float outMax, float& inMin, float& inMax)
    366 	{
    367 		// \note For accuracy reasons output range is limited to -1..1
    368 		const float rangeMin = -1.0f;
    369 		const float rangeMax = +1.0f;
    370 
    371 		if (outMax < rangeMin || outMin > rangeMax)
    372 			return false; // Out of range
    373 
    374 		inMin = deFloatTan(deFloatMax(outMin, rangeMin));
    375 		inMax = deFloatTan(deFloatMin(outMax, rangeMax));
    376 
    377 		return true;
    378 	}
    379 
    380 	static inline float evaluateComp (float inVal)
    381 	{
    382 		return deFloatAtanOver(inVal);
    383 	}
    384 };
    385 
    386 // Template for exponential function group.
    387 // \todo [2011-07-07 pyry] Shares most of the code with Trigonometric variant..
    388 template <class C>
    389 class UnaryExponentialFunc : public UnaryBuiltinVecTemplateProxy<C>
    390 {
    391 public:
    392 	UnaryExponentialFunc (GeneratorState& state, const char* function, ConstValueRangeAccess valueRange)
    393 		: UnaryBuiltinVecTemplateProxy<C>(state, function, valueRange)
    394 	{
    395 	}
    396 
    397 	static inline float getCompWeight (float outMin, float outMax)
    398 	{
    399 		if (Scalar::min<float>() == outMin || Scalar::max<float>() == outMax)
    400 			return 1.0f; // Infinite value range, anything goes
    401 
    402 		// Transform range
    403 		float inMin, inMax;
    404 		if (!C::transformValueRange(outMin, outMax, inMin, inMax))
    405 			return 0.0f; // Not possible to transform value range (out of range perhaps)
    406 
    407 		// Quantize
    408 		if (!quantizeFloatRange(inMin, inMax))
    409 			return 0.0f; // Not possible to quantize - would cause accuracy issues
    410 
    411 		if (outMin == outMax)
    412 			return 1.0f; // Constant value and passed quantization
    413 
    414 		// Evaluate new intersection
    415 		float intersectionLen	= C::evaluateComp(inMax) - C::evaluateComp(inMin);
    416 		float valRangeLen		= outMax - outMin;
    417 
    418 		return deFloatMax(0.1f, intersectionLen/valRangeLen);
    419 	}
    420 
    421 	static inline void computeValueRange (float outMin, float outMax, float& inMin, float& inMax)
    422 	{
    423 		DE_VERIFY(C::transformValueRange(outMin, outMax, inMin, inMax));
    424 		DE_VERIFY(quantizeFloatRange(inMin, inMax));
    425 		DE_ASSERT(inMin <= inMax);
    426 	}
    427 
    428 	static float getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
    429 	{
    430 		if (state.getProgramParameters().exponentialBaseWeight <= 0.0f)
    431 			return 0.0f;
    432 
    433 		return UnaryBuiltinVecTemplateProxy<C>::getWeight(state, valueRange) * state.getProgramParameters().exponentialBaseWeight;
    434 	}
    435 };
    436 
    437 class ExpOp : public UnaryExponentialFunc<ExpOp>
    438 {
    439 public:
    440 	ExpOp (GeneratorState& state, ConstValueRangeAccess valueRange)
    441 		: UnaryExponentialFunc<ExpOp>(state, "exp", valueRange)
    442 	{
    443 	}
    444 
    445 	static inline bool transformValueRange (float outMin, float outMax, float& inMin, float& inMax)
    446 	{
    447 		// Limited due to accuracy reasons, should be 0..+inf
    448 		const float rangeMin = 0.1f;
    449 		const float rangeMax = 10.0f;
    450 
    451 		if (outMax < rangeMin || outMin > rangeMax)
    452 			return false; // Out of range
    453 
    454 		inMin = deFloatLog(deFloatMax(outMin, rangeMin));
    455 		inMax = deFloatLog(deFloatMin(outMax, rangeMax));
    456 
    457 		return true;
    458 	}
    459 
    460 	static inline float evaluateComp (float inVal)
    461 	{
    462 		return deFloatExp(inVal);
    463 	}
    464 };
    465 
    466 class LogOp : public UnaryExponentialFunc<LogOp>
    467 {
    468 public:
    469 	LogOp (GeneratorState& state, ConstValueRangeAccess valueRange)
    470 		: UnaryExponentialFunc<LogOp>(state, "log", valueRange)
    471 	{
    472 	}
    473 
    474 	static inline bool transformValueRange (float outMin, float outMax, float& inMin, float& inMax)
    475 	{
    476 		// Limited due to accuracy reasons, should be -inf..+inf
    477 		const float rangeMin = 0.1f;
    478 		const float rangeMax = 6.0f;
    479 
    480 		if (outMax < rangeMin || outMin > rangeMax)
    481 			return false; // Out of range
    482 
    483 		inMin = deFloatExp(deFloatMax(outMin, rangeMin));
    484 		inMax = deFloatExp(deFloatMin(outMax, rangeMax));
    485 
    486 		return true;
    487 	}
    488 
    489 	static inline float evaluateComp (float inVal)
    490 	{
    491 		return deFloatLog(inVal);
    492 	}
    493 };
    494 
    495 class Exp2Op : public UnaryExponentialFunc<Exp2Op>
    496 {
    497 public:
    498 	Exp2Op (GeneratorState& state, ConstValueRangeAccess valueRange)
    499 		: UnaryExponentialFunc<Exp2Op>(state, "exp2", valueRange)
    500 	{
    501 	}
    502 
    503 	static inline bool transformValueRange (float outMin, float outMax, float& inMin, float& inMax)
    504 	{
    505 		// Limited due to accuracy reasons, should be 0..+inf
    506 		const float rangeMin = 0.1f;
    507 		const float rangeMax = 10.0f;
    508 
    509 		if (outMax < rangeMin || outMin > rangeMax)
    510 			return false; // Out of range
    511 
    512 		inMin = deFloatLog2(deFloatMax(outMin, rangeMin));
    513 		inMax = deFloatLog2(deFloatMin(outMax, rangeMax));
    514 
    515 		return true;
    516 	}
    517 
    518 	static inline float evaluateComp (float inVal)
    519 	{
    520 		return deFloatExp2(inVal);
    521 	}
    522 };
    523 
    524 class Log2Op : public UnaryExponentialFunc<Log2Op>
    525 {
    526 public:
    527 	Log2Op (GeneratorState& state, ConstValueRangeAccess valueRange)
    528 		: UnaryExponentialFunc<Log2Op>(state, "log2", valueRange)
    529 	{
    530 	}
    531 
    532 	static inline bool transformValueRange (float outMin, float outMax, float& inMin, float& inMax)
    533 	{
    534 		// Limited due to accuracy reasons, should be -inf..+inf
    535 		const float rangeMin = 0.1f;
    536 		const float rangeMax = 6.0f;
    537 
    538 		if (outMax < rangeMin || outMin > rangeMax)
    539 			return false; // Out of range
    540 
    541 		inMin = deFloatExp2(deFloatMax(outMin, rangeMin));
    542 		inMax = deFloatExp2(deFloatMin(outMax, rangeMax));
    543 
    544 		return true;
    545 	}
    546 
    547 	static inline float evaluateComp (float inVal)
    548 	{
    549 		return deFloatLog2(inVal);
    550 	}
    551 };
    552 
    553 class SqrtOp : public UnaryExponentialFunc<SqrtOp>
    554 {
    555 public:
    556 	SqrtOp (GeneratorState& state, ConstValueRangeAccess valueRange)
    557 		: UnaryExponentialFunc<SqrtOp>(state, "sqrt", valueRange)
    558 	{
    559 	}
    560 
    561 	static inline bool transformValueRange (float outMin, float outMax, float& inMin, float& inMax)
    562 	{
    563 		// Limited due to accuracy reasons, should be 0..+inf
    564 		const float rangeMin = 0.0f;
    565 		const float rangeMax = 4.0f;
    566 
    567 		if (outMax < rangeMin || outMin > rangeMax)
    568 			return false; // Out of range
    569 
    570 		inMin = deFloatMax(outMin, rangeMin);
    571 		inMax = deFloatMin(outMax, rangeMax);
    572 
    573 		inMin *= inMin;
    574 		inMax *= inMax;
    575 
    576 		return true;
    577 	}
    578 
    579 	static inline float evaluateComp (float inVal)
    580 	{
    581 		return deFloatSqrt(inVal);
    582 	}
    583 };
    584 
    585 class InvSqrtOp : public UnaryExponentialFunc<InvSqrtOp>
    586 {
    587 public:
    588 	InvSqrtOp (GeneratorState& state, ConstValueRangeAccess valueRange)
    589 		: UnaryExponentialFunc<InvSqrtOp>(state, "inversesqrt", valueRange)
    590 	{
    591 	}
    592 
    593 	static inline bool transformValueRange (float outMin, float outMax, float& inMin, float& inMax)
    594 	{
    595 		// Limited due to accuracy reasons
    596 		const float rangeMin = 0.4f;
    597 		const float rangeMax = 3.0f;
    598 
    599 		if (outMax < rangeMin || outMin > rangeMax)
    600 			return false; // Out of range
    601 
    602 		inMax = 1.0f/deFloatMax(outMin, rangeMin);
    603 		inMin = 1.0f/deFloatMin(outMax, rangeMax);
    604 
    605 		inMin *= inMin;
    606 		inMax *= inMax;
    607 
    608 		return true;
    609 	}
    610 
    611 	static inline float evaluateComp (float inVal)
    612 	{
    613 		return 1.0f/deFloatSqrt(inVal);
    614 	}
    615 };
    616 
    617 } // rsg
    618 
    619 #endif // _RSGBUILTINFUNCTIONS_HPP
    620