1 /**************************************************************************** |
1 /**************************************************************************** |
2 ** |
2 ** |
3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). |
3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). |
4 ** All rights reserved. |
4 ** All rights reserved. |
5 ** Contact: Nokia Corporation (qt-info@nokia.com) |
5 ** Contact: Nokia Corporation (qt-info@nokia.com) |
6 ** |
6 ** |
7 ** This file is part of the QtOpenGL module of the Qt Toolkit. |
7 ** This file is part of the QtOpenGL module of the Qt Toolkit. |
8 ** |
8 ** |
97 gl_Position.z = depth * gl_Position.w; \ |
97 gl_Position.z = depth * gl_Position.w; \ |
98 textureCoords = textureCoordArray; \ |
98 textureCoords = textureCoordArray; \ |
99 opacity = opacityArray; \ |
99 opacity = opacityArray; \ |
100 }"; |
100 }"; |
101 |
101 |
|
102 // NOTE: We let GL do the perspective correction so texture lookups in the fragment |
|
103 // shader are also perspective corrected. |
102 static const char* const qglslPositionOnlyVertexShader = "\ |
104 static const char* const qglslPositionOnlyVertexShader = "\ |
103 attribute highp vec4 vertexCoordsArray;\ |
105 attribute highp vec2 vertexCoordsArray;\ |
104 uniform highp mat4 pmvMatrix;\ |
106 uniform highp mat3 pmvMatrix;\ |
105 void setPosition(void)\ |
107 void setPosition(void)\ |
106 {\ |
108 {\ |
107 gl_Position = pmvMatrix * vertexCoordsArray;\ |
109 vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \ |
|
110 gl_Position = vec4(transformedPos.xy, 0.0, transformedPos.z); \ |
108 }"; |
111 }"; |
109 |
112 |
110 static const char* const qglslUntransformedPositionVertexShader = "\ |
113 static const char* const qglslUntransformedPositionVertexShader = "\ |
111 attribute highp vec4 vertexCoordsArray;\ |
114 attribute highp vec4 vertexCoordsArray;\ |
112 void setPosition(void)\ |
115 void setPosition(void)\ |
114 gl_Position = vertexCoordsArray;\ |
117 gl_Position = vertexCoordsArray;\ |
115 }"; |
118 }"; |
116 |
119 |
117 // Pattern Brush - This assumes the texture size is 8x8 and thus, the inverted size is 0.125 |
120 // Pattern Brush - This assumes the texture size is 8x8 and thus, the inverted size is 0.125 |
118 static const char* const qglslPositionWithPatternBrushVertexShader = "\ |
121 static const char* const qglslPositionWithPatternBrushVertexShader = "\ |
119 attribute highp vec4 vertexCoordsArray; \ |
122 attribute highp vec2 vertexCoordsArray; \ |
120 uniform highp mat4 pmvMatrix; \ |
123 uniform highp mat3 pmvMatrix; \ |
121 uniform mediump vec2 halfViewportSize; \ |
124 uniform mediump vec2 halfViewportSize; \ |
122 uniform highp vec2 invertedTextureSize; \ |
125 uniform highp vec2 invertedTextureSize; \ |
123 uniform highp mat3 brushTransform; \ |
126 uniform highp mat3 brushTransform; \ |
124 varying highp vec2 patternTexCoords; \ |
127 varying highp vec2 patternTexCoords; \ |
125 void setPosition(void) { \ |
128 void setPosition(void) { \ |
126 gl_Position = pmvMatrix * vertexCoordsArray;\ |
129 vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \ |
127 gl_Position.xy = gl_Position.xy / gl_Position.w; \ |
130 gl_Position.xy = transformedPos.xy / transformedPos.z; \ |
128 mediump vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \ |
131 mediump vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \ |
129 mediump vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1); \ |
132 mediump vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1.0); \ |
130 mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \ |
133 mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \ |
131 gl_Position.xy = gl_Position.xy * invertedHTexCoordsZ; \ |
134 gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \ |
132 gl_Position.w = invertedHTexCoordsZ; \ |
|
133 patternTexCoords.xy = (hTexCoords.xy * 0.125) * invertedHTexCoordsZ; \ |
135 patternTexCoords.xy = (hTexCoords.xy * 0.125) * invertedHTexCoordsZ; \ |
134 }"; |
136 }"; |
135 |
137 |
136 static const char* const qglslAffinePositionWithPatternBrushVertexShader |
138 static const char* const qglslAffinePositionWithPatternBrushVertexShader |
137 = qglslPositionWithPatternBrushVertexShader; |
139 = qglslPositionWithPatternBrushVertexShader; |
145 }\n"; |
147 }\n"; |
146 |
148 |
147 |
149 |
148 // Linear Gradient Brush |
150 // Linear Gradient Brush |
149 static const char* const qglslPositionWithLinearGradientBrushVertexShader = "\ |
151 static const char* const qglslPositionWithLinearGradientBrushVertexShader = "\ |
150 attribute highp vec4 vertexCoordsArray; \ |
152 attribute highp vec2 vertexCoordsArray; \ |
151 uniform highp mat4 pmvMatrix; \ |
153 uniform highp mat3 pmvMatrix; \ |
152 uniform mediump vec2 halfViewportSize; \ |
154 uniform mediump vec2 halfViewportSize; \ |
153 uniform highp vec3 linearData; \ |
155 uniform highp vec3 linearData; \ |
154 uniform highp mat3 brushTransform; \ |
156 uniform highp mat3 brushTransform; \ |
155 varying mediump float index; \ |
157 varying mediump float index; \ |
156 void setPosition() { \ |
158 void setPosition() { \ |
157 gl_Position = pmvMatrix * vertexCoordsArray;\ |
159 vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \ |
158 gl_Position.xy = gl_Position.xy / gl_Position.w; \ |
160 gl_Position.xy = transformedPos.xy / transformedPos.z; \ |
159 mediump vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \ |
161 mediump vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \ |
160 mediump vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1); \ |
162 mediump vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1); \ |
161 mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \ |
163 mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \ |
162 gl_Position.xy = gl_Position.xy * invertedHTexCoordsZ; \ |
164 gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \ |
163 gl_Position.w = invertedHTexCoordsZ; \ |
|
164 index = (dot(linearData.xy, hTexCoords.xy) * linearData.z) * invertedHTexCoordsZ; \ |
165 index = (dot(linearData.xy, hTexCoords.xy) * linearData.z) * invertedHTexCoordsZ; \ |
165 }"; |
166 }"; |
166 |
167 |
167 static const char* const qglslAffinePositionWithLinearGradientBrushVertexShader |
168 static const char* const qglslAffinePositionWithLinearGradientBrushVertexShader |
168 = qglslPositionWithLinearGradientBrushVertexShader; |
169 = qglslPositionWithLinearGradientBrushVertexShader; |
176 }\n"; |
177 }\n"; |
177 |
178 |
178 |
179 |
179 // Conical Gradient Brush |
180 // Conical Gradient Brush |
180 static const char* const qglslPositionWithConicalGradientBrushVertexShader = "\ |
181 static const char* const qglslPositionWithConicalGradientBrushVertexShader = "\ |
181 attribute highp vec4 vertexCoordsArray;\ |
182 attribute highp vec2 vertexCoordsArray;\ |
182 uniform highp mat4 pmvMatrix;\ |
183 uniform highp mat3 pmvMatrix;\ |
183 uniform mediump vec2 halfViewportSize; \ |
184 uniform mediump vec2 halfViewportSize; \ |
184 uniform highp mat3 brushTransform; \ |
185 uniform highp mat3 brushTransform; \ |
185 varying highp vec2 A; \ |
186 varying highp vec2 A; \ |
186 void setPosition(void)\ |
187 void setPosition(void)\ |
187 {\ |
188 {\ |
188 gl_Position = pmvMatrix * vertexCoordsArray;\ |
189 vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \ |
189 gl_Position.xy = gl_Position.xy / gl_Position.w; \ |
190 gl_Position.xy = transformedPos.xy / transformedPos.z; \ |
190 mediump vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \ |
191 mediump vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \ |
191 mediump vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1); \ |
192 mediump vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1); \ |
192 mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \ |
193 mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \ |
193 gl_Position.xy = gl_Position.xy * invertedHTexCoordsZ; \ |
194 gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \ |
194 gl_Position.w = invertedHTexCoordsZ; \ |
|
195 A = hTexCoords.xy * invertedHTexCoordsZ; \ |
195 A = hTexCoords.xy * invertedHTexCoordsZ; \ |
196 }"; |
196 }"; |
197 |
197 |
198 static const char* const qglslAffinePositionWithConicalGradientBrushVertexShader |
198 static const char* const qglslAffinePositionWithConicalGradientBrushVertexShader |
199 = qglslPositionWithConicalGradientBrushVertexShader; |
199 = qglslPositionWithConicalGradientBrushVertexShader; |
213 }"; |
213 }"; |
214 |
214 |
215 |
215 |
216 // Radial Gradient Brush |
216 // Radial Gradient Brush |
217 static const char* const qglslPositionWithRadialGradientBrushVertexShader = "\ |
217 static const char* const qglslPositionWithRadialGradientBrushVertexShader = "\ |
218 attribute highp vec4 vertexCoordsArray;\ |
218 attribute highp vec2 vertexCoordsArray;\ |
219 uniform highp mat4 pmvMatrix;\ |
219 uniform highp mat3 pmvMatrix;\ |
220 uniform mediump vec2 halfViewportSize; \ |
220 uniform mediump vec2 halfViewportSize; \ |
221 uniform highp mat3 brushTransform; \ |
221 uniform highp mat3 brushTransform; \ |
222 uniform highp vec2 fmp; \ |
222 uniform highp vec2 fmp; \ |
223 varying highp float b; \ |
223 varying highp float b; \ |
224 varying highp vec2 A; \ |
224 varying highp vec2 A; \ |
225 void setPosition(void) \ |
225 void setPosition(void) \ |
226 {\ |
226 {\ |
227 gl_Position = pmvMatrix * vertexCoordsArray;\ |
227 vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \ |
228 gl_Position.xy = gl_Position.xy / gl_Position.w; \ |
228 gl_Position.xy = transformedPos.xy / transformedPos.z; \ |
229 mediump vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \ |
229 mediump vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \ |
230 mediump vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1); \ |
230 mediump vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1); \ |
231 mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \ |
231 mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \ |
232 gl_Position.xy = gl_Position.xy * invertedHTexCoordsZ; \ |
232 gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \ |
233 gl_Position.w = invertedHTexCoordsZ; \ |
|
234 A = hTexCoords.xy * invertedHTexCoordsZ; \ |
233 A = hTexCoords.xy * invertedHTexCoordsZ; \ |
235 b = 2.0 * dot(A, fmp); \ |
234 b = 2.0 * dot(A, fmp); \ |
236 }"; |
235 }"; |
237 |
236 |
238 static const char* const qglslAffinePositionWithRadialGradientBrushVertexShader |
237 static const char* const qglslAffinePositionWithRadialGradientBrushVertexShader |
251 }"; |
250 }"; |
252 |
251 |
253 |
252 |
254 // Texture Brush |
253 // Texture Brush |
255 static const char* const qglslPositionWithTextureBrushVertexShader = "\ |
254 static const char* const qglslPositionWithTextureBrushVertexShader = "\ |
256 attribute highp vec4 vertexCoordsArray; \ |
255 attribute highp vec2 vertexCoordsArray; \ |
257 uniform highp mat4 pmvMatrix; \ |
256 uniform highp mat3 pmvMatrix; \ |
258 uniform mediump vec2 halfViewportSize; \ |
257 uniform mediump vec2 halfViewportSize; \ |
259 uniform highp vec2 invertedTextureSize; \ |
258 uniform highp vec2 invertedTextureSize; \ |
260 uniform highp mat3 brushTransform; \ |
259 uniform highp mat3 brushTransform; \ |
261 varying highp vec2 textureCoords; \ |
260 varying highp vec2 textureCoords; \ |
262 void setPosition(void) { \ |
261 void setPosition(void) { \ |
263 gl_Position = pmvMatrix * vertexCoordsArray;\ |
262 vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \ |
264 gl_Position.xy = gl_Position.xy / gl_Position.w; \ |
263 gl_Position.xy = transformedPos.xy / transformedPos.z; \ |
265 mediump vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \ |
264 mediump vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \ |
266 mediump vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1); \ |
265 mediump vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1); \ |
267 mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \ |
266 mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \ |
268 gl_Position.xy = gl_Position.xy * invertedHTexCoordsZ; \ |
267 gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \ |
269 gl_Position.w = invertedHTexCoordsZ; \ |
|
270 textureCoords.xy = (hTexCoords.xy * invertedTextureSize) * gl_Position.w; \ |
268 textureCoords.xy = (hTexCoords.xy * invertedTextureSize) * gl_Position.w; \ |
271 }"; |
269 }"; |
272 |
270 |
273 static const char* const qglslAffinePositionWithTextureBrushVertexShader |
271 static const char* const qglslAffinePositionWithTextureBrushVertexShader |
274 = qglslPositionWithTextureBrushVertexShader; |
272 = qglslPositionWithTextureBrushVertexShader; |