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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
|
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ShaderProgram_h
#define ShaderProgram_h
#if USE(ACCELERATED_COMPOSITING)
#include "FloatRect.h"
#include "IntRect.h"
#include "SkRect.h"
#include "TransformationMatrix.h"
#include <GLES2/gl2.h>
#define MAX_CONTRAST 5
namespace WebCore {
class ShaderProgram {
public:
ShaderProgram();
void init();
int program() { return m_program; }
// Drawing
void setViewport(SkRect& viewport, float scale);
float zValue(const TransformationMatrix& drawMatrix, float w, float h);
// For drawQuad and drawLayerQuad, they can handle 3 cases for now:
// 1) textureTarget == GL_TEXTURE_2D
// Normal texture in GL_TEXTURE_2D target.
// 2) textureTarget == GL_TEXTURE_EXTERNAL_OES
// Surface texture in GL_TEXTURE_EXTERNAL_OES target.
// 3) textureTarget == 0 (Will be deprecated soon)
// Surface texture in GL_TEXTURE_2D target.
//
// TODO: Shrink the support modes into 2 (1 and 2) after media framework
// support Surface texture in GL_TEXTURE_EXTERNAL_OES target on all
// platforms.
void drawQuad(SkRect& geometry, int textureId, float opacity,
GLenum textureTarget = GL_TEXTURE_2D,
GLint texFilter = GL_LINEAR);
void drawLayerQuad(const TransformationMatrix& drawMatrix,
const SkRect& geometry, int textureId, float opacity,
bool forceBlending = false,
GLenum textureTarget = GL_TEXTURE_2D);
void drawVideoLayerQuad(const TransformationMatrix& drawMatrix,
float* textureMatrix, SkRect& geometry, int textureId);
void setViewRect(const IntRect& viewRect);
FloatRect rectInScreenCoord(const TransformationMatrix& drawMatrix,
const IntSize& size);
FloatRect rectInInvScreenCoord(const TransformationMatrix& drawMatrix,
const IntSize& size);
FloatRect rectInInvScreenCoord(const FloatRect& rect);
FloatRect rectInScreenCoord(const FloatRect& rect);
FloatRect convertScreenCoordToDocumentCoord(const FloatRect& rect);
FloatRect convertInvScreenCoordToScreenCoord(const FloatRect& rect);
FloatRect convertScreenCoordToInvScreenCoord(const FloatRect& rect);
void setTitleBarHeight(int height) { m_titleBarHeight = height; }
void setWebViewRect(const IntRect& rect) { m_webViewRect = rect; }
void setScreenClip(const IntRect& clip);
void clip(const FloatRect& rect);
IntRect clippedRectWithViewport(const IntRect& rect, int margin = 0);
FloatRect documentViewport() { return m_documentViewport; }
void resetBlending();
float contrast() { return m_contrast; }
void setContrast(float c) {
float contrast = c;
if (contrast < 0)
contrast = 0;
if (contrast > MAX_CONTRAST)
contrast = MAX_CONTRAST;
m_contrast = contrast;
}
void setWebViewMatrix(const float* matrix, bool alphaLayer);
// This delta is the delta from the layout pos and the current animation pos.
// Basically, in terms of layout, the webview is still in the original layout
// pos, as without animation. Such that the viewport and visible rect etc are
// still in that pos, too, except the clipping info.
// Our rendering approach is after applying all the matrix, webView is
// rendered as if it was at the original layout pos, but then offset the
// glViewport to match the animation.
void calculateAnimationDelta();
int getAnimationDeltaX() { return m_animationDelta.x(); }
int getAnimationDeltaY() { return m_animationDelta.y(); }
private:
GLuint loadShader(GLenum shaderType, const char* pSource);
GLuint createProgram(const char* vertexSource, const char* fragmentSource);
void setProjectionMatrix(SkRect& geometry, GLint projectionMatrixHandle);
void setBlendingState(bool enableBlending);
void drawQuadInternal(SkRect& geometry, GLint textureId, float opacity,
GLint program, GLint projectionMatrixHandle,
GLint texSampler, GLenum textureTarget,
GLint position, GLint alpha,
GLint texFilter, GLint contrast = -1);
void drawLayerQuadInternal(const GLfloat* projectionMatrix, int textureId,
float opacity, GLenum textureTarget, GLint program,
GLint matrix, GLint texSample,
GLint position, GLint alpha, GLint contrast = -1);
bool m_blendingEnabled;
int m_program;
int m_programInverted;
int m_videoProgram;
int m_surfTexOESProgram;
int m_surfTexOESProgramInverted;
TransformationMatrix m_projectionMatrix;
GLuint m_textureBuffer[1];
TransformationMatrix m_documentToScreenMatrix;
TransformationMatrix m_documentToInvScreenMatrix;
SkRect m_viewport;
IntRect m_viewRect;
FloatRect m_clipRect;
IntRect m_screenClip;
int m_titleBarHeight;
IntRect m_webViewRect;
FloatRect m_documentViewport;
// uniforms
GLint m_hProjectionMatrix;
GLint m_hAlpha;
GLint m_hTexSampler;
GLint m_hProjectionMatrixInverted;
GLint m_hAlphaInverted;
GLint m_hContrastInverted;
GLint m_hTexSamplerInverted;
GLint m_hVideoProjectionMatrix;
GLint m_hVideoTextureMatrix;
GLint m_hVideoTexSampler;
GLint m_hSTOESProjectionMatrix;
GLint m_hSTOESAlpha;
GLint m_hSTOESTexSampler;
GLint m_hSTOESPosition;
GLint m_hSTOESProjectionMatrixInverted;
GLint m_hSTOESAlphaInverted;
GLint m_hSTOESContrastInverted;
GLint m_hSTOESTexSamplerInverted;
GLint m_hSTOESPositionInverted;
float m_contrast;
// attribs
GLint m_hPosition;
GLint m_hPositionInverted;
GLint m_hVideoPosition;
bool m_alphaLayer;
TransformationMatrix m_webViewMatrix;
float m_currentScale;
// After the webViewTranform, we need to reposition the rect to match our viewport.
// Basically, the webViewTransformMatrix should apply on the screen resolution.
// So we start by doing the scale and translate to get each tile into screen coordinates.
// After applying the webViewTransformMatrix, b/c the way it currently set up
// for scroll and titlebar, we need to offset both of them.
// Finally, map everything back to (-1, 1) by using the m_projectionMatrix.
// TODO: Given that m_webViewMatrix contains most of the tranformation
// information, we should be able to get rid of some parameter we got from
// Java side and simplify our code.
TransformationMatrix m_repositionMatrix;
IntPoint m_animationDelta;
};
} // namespace WebCore
#endif // USE(ACCELERATED_COMPOSITING)
#endif // ShaderProgram_h
|
