Home | History | Annotate | Download | only in utils 
      1 /*
      2  * Copyright (C) 2014 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 #ifndef MATHUTILS_H
     17 #define MATHUTILS_H
     18 
     19 #include <math.h>
     20 #include <algorithm>
     21 
     22 namespace android {
     23 namespace uirenderer {
     24 
     25 #define NON_ZERO_EPSILON (0.001f)
     26 #define ALPHA_EPSILON (0.001f)
     27 
     28 class MathUtils {
     29 public:
     30     /**
     31      * Check for floats that are close enough to zero.
     32      */
     33     inline static bool isZero(float value) {
     34         return (value >= -NON_ZERO_EPSILON) && (value <= NON_ZERO_EPSILON);
     35     }
     36 
     37     inline static bool isOne(float value) {
     38         return areEqual(value, 1.0f);
     39     }
     40 
     41     inline static bool isPositive(float value) { return value >= NON_ZERO_EPSILON; }
     42 
     43     /**
     44      * Clamps alpha value, and snaps when very near 0 or 1
     45      */
     46     inline static float clampAlpha(float alpha) {
     47         if (alpha <= ALPHA_EPSILON) {
     48             return 0;
     49         } else if (alpha >= (1 - ALPHA_EPSILON)) {
     50             return 1;
     51         } else {
     52             return alpha;
     53         }
     54     }
     55 
     56     /*
     57      * Clamps positive tessellation scale values
     58      */
     59     inline static float clampTessellationScale(float scale) {
     60         const float MIN_SCALE = 0.0001;
     61         const float MAX_SCALE = 1e10;
     62         if (scale < MIN_SCALE) {
     63             return MIN_SCALE;
     64         } else if (scale > MAX_SCALE) {
     65             return MAX_SCALE;
     66         }
     67         return scale;
     68     }
     69 
     70     /**
     71      * Returns the number of points (beyond two, the start and end) needed to form a polygonal
     72      * approximation of an arc, with a given threshold value.
     73      */
     74     inline static int divisionsNeededToApproximateArc(float radius, float angleInRads,
     75                                                       float threshold) {
     76         const float errConst = (-threshold / radius + 1);
     77         const float targetCosVal = 2 * errConst * errConst - 1;
     78 
     79         // needed divisions are rounded up from approximation
     80         return (int)(ceilf(angleInRads / acos(targetCosVal) / 2)) * 2;
     81     }
     82 
     83     inline static bool areEqual(float valueA, float valueB) { return isZero(valueA - valueB); }
     84 
     85     template <typename T>
     86     static inline T clamp(T a, T minValue, T maxValue) {
     87         return std::min(std::max(a, minValue), maxValue);
     88     }
     89 
     90     inline static float lerp(float v1, float v2, float t) { return v1 + ((v2 - v1) * t); }
     91 };  // class MathUtils
     92 
     93 } /* namespace uirenderer */
     94 } /* namespace android */
     95 
     96 #endif /* MATHUTILS_H */
     97