Fix the TextureMapper build for GTK+.
[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
28 #if defined(QT_OPENGL_LIB) || (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
29     #if defined(QT_OPENGL_ES_2) && !defined(TEXMAP_OPENGL_ES_2)
30         #define TEXMAP_OPENGL_ES_2
31     #endif
32 #endif
33 #endif
34
35 #include "FilterOperations.h"
36 #include "GraphicsContext.h"
37 #include "IntRect.h"
38 #include "IntSize.h"
39 #include "TextureMapperPlatformLayer.h"
40 #include "TransformationMatrix.h"
41 #include <wtf/UnusedParam.h>
42
43 /*
44     TextureMapper is a mechanism that enables hardware acceleration of CSS animations (accelerated compositing) without
45     a need for a platform specific scene-graph library like CoreAnimations or QGraphicsView.
46 */
47
48 namespace WebCore {
49
50 class TextureMapper;
51
52 // A 2D texture that can be the target of software or GL rendering.
53 class BitmapTexture  : public RefCounted<BitmapTexture> {
54 public:
55     enum PixelFormat { BGRAFormat, RGBAFormat, BGRFormat, RGBFormat };
56     enum Flag {
57         SupportsAlpha = 0x01
58     };
59
60     typedef unsigned Flags;
61
62     BitmapTexture()
63         : m_flags(0)
64     {
65     }
66
67     virtual ~BitmapTexture() { }
68
69     virtual IntSize size() const = 0;
70     virtual void updateContents(Image*, const IntRect&, const IntRect&, BitmapTexture::PixelFormat) = 0;
71     virtual void updateContents(const void*, const IntRect&) = 0;
72     virtual bool isValid() const = 0;
73     inline Flags flags() const { return m_flags; }
74
75     virtual int bpp() const { return 32; }
76     virtual void didReset() { }
77     void reset(const IntSize& size, Flags flags)
78     {
79         m_flags = flags;
80         m_contentSize = size;
81         didReset();
82     }
83
84     inline IntSize contentSize() const { return m_contentSize; }
85     inline int numberOfBytes() const { return size().width() * size().height() * bpp() >> 3; }
86     inline bool isOpaque() const { return !(m_flags & SupportsAlpha); }
87
88 #if ENABLE(CSS_FILTERS)
89     virtual void applyFilters(const BitmapTexture& contentTexture, const FilterOperations&) { }
90 #endif
91
92 protected:
93     IntSize m_contentSize;
94
95 private:
96     Flags m_flags;
97 };
98
99 // A "context" class used to encapsulate accelerated texture mapping functions: i.e. drawing a texture
100 // onto the screen or into another texture with a specified transform, opacity and mask.
101 class TextureMapper {
102     friend class BitmapTexture;
103
104 public:
105     enum AccelerationMode { SoftwareMode, OpenGLMode };
106     static PassOwnPtr<TextureMapper> create(AccelerationMode newMode = SoftwareMode);
107     virtual ~TextureMapper() { }
108
109     virtual void drawTexture(const BitmapTexture&, const FloatRect& target, const TransformationMatrix& modelViewMatrix = TransformationMatrix(), float opacity = 1.0f, const BitmapTexture* maskTexture = 0) = 0;
110
111     // makes a surface the target for the following drawTexture calls.
112     virtual void bindSurface(BitmapTexture* surface) = 0;
113     virtual void setGraphicsContext(GraphicsContext* context) { m_context = context; }
114     virtual GraphicsContext* graphicsContext() { return m_context; }
115     virtual void beginClip(const TransformationMatrix&, const FloatRect&) = 0;
116     virtual void endClip() = 0;
117     virtual PassRefPtr<BitmapTexture> createTexture() = 0;
118
119     void setImageInterpolationQuality(InterpolationQuality quality) { m_interpolationQuality = quality; }
120     void setTextDrawingMode(TextDrawingModeFlags mode) { m_textDrawingMode = mode; }
121
122     InterpolationQuality imageInterpolationQuality() const { return m_interpolationQuality; }
123     TextDrawingModeFlags textDrawingMode() const { return m_textDrawingMode; }
124     virtual AccelerationMode accelerationMode() const = 0;
125
126     virtual void beginPainting() { }
127     virtual void endPainting() { }
128
129     virtual IntSize maxTextureSize() const { return IntSize(INT_MAX, INT_MAX); }
130
131     // A surface is released implicitly when dereferenced.
132     virtual PassRefPtr<BitmapTexture> acquireTextureFromPool(const IntSize&);
133
134 protected:
135     TextureMapper()
136         : m_interpolationQuality(InterpolationDefault)
137         , m_textDrawingMode(TextModeFill)
138     {}
139
140 private:
141 #if USE(TEXTURE_MAPPER_GL)
142     static PassOwnPtr<TextureMapper> platformCreateAccelerated();
143 #else
144     static PassOwnPtr<TextureMapper> platformCreateAccelerated()
145     {
146         return PassOwnPtr<TextureMapper>();
147     }
148 #endif
149     InterpolationQuality m_interpolationQuality;
150     TextDrawingModeFlags m_textDrawingMode;
151     Vector<RefPtr<BitmapTexture> > m_texturePool;
152     GraphicsContext* m_context;
153 };
154
155 }
156
157 #endif
158
159 #endif