42407fb428fb04ebd0b6208daf56a7387accbb31
[WebKit-https.git] / Source / WebCore / platform / graphics / texmap / TextureMapperGL.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 TextureMapperGL_h
21 #define TextureMapperGL_h
22
23 #if USE(TEXTURE_MAPPER)
24
25 #include "FilterOperation.h"
26 #include "FloatQuad.h"
27 #include "GraphicsContext3D.h"
28 #include "IntSize.h"
29 #include "TextureMapper.h"
30 #include "TransformationMatrix.h"
31
32 namespace WebCore {
33
34 struct TextureMapperGLData;
35 class TextureMapperShaderProgram;
36 class FilterOperation;
37
38 // An OpenGL-ES2 implementation of TextureMapper.
39 class TextureMapperGL : public TextureMapper {
40 public:
41     TextureMapperGL();
42     virtual ~TextureMapperGL();
43
44     enum Flag {
45         ShouldBlend = 0x01,
46         ShouldFlipTexture = 0x02,
47         ShouldUseARBTextureRect = 0x04,
48         ShouldAntialias = 0x08
49     };
50
51     typedef int Flags;
52
53     // TextureMapper implementation
54     virtual void drawBorder(const Color&, float borderWidth, const FloatRect&, const TransformationMatrix&) override;
55     virtual void drawNumber(int number, const Color&, const FloatPoint&, const TransformationMatrix&) override;
56     virtual void drawTexture(const BitmapTexture&, const FloatRect&, const TransformationMatrix&, float opacity, unsigned exposedEdges) override;
57     virtual void drawTexture(Platform3DObject texture, Flags, const IntSize& textureSize, const FloatRect& targetRect, const TransformationMatrix& modelViewMatrix, float opacity, unsigned exposedEdges = AllEdges);
58     virtual void drawSolidColor(const FloatRect&, const TransformationMatrix&, const Color&) override;
59
60     virtual void bindSurface(BitmapTexture* surface) override;
61     virtual void beginClip(const TransformationMatrix&, const FloatRect&) override;
62     virtual void beginPainting(PaintFlags = 0) override;
63     virtual void endPainting() override;
64     virtual void endClip() override;
65     virtual IntRect clipBounds() override;
66     virtual IntSize maxTextureSize() const override { return IntSize(2000, 2000); }
67     virtual PassRefPtr<BitmapTexture> createTexture() override;
68     inline GraphicsContext3D* graphicsContext3D() const { return m_context3D.get(); }
69
70     void drawFiltered(const BitmapTexture& sourceTexture, const BitmapTexture* contentTexture, const FilterOperation&, int pass);
71
72     void setEnableEdgeDistanceAntialiasing(bool enabled) { m_enableEdgeDistanceAntialiasing = enabled; }
73
74 private:
75     struct ClipState {
76         IntRect scissorBox;
77         int stencilIndex;
78         ClipState(const IntRect& scissors = IntRect(), int stencil = 1)
79             : scissorBox(scissors)
80             , stencilIndex(stencil)
81         { }
82     };
83
84     class ClipStack {
85     public:
86         ClipStack()
87             : clipStateDirty(false)
88         { }
89
90         // Y-axis should be inverted only when painting into the window.
91         enum YAxisMode {
92             DefaultYAxis,
93             InvertedYAxis
94         };
95
96         void push();
97         void pop();
98         void apply(GraphicsContext3D*);
99         void applyIfNeeded(GraphicsContext3D*);
100         inline ClipState& current() { return clipState; }
101         void reset(const IntRect&, YAxisMode);
102         void intersect(const IntRect&);
103         void setStencilIndex(int);
104         inline int getStencilIndex() const
105         {
106             return clipState.stencilIndex;
107         }
108         inline bool isCurrentScissorBoxEmpty() const
109         {
110             return clipState.scissorBox.isEmpty();
111         }
112
113     private:
114         ClipState clipState;
115         Vector<ClipState> clipStack;
116         bool clipStateDirty;
117         IntSize size;
118         YAxisMode yAxisMode;
119     };
120
121     void drawTexturedQuadWithProgram(TextureMapperShaderProgram*, uint32_t texture, Flags, const IntSize&, const FloatRect&, const TransformationMatrix& modelViewMatrix, float opacity);
122     void draw(const FloatRect&, const TransformationMatrix& modelViewMatrix, TextureMapperShaderProgram*, GC3Denum drawingMode, Flags);
123
124     void drawUnitRect(TextureMapperShaderProgram*, GC3Denum drawingMode);
125     void drawEdgeTriangles(TextureMapperShaderProgram*);
126
127     bool beginScissorClip(const TransformationMatrix&, const FloatRect&);
128     void bindDefaultSurface();
129     ClipStack& clipStack();
130     inline TextureMapperGLData& data() { return *m_data; }
131     RefPtr<GraphicsContext3D> m_context3D;
132     TextureMapperGLData* m_data;
133     ClipStack m_clipStack;
134     bool m_enableEdgeDistanceAntialiasing;
135
136     friend class BitmapTextureGL;
137 };
138
139 class BitmapTextureGL : public BitmapTexture {
140 public:
141     virtual IntSize size() const;
142     virtual bool isValid() const;
143     virtual bool canReuseWith(const IntSize& contentsSize, Flags = 0);
144     virtual void didReset();
145     void bind(TextureMapperGL*);
146     void initializeStencil();
147     void initializeDepthBuffer();
148     ~BitmapTextureGL();
149     virtual uint32_t id() const { return m_id; }
150     uint32_t textureTarget() const { return GraphicsContext3D::TEXTURE_2D; }
151     IntSize textureSize() const { return m_textureSize; }
152     void updateContents(Image*, const IntRect&, const IntPoint&, UpdateContentsFlag);
153     virtual void updateContents(const void*, const IntRect& target, const IntPoint& sourceOffset, int bytesPerLine, UpdateContentsFlag);
154     virtual bool isBackedByOpenGL() const { return true; }
155
156     virtual PassRefPtr<BitmapTexture> applyFilters(TextureMapper*, const FilterOperations&) override;
157     struct FilterInfo {
158         RefPtr<FilterOperation> filter;
159         unsigned pass;
160         RefPtr<BitmapTexture> contentTexture;
161
162         FilterInfo(PassRefPtr<FilterOperation> f = 0, unsigned p = 0, PassRefPtr<BitmapTexture> t = 0)
163             : filter(f)
164             , pass(p)
165             , contentTexture(t)
166             { }
167     };
168     const FilterInfo* filterInfo() const { return &m_filterInfo; }
169
170 private:
171     void updateContentsNoSwizzle(const void*, const IntRect& target, const IntPoint& sourceOffset, int bytesPerLine, unsigned bytesPerPixel = 4, Platform3DObject glFormat = GraphicsContext3D::RGBA);
172
173     Platform3DObject m_id;
174     IntSize m_textureSize;
175     IntRect m_dirtyRect;
176     Platform3DObject m_fbo;
177     Platform3DObject m_rbo;
178     Platform3DObject m_depthBufferObject;
179     bool m_shouldClear;
180     TextureMapperGL::ClipStack m_clipStack;
181     RefPtr<GraphicsContext3D> m_context3D;
182
183     explicit BitmapTextureGL(TextureMapperGL*);
184     BitmapTextureGL();
185
186     void clearIfNeeded();
187     void createFboIfNeeded();
188
189     FilterInfo m_filterInfo;
190
191     friend class TextureMapperGL;
192 };
193
194 BitmapTextureGL* toBitmapTextureGL(BitmapTexture*);
195
196 }
197 #endif
198
199 #endif