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 #ifndef DAMAGEACCUMULATOR_H
     17 #define DAMAGEACCUMULATOR_H
     18 
     19 #include <cutils/compiler.h>
     20 #include <utils/LinearAllocator.h>
     21 
     22 #include <SkMatrix.h>
     23 #include <SkRect.h>
     24 
     25 #include "utils/Macros.h"
     26 
     27 // Smaller than INT_MIN/INT_MAX because we offset these values
     28 // and thus don't want to be adding offsets to INT_MAX, that's bad
     29 #define DIRTY_MIN (-0x7ffffff-1)
     30 #define DIRTY_MAX (0x7ffffff)
     31 
     32 namespace android {
     33 namespace uirenderer {
     34 
     35 struct DirtyStack;
     36 class RenderNode;
     37 class Matrix4;
     38 
     39 class DamageAccumulator {
     40     PREVENT_COPY_AND_ASSIGN(DamageAccumulator);
     41 public:
     42     DamageAccumulator();
     43     // mAllocator will clean everything up for us, no need for a dtor
     44 
     45     // Push a transform node onto the stack. This should be called prior
     46     // to any dirty() calls. Subsequent calls to dirty()
     47     // will be affected by the transform when popTransform() is called.
     48     void pushTransform(const RenderNode* transform);
     49     void pushTransform(const Matrix4* transform);
     50 
     51     // Pops a transform node from the stack, propagating the dirty rect
     52     // up to the parent node. Returns the IDamageTransform that was just applied
     53     void popTransform();
     54 
     55     void dirty(float left, float top, float right, float bottom);
     56 
     57     // Returns the current dirty area, *NOT* transformed by pushed transforms
     58     void peekAtDirty(SkRect* dest) const;
     59 
     60     ANDROID_API void computeCurrentTransform(Matrix4* outMatrix) const;
     61 
     62     void finish(SkRect* totalDirty);
     63 
     64 private:
     65     void pushCommon();
     66     void applyMatrix4Transform(DirtyStack* frame);
     67     void applyRenderNodeTransform(DirtyStack* frame);
     68 
     69     LinearAllocator mAllocator;
     70     DirtyStack* mHead;
     71 };
     72 
     73 } /* namespace uirenderer */
     74 } /* namespace android */
     75 
     76 #endif /* DAMAGEACCUMULATOR_H */
     77