[Texmap] Implementation for pattern compositing
[WebKit-https.git] / Source / WebCore / platform / graphics / texmap / TextureMapper.h
1 /*
2  Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
3
4  This library is free software; you can redistribute it and/or
5  modify it under the terms of the GNU Library General Public
6  License as published by the Free Software Foundation; either
7  version 2 of the License, or (at your option) any later version.
8
9  This library is distributed in the hope that it will be useful,
10  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  Library General Public License for more details.
13
14  You should have received a copy of the GNU Library General Public License
15  along with this library; see the file COPYING.LIB.  If not, write to
16  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17  Boston, MA 02110-1301, USA.
18  */
19
20 #ifndef TextureMapper_h
21 #define TextureMapper_h
22
23 #if USE(ACCELERATED_COMPOSITING)
24
25 #if PLATFORM(QT)
26 #include <qglobal.h>
27 #if defined(QT_OPENGL_ES_2) && !defined(TEXMAP_OPENGL_ES_2)
28     #define TEXMAP_OPENGL_ES_2
29 #endif
30 #endif
31 #if (PLATFORM(GTK) || PLATFORM(EFL)) && USE(OPENGL_ES_2)
32 #define TEXMAP_OPENGL_ES_2
33 #endif
34
35 #include "GraphicsContext.h"
36 #include "IntRect.h"
37 #include "IntSize.h"
38 #include "TransformationMatrix.h"
39 #include <wtf/UnusedParam.h>
40
41 /*
42     TextureMapper is a mechanism that enables hardware acceleration of CSS animations (accelerated compositing) without
43     a need for a platform specific scene-graph library like CoreAnimations or QGraphicsView.
44 */
45
46 namespace WebCore {
47
48 class BitmapTexturePool;
49 class CustomFilterProgram;
50 class GraphicsLayer;
51 class TextureMapper;
52 class FilterOperations;
53
54 // A 2D texture that can be the target of software or GL rendering.
55 class BitmapTexture : public RefCounted<BitmapTexture> {
56 public:
57     enum Flag {
58         SupportsAlpha = 0x01
59     };
60
61     enum UpdateContentsFlag {
62         UpdateCanModifyOriginalImageData,
63         UpdateCannotModifyOriginalImageData
64     };
65
66     typedef unsigned Flags;
67
68     BitmapTexture()
69         : m_flags(0)
70     {
71     }
72
73     virtual ~BitmapTexture() { }
74     virtual bool isBackedByOpenGL() const { return false; }
75
76     virtual IntSize size() const = 0;
77     virtual void updateContents(Image*, const IntRect&, const IntPoint& offset, UpdateContentsFlag) = 0;
78     virtual void updateContents(TextureMapper*, GraphicsLayer*, const IntRect& target, const IntPoint& offset, UpdateContentsFlag);
79     virtual void updateContents(const void*, const IntRect& target, const IntPoint& offset, int bytesPerLine, UpdateContentsFlag) = 0;
80     virtual bool isValid() const = 0;
81     inline Flags flags() const { return m_flags; }
82
83     virtual int bpp() const { return 32; }
84     virtual bool canReuseWith(const IntSize& /* contentsSize */, Flags = 0) { return false; }
85     void reset(const IntSize& size, Flags flags = 0)
86     {
87         m_flags = flags;
88         m_contentSize = size;
89         didReset();
90     }
91     virtual void didReset() { }
92
93     inline IntSize contentSize() const { return m_contentSize; }
94     inline int numberOfBytes() const { return size().width() * size().height() * bpp() >> 3; }
95     inline bool isOpaque() const { return !(m_flags & SupportsAlpha); }
96
97 #if ENABLE(CSS_FILTERS)
98     virtual PassRefPtr<BitmapTexture> applyFilters(TextureMapper*, const BitmapTexture& contentTexture, const FilterOperations&) { return this; }
99 #endif
100
101 protected:
102     IntSize m_contentSize;
103
104 private:
105     Flags m_flags;
106 };
107
108 // A "context" class used to encapsulate accelerated texture mapping functions: i.e. drawing a texture
109 // onto the screen or into another texture with a specified transform, opacity and mask.
110 class TextureMapper {
111     WTF_MAKE_FAST_ALLOCATED;
112     friend class BitmapTexture;
113 public:
114     enum AccelerationMode { SoftwareMode, OpenGLMode };
115     enum PaintFlag {
116         PaintingMirrored = 1 << 0,
117     };
118
119     enum WrapMode {
120         StretchWrap,
121         RepeatWrap
122     };
123
124     typedef unsigned PaintFlags;
125
126     static PassOwnPtr<TextureMapper> create(AccelerationMode newMode = SoftwareMode);
127     virtual ~TextureMapper();
128
129     enum ExposedEdges {
130         NoEdges = 0,
131         LeftEdge = 1 << 0,
132         RightEdge = 1 << 1,
133         TopEdge = 1 << 2,
134         BottomEdge = 1 << 3,
135         AllEdges = LeftEdge | RightEdge | TopEdge | BottomEdge,
136     };
137
138     virtual void drawBorder(const Color&, float borderWidth, const FloatRect&, const TransformationMatrix&) = 0;
139     virtual void drawNumber(int number, const Color&, const FloatPoint&, const TransformationMatrix&) = 0;
140
141     virtual void drawTexture(const BitmapTexture&, const FloatRect& target, const TransformationMatrix& modelViewMatrix = TransformationMatrix(), float opacity = 1.0f, unsigned exposedEdges = AllEdges) = 0;
142     virtual void drawSolidColor(const FloatRect&, const TransformationMatrix&, const Color&) = 0;
143
144     // makes a surface the target for the following drawTexture calls.
145     virtual void bindSurface(BitmapTexture* surface) = 0;
146     void setGraphicsContext(GraphicsContext* context) { m_context = context; }
147     GraphicsContext* graphicsContext() { return m_context; }
148     virtual void beginClip(const TransformationMatrix&, const FloatRect&) = 0;
149     virtual void endClip() = 0;
150     virtual PassRefPtr<BitmapTexture> createTexture() = 0;
151
152     void setImageInterpolationQuality(InterpolationQuality quality) { m_interpolationQuality = quality; }
153     void setTextDrawingMode(TextDrawingModeFlags mode) { m_textDrawingMode = mode; }
154
155     InterpolationQuality imageInterpolationQuality() const { return m_interpolationQuality; }
156     TextDrawingModeFlags textDrawingMode() const { return m_textDrawingMode; }
157     AccelerationMode accelerationMode() const { return m_accelerationMode; }
158
159     virtual void beginPainting(PaintFlags = 0) { }
160     virtual void endPainting() { }
161
162     void setMaskMode(bool m) { m_isMaskMode = m; }
163
164     virtual IntSize maxTextureSize() const = 0;
165
166     virtual PassRefPtr<BitmapTexture> acquireTextureFromPool(const IntSize&);
167
168 #if ENABLE(CSS_SHADERS)
169     virtual void removeCachedCustomFilterProgram(CustomFilterProgram*) { }
170 #endif
171
172     void setPatternTransform(const TransformationMatrix& p) { m_patternTransform = p; }
173     void setWrapMode(WrapMode m) { m_wrapMode = m; }
174
175 protected:
176     explicit TextureMapper(AccelerationMode);
177
178     GraphicsContext* m_context;
179
180     bool isInMaskMode() const { return m_isMaskMode; }
181     WrapMode wrapMode() const { return m_wrapMode; }
182     const TransformationMatrix& patternTransform() const { return m_patternTransform; }
183
184 private:
185 #if USE(TEXTURE_MAPPER_GL)
186     static PassOwnPtr<TextureMapper> platformCreateAccelerated();
187 #else
188     static PassOwnPtr<TextureMapper> platformCreateAccelerated()
189     {
190         return PassOwnPtr<TextureMapper>();
191     }
192 #endif
193     InterpolationQuality m_interpolationQuality;
194     TextDrawingModeFlags m_textDrawingMode;
195     OwnPtr<BitmapTexturePool> m_texturePool;
196     AccelerationMode m_accelerationMode;
197     bool m_isMaskMode;
198     TransformationMatrix m_patternTransform;
199     WrapMode m_wrapMode;
200 };
201
202 }
203
204 #endif
205
206 #endif