Patch by James Robinson <jamesr@chromium.org> on 2011-07-13
[WebKit-https.git] / Source / WebCore / platform / graphics / chromium / LayerTilerChromium.h
1 /*
2  * Copyright (C) 2010 Google Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer.
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
16  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
18  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
19  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
20  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
21  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26
27 #ifndef LayerTilerChromium_h
28 #define LayerTilerChromium_h
29
30 #if USE(ACCELERATED_COMPOSITING)
31
32 #include "LayerChromium.h"
33 #include "LayerTexture.h"
34 #include "LayerTextureUpdater.h"
35 #include "TilingData.h"
36 #include <wtf/HashTraits.h>
37 #include <wtf/RefCounted.h>
38
39 namespace WebCore {
40
41 class GraphicsContext3D;
42 class LayerRendererChromium;
43 class LayerTextureUpdater;
44
45 class LayerTilerChromium {
46     WTF_MAKE_NONCOPYABLE(LayerTilerChromium);
47 public:
48     enum BorderTexelOption { HasBorderTexels, NoBorderTexels };
49
50     static PassOwnPtr<LayerTilerChromium> create(LayerRendererChromium*, const IntSize& tileSize, BorderTexelOption);
51
52     ~LayerTilerChromium();
53
54     // Set invalidations to be potentially repainted during update().
55     void invalidateRect(const IntRect& contentRect);
56     void invalidateEntireLayer();
57
58     // Prepare data needed to update textures that instersect with contentRect.
59     void prepareToUpdate(const IntRect& contentRect, LayerTextureUpdater*);
60     // Update invalid textures that intersect with contentRect provided in prepareToUpdate().
61     void updateRect(LayerTextureUpdater*);
62     // Draw all tiles that intersect with the content rect.
63     void draw(const IntRect& contentRect, const TransformationMatrix&, float opacity);
64
65     int numTiles() const { return m_tilingData.numTiles(); }
66
67     // Set position of this tiled layer in content space.
68     void setLayerPosition(const IntPoint& position);
69     // Change the tile size.  This may invalidate all the existing tiles.
70     void setTileSize(const IntSize& size);
71
72     bool skipsDraw() const { return m_skipsDraw; }
73
74     // Reserves all existing and valid tile textures to protect them from being
75     // recycled by the texture manager.
76     void protectTileTextures(const IntRect& contentRect);
77
78     typedef ProgramBinding<VertexShaderPosTexTransform, FragmentShaderRGBATexAlpha> Program;
79     // Shader program that swaps red and blue components of texture.
80     // Used when texture format does not match native color format.
81     typedef ProgramBinding<VertexShaderPosTexTransform, FragmentShaderRGBATexSwizzleAlpha> ProgramSwizzle;
82
83     // If this tiler has exactly one tile, return its texture. Otherwise, null.
84     LayerTexture* getSingleTexture();
85
86 private:
87     LayerTilerChromium(LayerRendererChromium*, const IntSize& tileSize, BorderTexelOption);
88
89     class Tile : public RefCounted<Tile> {
90         WTF_MAKE_NONCOPYABLE(Tile);
91     public:
92         explicit Tile(PassOwnPtr<LayerTexture> tex) : m_tex(tex), m_i(-1), m_j(-1) { }
93
94         LayerTexture* texture() { return m_tex.get(); }
95
96         bool dirty() const { return !m_dirtyLayerRect.isEmpty(); }
97         void clearDirty() { m_dirtyLayerRect = IntRect(); }
98
99         int i() const { return m_i; }
100         int j() const { return m_j; }
101         void moveTo(int i, int j) { m_i = i; m_j = j; }
102
103         // Layer-space dirty rectangle that needs to be repainted.
104         IntRect m_dirtyLayerRect;
105     private:
106         OwnPtr<LayerTexture> m_tex;
107         int m_i;
108         int m_j;
109     };
110
111     // Draw all tiles that intersect with contentRect.
112     template <class T>
113     void drawTiles(const IntRect& contentRect, const TransformationMatrix&, float opacity, const T* program);
114
115     template <class T>
116     void drawTexturedQuad(GraphicsContext3D*, const FloatQuad&, const TransformationMatrix& projectionMatrix, const TransformationMatrix& drawMatrix,
117                           float width, float height, float opacity,
118                           float texTranslateX, float texTranslateY,
119                           float texScaleX, float texScaleY,
120                           const T* program);
121
122     // Grow layer size to contain this rectangle.
123     void growLayerToContain(const IntRect& contentRect);
124
125     LayerRendererChromium* layerRenderer() const { return m_layerRenderer; }
126     GraphicsContext3D* layerRendererContext() const;
127     Tile* createTile(int i, int j);
128     // Invalidate any tiles which do not intersect with the contentRect
129     void invalidateTiles(const IntRect& contentRect);
130     void reset();
131     void contentRectToTileIndices(const IntRect& contentRect, int &left, int &top, int &right, int &bottom) const;
132     IntRect contentRectToLayerRect(const IntRect& contentRect) const;
133     IntRect layerRectToContentRect(const IntRect& layerRect) const;
134
135     Tile* tileAt(int, int) const;
136     IntRect tileContentRect(const Tile*) const;
137     IntRect tileLayerRect(const Tile*) const;
138     IntRect tileTexRect(const Tile*) const;
139
140     GC3Denum m_textureFormat;
141
142     IntSize m_tileSize;
143     IntPoint m_layerPosition;
144
145     bool m_skipsDraw;
146
147     // Default hash key traits for integers disallow 0 and -1 as a key, so
148     // use a custom hash trait which disallows -1 and -2 instead.
149     typedef std::pair<int, int> TileMapKey;
150     struct TileMapKeyTraits : HashTraits<TileMapKey> {
151         static const bool emptyValueIsZero = false;
152         static const bool needsDestruction = false;
153         static TileMapKey emptyValue() { return std::make_pair(-1, -1); }
154         static void constructDeletedValue(TileMapKey& slot) { slot = std::make_pair(-2, -2); }
155         static bool isDeletedValue(TileMapKey value) { return value.first == -2 && value.second == -2; }
156     };
157     // FIXME: The mapped value in TileMap should really be an OwnPtr, as the
158     // refcount of a Tile should never be more than 1. However, HashMap
159     // doesn't easily support OwnPtr as a value.
160     typedef HashMap<TileMapKey, RefPtr<Tile>, DefaultHash<TileMapKey>::Hash, TileMapKeyTraits> TileMap;
161     TileMap m_tiles;
162     // Tightly packed set of unused tiles.
163     Vector<RefPtr<Tile> > m_unusedTiles;
164
165     // State held between update and upload.
166     IntRect m_paintRect;
167     IntRect m_updateRect;
168
169     LayerTextureUpdater::Orientation m_textureOrientation;
170     LayerTextureUpdater::SampledTexelFormat m_sampledTexelFormat;
171     TilingData m_tilingData;
172
173     LayerRendererChromium* m_layerRenderer;
174 };
175
176 }
177
178 #endif // USE(ACCELERATED_COMPOSITING)
179
180 #endif