DamageAccumulator.h revision 25fbb3fa1138675379102a44405852555cefccbd 
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
27namespace android {
28namespace uirenderer {
29
30struct DirtyStack;
31class RenderNode;
32class Matrix4;
33
34class IDamageAccumulator {
35public:
36    virtual void pushTransform(const RenderNode* transform) = 0;
37    virtual void pushTransform(const Matrix4* transform) = 0;
38    virtual void pushNullTransform() = 0;
39    virtual void popTransform() = 0;
40    virtual void dirty(float left, float top, float right, float bottom) = 0;
41    virtual void peekAtDirty(SkRect* dest) = 0;
42protected:
43    virtual ~IDamageAccumulator() {}
44};
45
46class DamageAccumulator : public IDamageAccumulator {
47    PREVENT_COPY_AND_ASSIGN(DamageAccumulator);
48public:
49    DamageAccumulator();
50    // mAllocator will clean everything up for us, no need for a dtor
51
52    // Push a transform node onto the stack. This should be called prior
53    // to any dirty() calls. Subsequent calls to dirty()
54    // will be affected by the transform when popTransform() is called.
55    virtual void pushTransform(const RenderNode* transform);
56    virtual void pushTransform(const Matrix4* transform);
57    // This is used in combination with peekAtDirty to inspect the damage
58    // area of a subtree
59    virtual void pushNullTransform();
60
61    // Pops a transform node from the stack, propagating the dirty rect
62    // up to the parent node. Returns the IDamageTransform that was just applied
63    virtual void popTransform();
64
65    virtual void dirty(float left, float top, float right, float bottom);
66
67    // Returns the current dirty area, *NOT* transformed by pushed transforms
68    virtual void peekAtDirty(SkRect* dest);
69
70    void finish(SkRect* totalDirty);
71
72private:
73    void pushCommon();
74    void applyMatrix4Transform(DirtyStack* frame);
75    void applyRenderNodeTransform(DirtyStack* frame);
76
77    LinearAllocator mAllocator;
78    DirtyStack* mHead;
79};
80
81class NullDamageAccumulator : public IDamageAccumulator {
82    PREVENT_COPY_AND_ASSIGN(NullDamageAccumulator);
83public:
84    virtual void pushTransform(const RenderNode* transform) { }
85    virtual void pushTransform(const Matrix4* transform) { }
86    virtual void pushNullTransform() { }
87    virtual void popTransform() { }
88    virtual void dirty(float left, float top, float right, float bottom) { }
89    virtual void peekAtDirty(SkRect* dest) { dest->setEmpty(); }
90
91    ANDROID_API static NullDamageAccumulator* instance();
92
93private:
94    NullDamageAccumulator() {}
95    ~NullDamageAccumulator() {}
96
97    static NullDamageAccumulator sInstance;
98};
99
100} /* namespace uirenderer */
101} /* namespace android */
102
103#endif /* DAMAGEACCUMULATOR_H */
104