cc/render_surface_impl.h


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

// Copyright 2011 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef CC_RENDER_SURFACE_IMPL_H_
#define CC_RENDER_SURFACE_IMPL_H_

#include "base/basictypes.h"
#include "base/memory/scoped_ptr.h"
#include "cc/cc_export.h"
#include "cc/render_pass.h"
#include "cc/shared_quad_state.h"
#include "ui/gfx/rect.h"
#include "ui/gfx/rect_f.h"
#include "ui/gfx/transform.h"

namespace cc {

class DamageTracker;
class DelegatedRendererLayerImpl;
class QuadSink;
class RenderPassSink;
class LayerImpl;

struct AppendQuadsData;

class CC_EXPORT RenderSurfaceImpl {
public:
    explicit RenderSurfaceImpl(LayerImpl*);
    virtual ~RenderSurfaceImpl();

    std::string name() const;
    void dumpSurface(std::string*, int indent) const;

    gfx::PointF contentRectCenter() const { return gfx::RectF(m_contentRect).CenterPoint(); }

    // Returns the rect that encloses the RenderSurfaceImpl including any reflection.
    gfx::RectF drawableContentRect() const;

    float drawOpacity() const { return m_drawOpacity; }
    void setDrawOpacity(float opacity) { m_drawOpacity = opacity; }

    void setNearestAncestorThatMovesPixels(RenderSurfaceImpl* surface) { m_nearestAncestorThatMovesPixels = surface; }
    const RenderSurfaceImpl* nearestAncestorThatMovesPixels() const { return m_nearestAncestorThatMovesPixels; }

    bool drawOpacityIsAnimating() const { return m_drawOpacityIsAnimating; }
    void setDrawOpacityIsAnimating(bool drawOpacityIsAnimating) { m_drawOpacityIsAnimating = drawOpacityIsAnimating; }

    void setDrawTransform(const gfx::Transform& drawTransform) { m_drawTransform = drawTransform; }
    const gfx::Transform& drawTransform() const { return m_drawTransform; }

    void setScreenSpaceTransform(const gfx::Transform& screenSpaceTransform) { m_screenSpaceTransform = screenSpaceTransform; }
    const gfx::Transform& screenSpaceTransform() const { return m_screenSpaceTransform; }

    void setReplicaDrawTransform(const gfx::Transform& replicaDrawTransform) { m_replicaDrawTransform = replicaDrawTransform; }
    const gfx::Transform& replicaDrawTransform() const { return m_replicaDrawTransform; }

    void setReplicaScreenSpaceTransform(const gfx::Transform& replicaScreenSpaceTransform) { m_replicaScreenSpaceTransform = replicaScreenSpaceTransform; }
    const gfx::Transform& replicaScreenSpaceTransform() const { return m_replicaScreenSpaceTransform; }

    bool targetSurfaceTransformsAreAnimating() const { return m_targetSurfaceTransformsAreAnimating; }
    void setTargetSurfaceTransformsAreAnimating(bool animating) { m_targetSurfaceTransformsAreAnimating = animating; }
    bool screenSpaceTransformsAreAnimating() const { return m_screenSpaceTransformsAreAnimating; }
    void setScreenSpaceTransformsAreAnimating(bool animating) { m_screenSpaceTransformsAreAnimating = animating; }

    void setIsClipped(bool isClipped) { m_isClipped = isClipped; }
    bool isClipped() const { return m_isClipped; }

    void setClipRect(const gfx::Rect&);
    const gfx::Rect& clipRect() const { return m_clipRect; }

    bool contentsChanged() const;

    void setContentRect(const gfx::Rect&);
    const gfx::Rect& contentRect() const { return m_contentRect; }

    std::vector<LayerImpl*>& layerList() { return m_layerList; }
    void addContributingDelegatedRenderPassLayer(LayerImpl*);
    void clearLayerLists();

    int owningLayerId() const;

    void resetPropertyChangedFlag() { m_surfacePropertyChanged = false; }
    bool surfacePropertyChanged() const;
    bool surfacePropertyChangedOnlyFromDescendant() const;

    DamageTracker* damageTracker() const { return m_damageTracker.get(); }

    RenderPass::Id renderPassId();

    void appendRenderPasses(RenderPassSink&);
    void appendQuads(QuadSink&, AppendQuadsData&, bool forReplica, RenderPass::Id renderPassId);

private:
    LayerImpl* m_owningLayer;

    // Uses this surface's space.
    gfx::Rect m_contentRect;
    bool m_surfacePropertyChanged;

    float m_drawOpacity;
    bool m_drawOpacityIsAnimating;
    gfx::Transform m_drawTransform;
    gfx::Transform m_screenSpaceTransform;
    gfx::Transform m_replicaDrawTransform;
    gfx::Transform m_replicaScreenSpaceTransform;
    bool m_targetSurfaceTransformsAreAnimating;
    bool m_screenSpaceTransformsAreAnimating;

    bool m_isClipped;

    // Uses the space of the surface's target surface.
    gfx::Rect m_clipRect;

    std::vector<LayerImpl*> m_layerList;
    std::vector<DelegatedRendererLayerImpl*> m_contributingDelegatedRenderPassLayerList;

    // The nearest ancestor target surface that will contain the contents of this surface, and that is going
    // to move pixels within the surface (such as with a blur). This can point to itself.
    RenderSurfaceImpl* m_nearestAncestorThatMovesPixels;

    scoped_ptr<DamageTracker> m_damageTracker;

    // For LayerIteratorActions
    int m_targetRenderSurfaceLayerIndexHistory;
    int m_currentLayerIndexHistory;

    friend struct LayerIteratorActions;

    DISALLOW_COPY_AND_ASSIGN(RenderSurfaceImpl);
};

}
#endif  // CC_RENDER_SURFACE_IMPL_H_