X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Fpublic-api%2Fmath%2Fmath-utils.h;h=521d266160aa3f5abf327b063bf92706c5675eda;hb=646f736e77b085c86e982c0d1d4b895c2a431330;hp=25a26a78b60cede0c531085094a45549c1f39582;hpb=783cf777ff0e903754ffea8452867e9c225c0aee;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/dali/public-api/math/math-utils.h b/dali/public-api/math/math-utils.h index 25a26a7..521d266 100644 --- a/dali/public-api/math/math-utils.h +++ b/dali/public-api/math/math-utils.h @@ -2,7 +2,7 @@ #define __DALI_MATH_UTILS_H__ /* - * Copyright (c) 2014 Samsung Electronics Co., Ltd. + * Copyright (c) 2018 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -18,24 +18,32 @@ * */ +// EXTERNAL INCLUDES +#include // uint32_t + // INTERNAL INCLUDES #include #include namespace Dali { +/** + * @addtogroup dali_core_math + * @{ + */ /** * @brief Returns the next power of two. * * In case of numbers which are already a power of two this function returns the original number. - * If i is zero returns 1 - * @param[in] i input number - * @return next power of two or i itself in case it's a power of two + * If i is zero returns 1. + * @SINCE_1_0.0 + * @param[in] i Input number + * @return The next power of two or i itself in case it's a power of two */ -inline unsigned int NextPowerOfTwo( unsigned int i ) +inline uint32_t NextPowerOfTwo( uint32_t i ) { - DALI_ASSERT_DEBUG(i <= 1u << (sizeof(unsigned) * 8 - 1) && "Return type cannot represent the next power of two greater than the argument."); + DALI_ASSERT_ALWAYS(i <= 1u << (sizeof(uint32_t) * 8 - 1) && "Return type cannot represent the next power of two greater than the argument."); if(i==0u) { return 1u; @@ -54,10 +62,11 @@ inline unsigned int NextPowerOfTwo( unsigned int i ) /** * @brief Whether a number is power of two. * - * @param[in] i input number - * @return true if i is power of two + * @SINCE_1_0.0 + * @param[in] i Input number + * @return True if i is power of two. */ -inline bool IsPowerOfTwo( unsigned int i ) +inline bool IsPowerOfTwo( uint32_t i ) { return (i != 0u) && ((i & (i - 1u)) == 0u); } @@ -65,6 +74,7 @@ inline bool IsPowerOfTwo( unsigned int i ) /** * @brief Clamp a value. * + * @SINCE_1_0.0 * @param[in] value The value to clamp. * @param[in] min The minimum allowed value. * @param[in] max The maximum allowed value. @@ -81,6 +91,7 @@ inline const T& Clamp( const T& value, const T& min, const T& max ) /** * @brief Clamp a value directly. * + * @SINCE_1_0.0 * @param[in,out] value The value that will be clamped. * @param[in] min The minimum allowed value. * @param[in] max The maximum allowed value. @@ -97,8 +108,9 @@ inline void ClampInPlace( T& value, const T& min, const T& max ) /** * @brief Linear interpolation between two values. * + * @SINCE_1_0.0 * @param[in] offset The offset through the range @p low to @p high. - * This value is clamped between 0 and 1 + * This value is clamped between 0 and 1. * @param[in] low Lowest value in range * @param[in] high Highest value in range * @return A value between low and high. @@ -112,6 +124,7 @@ inline const T Lerp( const float offset, const T& low, const T& high ) /** * @brief Get an epsilon that is valid for the given range. * + * @SINCE_1_0.0 * @param[in] a the first value in the range * @param[in] b the second value in the range. * @return a suitable epsilon @@ -121,7 +134,7 @@ inline float GetRangedEpsilon( float a, float b ) const float absA = fabsf( a ); const float absB = fabsf( b ); const float absF = absA > absB ? absA : absB; - const int absI = absF; + const int32_t absI = static_cast( absF ); // truncated float epsilon = Math::MACHINE_EPSILON_10000; if (absF < 0.1f) @@ -150,6 +163,7 @@ inline float GetRangedEpsilon( float a, float b ) /** * @brief Helper function to compare equality of a floating point value with zero. * + * @SINCE_1_0.0 * @param[in] value the value to compare * @return true if the value is equal to zero */ @@ -164,6 +178,7 @@ inline bool EqualsZero( float value ) /** * @brief Helper function to compare equality of two floating point values. * + * @SINCE_1_0.0 * @param[in] a the first value to compare * @param[in] b the second value to compare * @return true if the values are equal within a minimal epsilon for their values @@ -176,6 +191,7 @@ inline bool Equals( float a, float b ) /** * @brief Helper function to compare equality of two floating point values. * + * @SINCE_1_0.0 * @param[in] a the first value to compare * @param[in] b the second value to compare * @param[in] epsilon the minimum epsilon value that will be used to consider the values different @@ -189,16 +205,17 @@ inline bool Equals( float a, float b, float epsilon ) /** * @brief Get an float that is rounded at specified place of decimals. * + * @SINCE_1_0.0 * @param[in] value float value * @param[in] pos decimal place * @return a rounded float */ -inline float Round(float value, int pos) +inline float Round( float value, int32_t pos ) { float temp; - temp = value * powf( 10, pos ); - temp = floorf( temp + 0.5 ); - temp *= powf( 10, -pos ); + temp = value * powf( 10.f, static_cast( pos ) ); + temp = floorf( temp + 0.5f ); + temp *= powf( 10.f, static_cast( -pos ) ); return temp; } @@ -212,27 +229,30 @@ inline float Round(float value, int pos) * start: 2 * end: 8 * + * @code * 2 8 * (\ / start) (\ / end) * |----x | + * @endcode * * The value x will be confined to this domain. - * If x is below 2 e.g. 0, then it is wraped to 6. + * If x is below 2 e.g. 0, then it is wrapped to 6. * If x is above or equal to 8 e.g. 8.1 then it is - * wrapped to 2.1 + * wrapped to 2.1. * * Domain wrapping is useful for various problems from * calculating positions in a space that repeats, to * computing angles that range from 0 to 360. * + * @SINCE_1_0.0 * @param[in] x the point to be wrapped within the domain * @param[in] start The start of the domain * @param[in] end The end of the domain * - * @note if start = end (i.e. size of domain 0), then wrapping will not occur + * @return the wrapped value over the domain (start) (end) + * @note If start = end (i.e. size of domain 0), then wrapping will not occur * and result will always be equal to start. * - * @return the wrapped value over the domain (start) (end) */ inline float WrapInDomain(float x, float start, float end) { @@ -252,8 +272,10 @@ inline float WrapInDomain(float x, float start, float end) * @brief Find the shortest distance (magnitude) and direction (sign) * from (a) to (b) in domain (start) to (end). * - * (\ / start) (\ / end) - * |-a b<----| + * @code + * (\ / start) (\ / end) + * |-a b<----| + * @endcode * * Knowing the shortest distance is useful with wrapped domains * to solve problems such as determing the closest object to @@ -267,14 +289,15 @@ inline float WrapInDomain(float x, float start, float end) * return -20. i.e. subtract 20 from current value (10) to reach * target wrapped value (350). * - * @note assumes both (a) and (b) are already within the domain - * (start) to (end) - * + * @SINCE_1_0.0 * @param a the current value * @param b the target value * @param start the start of the domain * @param end the end of the domain * @return the shortest direction (the sign) and distance (the magnitude) + * @note Assumes both (a) and (b) are already within the domain + * (start) to (end). + * */ inline float ShortestDistanceInDomain( float a, float b, float start, float end ) { @@ -306,6 +329,22 @@ inline float ShortestDistanceInDomain( float a, float b, float start, float end return vect; } +/** + * @brief Extracts the sign of a number + * + * @SINCE_1_0.0 + * @param[in] value The value we want to extract the sign + * @return -1 for negative values, +1 for positive values and 0 if value is 0 + */ +template +int32_t Sign( T value ) +{ + return ( T(0) < value ) - ( value < T(0) ); +} + +/** + * @} + */ } // namespace Dali #endif // __DALI_MATH_UTILS_H__