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
|
/*
* 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 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 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);
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;
}
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;
// 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;
};
} // namespace WebCore
#endif // USE(ACCELERATED_COMPOSITING)
#endif // ShaderProgram_h
|
