Home | History | Annotate | Download | only in hwui 
      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 
     17 #include "Interpolator.h"
     18 
     19 #include <algorithm>
     20 
     21 #include <log/log.h>
     22 
     23 #include "utils/MathUtils.h"
     24 
     25 namespace android {
     26 namespace uirenderer {
     27 
     28 Interpolator* Interpolator::createDefaultInterpolator() {
     29     return new AccelerateDecelerateInterpolator();
     30 }
     31 
     32 float AccelerateDecelerateInterpolator::interpolate(float input) {
     33     return (float)(cosf((input + 1) * M_PI) / 2.0f) + 0.5f;
     34 }
     35 
     36 float AccelerateInterpolator::interpolate(float input) {
     37     if (mFactor == 1.0f) {
     38         return input * input;
     39     } else {
     40         return pow(input, mDoubleFactor);
     41     }
     42 }
     43 
     44 float AnticipateInterpolator::interpolate(float t) {
     45     return t * t * ((mTension + 1) * t - mTension);
     46 }
     47 
     48 static float a(float t, float s) {
     49     return t * t * ((s + 1) * t - s);
     50 }
     51 
     52 static float o(float t, float s) {
     53     return t * t * ((s + 1) * t + s);
     54 }
     55 
     56 float AnticipateOvershootInterpolator::interpolate(float t) {
     57     if (t < 0.5f)
     58         return 0.5f * a(t * 2.0f, mTension);
     59     else
     60         return 0.5f * (o(t * 2.0f - 2.0f, mTension) + 2.0f);
     61 }
     62 
     63 static float bounce(float t) {
     64     return t * t * 8.0f;
     65 }
     66 
     67 float BounceInterpolator::interpolate(float t) {
     68     t *= 1.1226f;
     69     if (t < 0.3535f)
     70         return bounce(t);
     71     else if (t < 0.7408f)
     72         return bounce(t - 0.54719f) + 0.7f;
     73     else if (t < 0.9644f)
     74         return bounce(t - 0.8526f) + 0.9f;
     75     else
     76         return bounce(t - 1.0435f) + 0.95f;
     77 }
     78 
     79 float CycleInterpolator::interpolate(float input) {
     80     return sinf(2 * mCycles * M_PI * input);
     81 }
     82 
     83 float DecelerateInterpolator::interpolate(float input) {
     84     float result;
     85     if (mFactor == 1.0f) {
     86         result = 1.0f - (1.0f - input) * (1.0f - input);
     87     } else {
     88         result = 1.0f - pow((1.0f - input), 2 * mFactor);
     89     }
     90     return result;
     91 }
     92 
     93 float OvershootInterpolator::interpolate(float t) {
     94     t -= 1.0f;
     95     return t * t * ((mTension + 1) * t + mTension) + 1.0f;
     96 }
     97 
     98 float PathInterpolator::interpolate(float t) {
     99     if (t <= 0) {
    100         return 0;
    101     } else if (t >= 1) {
    102         return 1;
    103     }
    104     // Do a binary search for the correct x to interpolate between.
    105     size_t startIndex = 0;
    106     size_t endIndex = mX.size() - 1;
    107 
    108     while (endIndex > startIndex + 1) {
    109         int midIndex = (startIndex + endIndex) / 2;
    110         if (t < mX[midIndex]) {
    111             endIndex = midIndex;
    112         } else {
    113             startIndex = midIndex;
    114         }
    115     }
    116 
    117     float xRange = mX[endIndex] - mX[startIndex];
    118     if (xRange == 0) {
    119         return mY[startIndex];
    120     }
    121 
    122     float tInRange = t - mX[startIndex];
    123     float fraction = tInRange / xRange;
    124 
    125     float startY = mY[startIndex];
    126     float endY = mY[endIndex];
    127     return startY + (fraction * (endY - startY));
    128 }
    129 
    130 LUTInterpolator::LUTInterpolator(float* values, size_t size) : mValues(values), mSize(size) {}
    131 
    132 LUTInterpolator::~LUTInterpolator() {}
    133 
    134 float LUTInterpolator::interpolate(float input) {
    135     // lut position should only be at the end of the table when input is 1f.
    136     float lutpos = input * (mSize - 1);
    137     if (lutpos >= (mSize - 1)) {
    138         return mValues[mSize - 1];
    139     }
    140 
    141     float ipart, weight;
    142     weight = modff(lutpos, &ipart);
    143 
    144     int i1 = (int)ipart;
    145     int i2 = std::min(i1 + 1, (int)mSize - 1);
    146 
    147     LOG_ALWAYS_FATAL_IF(
    148             i1 < 0 || i2 < 0,
    149             "negatives in interpolation!"
    150             " i1=%d, i2=%d, input=%f, lutpos=%f, size=%zu, values=%p, ipart=%f, weight=%f",
    151             i1, i2, input, lutpos, mSize, mValues.get(), ipart, weight);
    152 
    153     float v1 = mValues[i1];
    154     float v2 = mValues[i2];
    155 
    156     return MathUtils::lerp(v1, v2, weight);
    157 }
    158 
    159 } /* namespace uirenderer */
    160 } /* namespace android */
    161