Home | History | Annotate | Download | only in android 
      1 /*
      2  * Copyright 2010, The Android Open Source Project
      3  *
      4  * Redistribution and use in source and binary forms, with or without
      5  * modification, are permitted provided that the following conditions
      6  * are met:
      7  *  * Redistributions of source code must retain the above copyright
      8  *    notice, this list of conditions and the following disclaimer.
      9  *  * Redistributions in binary form must reproduce the above copyright
     10  *    notice, this list of conditions and the following disclaimer in the
     11  *    documentation and/or other materials provided with the distribution.
     12  *
     13  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
     14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
     17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
     18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
     20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
     21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     24  */
     25 
     26 #include "config.h"
     27 #include "ShaderProgram.h"
     28 
     29 #if USE(ACCELERATED_COMPOSITING)
     30 
     31 #include "FloatPoint3D.h"
     32 #include "GLUtils.h"
     33 #include "TilesManager.h"
     34 
     35 #include <GLES2/gl2.h>
     36 #include <GLES2/gl2ext.h>
     37 #include <cutils/log.h>
     38 #include <wtf/CurrentTime.h>
     39 #include <wtf/text/CString.h>
     40 
     41 #undef XLOG
     42 #define XLOG(...) android_printLog(ANDROID_LOG_DEBUG, "ShaderProgram", __VA_ARGS__)
     43 
     44 namespace WebCore {
     45 
     46 static const char gVertexShader[] =
     47     "attribute vec4 vPosition;\n"
     48     "uniform mat4 projectionMatrix;\n"
     49     "varying vec2 v_texCoord;\n"
     50     "void main() {\n"
     51     "  gl_Position = projectionMatrix * vPosition;\n"
     52     "  v_texCoord = vec2(vPosition);\n"
     53     "}\n";
     54 
     55 static const char gFragmentShader[] =
     56     "precision mediump float;\n"
     57     "varying vec2 v_texCoord; \n"
     58     "uniform float alpha; \n"
     59     "uniform sampler2D s_texture; \n"
     60     "void main() {\n"
     61     "  gl_FragColor = texture2D(s_texture, v_texCoord); \n"
     62     "  gl_FragColor *= alpha; "
     63     "}\n";
     64 
     65 static const char gFragmentShaderInverted[] =
     66     "precision mediump float;\n"
     67     "varying vec2 v_texCoord; \n"
     68     "uniform float alpha; \n"
     69     "uniform float contrast; \n"
     70     "uniform sampler2D s_texture; \n"
     71     "void main() {\n"
     72     "  vec4 pixel = texture2D(s_texture, v_texCoord); \n"
     73     "  float a = pixel.a; \n"
     74     "  float color = a - (0.2989 * pixel.r + 0.5866 * pixel.g + 0.1145 * pixel.b);\n"
     75     "  color = ((color - a/2.0) * contrast) + a/2.0; \n"
     76     "  pixel.rgb = vec3(color, color, color); \n "
     77     "  gl_FragColor = pixel; \n"
     78     "  gl_FragColor *= alpha; \n"
     79     "}\n";
     80 
     81 static const char gVideoVertexShader[] =
     82     "attribute vec4 vPosition;\n"
     83     "uniform mat4 textureMatrix;\n"
     84     "uniform mat4 projectionMatrix;\n"
     85     "varying vec2 v_texCoord;\n"
     86     "void main() {\n"
     87     "  gl_Position = projectionMatrix * vPosition;\n"
     88     "  v_texCoord = vec2(textureMatrix * vec4(vPosition.x, 1.0 - vPosition.y, 0.0, 1.0));\n"
     89     "}\n";
     90 
     91 static const char gVideoFragmentShader[] =
     92     "#extension GL_OES_EGL_image_external : require\n"
     93     "precision mediump float;\n"
     94     "uniform samplerExternalOES s_yuvTexture;\n"
     95     "varying vec2 v_texCoord;\n"
     96     "void main() {\n"
     97     "  gl_FragColor = texture2D(s_yuvTexture, v_texCoord);\n"
     98     "}\n";
     99 
    100 static const char gSurfaceTextureOESFragmentShader[] =
    101     "#extension GL_OES_EGL_image_external : require\n"
    102     "precision mediump float;\n"
    103     "varying vec2 v_texCoord; \n"
    104     "uniform float alpha; \n"
    105     "uniform samplerExternalOES s_texture; \n"
    106     "void main() {\n"
    107     "  gl_FragColor = texture2D(s_texture, v_texCoord); \n"
    108     "  gl_FragColor *= alpha; "
    109     "}\n";
    110 
    111 static const char gSurfaceTextureOESFragmentShaderInverted[] =
    112     "#extension GL_OES_EGL_image_external : require\n"
    113     "precision mediump float;\n"
    114     "varying vec2 v_texCoord; \n"
    115     "uniform float alpha; \n"
    116     "uniform float contrast; \n"
    117     "uniform samplerExternalOES s_texture; \n"
    118     "void main() {\n"
    119     "  vec4 pixel = texture2D(s_texture, v_texCoord); \n"
    120     "  float a = pixel.a; \n"
    121     "  float color = a - (0.2989 * pixel.r + 0.5866 * pixel.g + 0.1145 * pixel.b);\n"
    122     "  color = ((color - a/2.0) * contrast) + a/2.0; \n"
    123     "  pixel.rgb = vec3(color, color, color); \n "
    124     "  gl_FragColor = pixel; \n"
    125     "  gl_FragColor *= alpha; \n"
    126     "}\n";
    127 
    128 GLuint ShaderProgram::loadShader(GLenum shaderType, const char* pSource)
    129 {
    130     GLuint shader = glCreateShader(shaderType);
    131     if (shader) {
    132         glShaderSource(shader, 1, &pSource, 0);
    133         glCompileShader(shader);
    134         GLint compiled = 0;
    135         glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
    136         if (!compiled) {
    137             GLint infoLen = 0;
    138             glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
    139             if (infoLen) {
    140                 char* buf = (char*) malloc(infoLen);
    141                 if (buf) {
    142                 glGetShaderInfoLog(shader, infoLen, 0, buf);
    143                 XLOG("could not compile shader %d:\n%s\n", shaderType, buf);
    144                 free(buf);
    145             }
    146             glDeleteShader(shader);
    147             shader = 0;
    148             }
    149         }
    150     }
    151     return shader;
    152 }
    153 
    154 GLuint ShaderProgram::createProgram(const char* pVertexSource, const char* pFragmentSource)
    155 {
    156     GLuint vertexShader = loadShader(GL_VERTEX_SHADER, pVertexSource);
    157     if (!vertexShader) {
    158         XLOG("couldn't load the vertex shader!");
    159         return -1;
    160     }
    161 
    162     GLuint pixelShader = loadShader(GL_FRAGMENT_SHADER, pFragmentSource);
    163     if (!pixelShader) {
    164         XLOG("couldn't load the pixel shader!");
    165         return -1;
    166     }
    167 
    168     GLuint program = glCreateProgram();
    169     if (program) {
    170         glAttachShader(program, vertexShader);
    171         GLUtils::checkGlError("glAttachShader vertex");
    172         glAttachShader(program, pixelShader);
    173         GLUtils::checkGlError("glAttachShader pixel");
    174         glLinkProgram(program);
    175         GLint linkStatus = GL_FALSE;
    176         glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
    177         if (linkStatus != GL_TRUE) {
    178             GLint bufLength = 0;
    179             glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength);
    180             if (bufLength) {
    181                 char* buf = (char*) malloc(bufLength);
    182                 if (buf) {
    183                     glGetProgramInfoLog(program, bufLength, 0, buf);
    184                     XLOG("could not link program:\n%s\n", buf);
    185                     free(buf);
    186                 }
    187             }
    188             glDeleteProgram(program);
    189             program = -1;
    190         }
    191     }
    192     return program;
    193 }
    194 
    195 ShaderProgram::ShaderProgram()
    196     : m_blendingEnabled(false)
    197     , m_contrast(1)
    198     , m_alphaLayer(false)
    199     , m_currentScale(1.0f)
    200 {
    201     init();
    202 }
    203 
    204 void ShaderProgram::init()
    205 {
    206     m_program = createProgram(gVertexShader, gFragmentShader);
    207     m_programInverted = createProgram(gVertexShader, gFragmentShaderInverted);
    208     m_videoProgram = createProgram(gVideoVertexShader, gVideoFragmentShader);
    209     m_surfTexOESProgram =
    210         createProgram(gVertexShader, gSurfaceTextureOESFragmentShader);
    211     m_surfTexOESProgramInverted =
    212         createProgram(gVertexShader, gSurfaceTextureOESFragmentShaderInverted);
    213 
    214     if (m_program == -1
    215         || m_programInverted == -1
    216         || m_videoProgram == -1
    217         || m_surfTexOESProgram == -1
    218         || m_surfTexOESProgramInverted == -1)
    219         return;
    220 
    221     m_hProjectionMatrix = glGetUniformLocation(m_program, "projectionMatrix");
    222     m_hAlpha = glGetUniformLocation(m_program, "alpha");
    223     m_hTexSampler = glGetUniformLocation(m_program, "s_texture");
    224     m_hPosition = glGetAttribLocation(m_program, "vPosition");
    225 
    226     m_hProjectionMatrixInverted = glGetUniformLocation(m_programInverted, "projectionMatrix");
    227     m_hAlphaInverted = glGetUniformLocation(m_programInverted, "alpha");
    228     m_hContrastInverted = glGetUniformLocation(m_surfTexOESProgramInverted, "contrast");
    229     m_hTexSamplerInverted = glGetUniformLocation(m_programInverted, "s_texture");
    230     m_hPositionInverted = glGetAttribLocation(m_programInverted, "vPosition");
    231 
    232     m_hVideoProjectionMatrix =
    233         glGetUniformLocation(m_videoProgram, "projectionMatrix");
    234     m_hVideoTextureMatrix = glGetUniformLocation(m_videoProgram, "textureMatrix");
    235     m_hVideoTexSampler = glGetUniformLocation(m_videoProgram, "s_yuvTexture");
    236     m_hVideoPosition = glGetAttribLocation(m_program, "vPosition");
    237 
    238     m_hSTOESProjectionMatrix =
    239         glGetUniformLocation(m_surfTexOESProgram, "projectionMatrix");
    240     m_hSTOESAlpha = glGetUniformLocation(m_surfTexOESProgram, "alpha");
    241     m_hSTOESTexSampler = glGetUniformLocation(m_surfTexOESProgram, "s_texture");
    242     m_hSTOESPosition = glGetAttribLocation(m_surfTexOESProgram, "vPosition");
    243 
    244     m_hSTOESProjectionMatrixInverted =
    245         glGetUniformLocation(m_surfTexOESProgramInverted, "projectionMatrix");
    246     m_hSTOESAlphaInverted = glGetUniformLocation(m_surfTexOESProgramInverted, "alpha");
    247     m_hSTOESContrastInverted = glGetUniformLocation(m_surfTexOESProgramInverted, "contrast");
    248     m_hSTOESTexSamplerInverted = glGetUniformLocation(m_surfTexOESProgramInverted, "s_texture");
    249     m_hSTOESPositionInverted = glGetAttribLocation(m_surfTexOESProgramInverted, "vPosition");
    250 
    251 
    252     const GLfloat coord[] = {
    253         0.0f, 0.0f, // C
    254         1.0f, 0.0f, // D
    255         0.0f, 1.0f, // A
    256         1.0f, 1.0f // B
    257     };
    258 
    259     glGenBuffers(1, m_textureBuffer);
    260     glBindBuffer(GL_ARRAY_BUFFER, m_textureBuffer[0]);
    261     glBufferData(GL_ARRAY_BUFFER, 2 * 4 * sizeof(GLfloat), coord, GL_STATIC_DRAW);
    262 
    263     GLUtils::checkGlError("init");
    264 }
    265 
    266 void ShaderProgram::resetBlending()
    267 {
    268     glDisable(GL_BLEND);
    269     glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
    270     glBlendEquation(GL_FUNC_ADD);
    271     m_blendingEnabled = false;
    272 }
    273 
    274 void ShaderProgram::setBlendingState(bool enableBlending)
    275 {
    276     if (enableBlending == m_blendingEnabled)
    277         return;
    278 
    279     if (enableBlending)
    280         glEnable(GL_BLEND);
    281     else
    282         glDisable(GL_BLEND);
    283 
    284     m_blendingEnabled = enableBlending;
    285 }
    286 
    287 /////////////////////////////////////////////////////////////////////////////////////////
    288 // Drawing
    289 /////////////////////////////////////////////////////////////////////////////////////////
    290 
    291 void ShaderProgram::setViewport(SkRect& viewport, float scale)
    292 {
    293     TransformationMatrix ortho;
    294     GLUtils::setOrthographicMatrix(ortho, viewport.fLeft, viewport.fTop,
    295                                    viewport.fRight, viewport.fBottom, -1000, 1000);
    296     m_projectionMatrix = ortho;
    297     m_viewport = viewport;
    298     m_currentScale = scale;
    299 }
    300 
    301 void ShaderProgram::setProjectionMatrix(SkRect& geometry, GLint projectionMatrixHandle)
    302 {
    303     TransformationMatrix translate;
    304     translate.translate3d(geometry.fLeft, geometry.fTop, 0.0);
    305     TransformationMatrix scale;
    306     scale.scale3d(geometry.width(), geometry.height(), 1.0);
    307 
    308     TransformationMatrix total;
    309     if (!m_alphaLayer)
    310         total = m_projectionMatrix * m_repositionMatrix * m_webViewMatrix
    311                 * translate * scale;
    312     else
    313         total = m_projectionMatrix * translate * scale;
    314 
    315     GLfloat projectionMatrix[16];
    316     GLUtils::toGLMatrix(projectionMatrix, total);
    317     glUniformMatrix4fv(projectionMatrixHandle, 1, GL_FALSE, projectionMatrix);
    318 }
    319 
    320 void ShaderProgram::drawQuadInternal(SkRect& geometry,
    321                                      GLint textureId,
    322                                      float opacity,
    323                                      GLint program,
    324                                      GLint projectionMatrixHandle,
    325                                      GLint texSampler,
    326                                      GLenum textureTarget,
    327                                      GLint position,
    328                                      GLint alpha,
    329                                      GLint texFilter,
    330                                      GLint contrast)
    331 {
    332     glUseProgram(program);
    333 
    334     if (!geometry.isEmpty())
    335          setProjectionMatrix(geometry, projectionMatrixHandle);
    336     else {
    337         TransformationMatrix matrix;
    338         // Map x,y from (0,1) to (-1, 1)
    339         matrix.scale3d(2, 2, 1);
    340         matrix.translate3d(-0.5, -0.5, 0);
    341         GLfloat projectionMatrix[16];
    342         GLUtils::toGLMatrix(projectionMatrix, matrix);
    343         glUniformMatrix4fv(projectionMatrixHandle, 1, GL_FALSE, projectionMatrix);
    344     }
    345 
    346     glActiveTexture(GL_TEXTURE0);
    347     glUniform1i(texSampler, 0);
    348     glBindTexture(textureTarget, textureId);
    349     glTexParameteri(textureTarget, GL_TEXTURE_MIN_FILTER, texFilter);
    350     glTexParameteri(textureTarget, GL_TEXTURE_MAG_FILTER, texFilter);
    351     glTexParameteri(textureTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    352     glTexParameteri(textureTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    353 
    354     glBindBuffer(GL_ARRAY_BUFFER, m_textureBuffer[0]);
    355     glEnableVertexAttribArray(position);
    356     glVertexAttribPointer(position, 2, GL_FLOAT, GL_FALSE, 0, 0);
    357     glUniform1f(alpha, opacity);
    358     if (contrast != -1)
    359         glUniform1f(contrast, m_contrast);
    360 
    361     setBlendingState(opacity < 1.0);
    362     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
    363 }
    364 
    365 void ShaderProgram::drawQuad(SkRect& geometry, int textureId, float opacity,
    366                              GLenum textureTarget, GLint texFilter)
    367 {
    368     if (textureTarget == GL_TEXTURE_2D) {
    369         if (!TilesManager::instance()->invertedScreen()) {
    370             drawQuadInternal(geometry, textureId, opacity, m_program,
    371                              m_hProjectionMatrix,
    372                              m_hTexSampler, GL_TEXTURE_2D,
    373                              m_hPosition, m_hAlpha, texFilter);
    374         } else {
    375             // With the new GPU texture upload path, we do not use an FBO
    376             // to blit the texture we receive from the TexturesGenerator thread.
    377             // To implement inverted rendering, we thus have to do the rendering
    378             // live, by using a different shader.
    379             drawQuadInternal(geometry, textureId, opacity, m_programInverted,
    380                              m_hProjectionMatrixInverted,
    381                              m_hTexSamplerInverted, GL_TEXTURE_2D,
    382                              m_hPositionInverted, m_hAlphaInverted, texFilter,
    383                              m_hContrastInverted);
    384         }
    385     } else if (textureTarget == GL_TEXTURE_EXTERNAL_OES
    386                && !TilesManager::instance()->invertedScreen()) {
    387         drawQuadInternal(geometry, textureId, opacity, m_surfTexOESProgram,
    388                          m_hSTOESProjectionMatrix,
    389                          m_hSTOESTexSampler, GL_TEXTURE_EXTERNAL_OES,
    390                          m_hSTOESPosition, m_hSTOESAlpha, texFilter);
    391     } else if (textureTarget == GL_TEXTURE_EXTERNAL_OES
    392                && TilesManager::instance()->invertedScreen()) {
    393         drawQuadInternal(geometry, textureId, opacity, m_surfTexOESProgramInverted,
    394                          m_hSTOESProjectionMatrixInverted,
    395                          m_hSTOESTexSamplerInverted, GL_TEXTURE_EXTERNAL_OES,
    396                          m_hSTOESPositionInverted, m_hSTOESAlphaInverted,
    397                          texFilter, m_hSTOESContrastInverted);
    398     }
    399     GLUtils::checkGlError("drawQuad");
    400 }
    401 
    402 void ShaderProgram::setViewRect(const IntRect& viewRect)
    403 {
    404     m_viewRect = viewRect;
    405 
    406     // We do clipping using glScissor, which needs to take
    407     // coordinates in screen space. The following matrix transform
    408     // content coordinates in screen coordinates.
    409     TransformationMatrix translate;
    410     translate.translate(1.0, 1.0);
    411 
    412     TransformationMatrix scale;
    413     scale.scale3d(m_viewRect.width() * 0.5f, m_viewRect.height() * 0.5f, 1);
    414 
    415     m_documentToScreenMatrix = scale * translate * m_projectionMatrix;
    416 
    417     translate.scale3d(1, -1, 1);
    418     m_documentToInvScreenMatrix = scale * translate * m_projectionMatrix;
    419 
    420     IntRect rect(0, 0, m_webViewRect.width(), m_webViewRect.height());
    421     m_documentViewport = m_documentToScreenMatrix.inverse().mapRect(rect);
    422 }
    423 
    424 // This function transform a clip rect extracted from the current layer
    425 // into a clip rect in screen coordinates -- used by the clipping rects
    426 FloatRect ShaderProgram::rectInScreenCoord(const TransformationMatrix& drawMatrix, const IntSize& size)
    427 {
    428     FloatRect srect(0, 0, size.width(), size.height());
    429     TransformationMatrix renderMatrix = m_documentToScreenMatrix * drawMatrix;
    430     return renderMatrix.mapRect(srect);
    431 }
    432 
    433 // used by the partial screen invals
    434 FloatRect ShaderProgram::rectInInvScreenCoord(const TransformationMatrix& drawMatrix, const IntSize& size)
    435 {
    436     FloatRect srect(0, 0, size.width(), size.height());
    437     TransformationMatrix renderMatrix = m_documentToInvScreenMatrix * drawMatrix;
    438     return renderMatrix.mapRect(srect);
    439 }
    440 
    441 FloatRect ShaderProgram::rectInInvScreenCoord(const FloatRect& rect)
    442 {
    443     return m_documentToInvScreenMatrix.mapRect(rect);
    444 }
    445 
    446 FloatRect ShaderProgram::rectInScreenCoord(const FloatRect& rect)
    447 {
    448     return m_documentToScreenMatrix.mapRect(rect);
    449 }
    450 
    451 FloatRect ShaderProgram::convertScreenCoordToDocumentCoord(const FloatRect& rect)
    452 {
    453     return m_documentToScreenMatrix.inverse().mapRect(rect);
    454 }
    455 
    456 FloatRect ShaderProgram::convertInvScreenCoordToScreenCoord(const FloatRect& rect)
    457 {
    458     FloatRect documentRect = m_documentToInvScreenMatrix.inverse().mapRect(rect);
    459     return rectInScreenCoord(documentRect);
    460 }
    461 
    462 FloatRect ShaderProgram::convertScreenCoordToInvScreenCoord(const FloatRect& rect)
    463 {
    464     FloatRect documentRect = m_documentToScreenMatrix.inverse().mapRect(rect);
    465     return rectInInvScreenCoord(documentRect);
    466 }
    467 
    468 void ShaderProgram::setScreenClip(const IntRect& clip)
    469 {
    470     m_screenClip = clip;
    471     IntRect mclip = clip;
    472 
    473     // the clip from frameworks is in full screen coordinates
    474     mclip.setY(clip.y() - m_webViewRect.y() - m_titleBarHeight);
    475     FloatRect tclip = convertInvScreenCoordToScreenCoord(mclip);
    476     IntRect screenClip(tclip.x(), tclip.y(), tclip.width(), tclip.height());
    477     m_screenClip = screenClip;
    478 }
    479 
    480 // clip is in screen coordinates
    481 void ShaderProgram::clip(const FloatRect& clip)
    482 {
    483     if (clip == m_clipRect)
    484         return;
    485 
    486     // we should only call glScissor in this function, so that we can easily
    487     // track the current clipping rect.
    488 
    489     IntRect screenClip(clip.x(),
    490                        clip.y(),
    491                        clip.width(), clip.height());
    492 
    493     if (!m_screenClip.isEmpty())
    494         screenClip.intersect(m_screenClip);
    495 
    496     screenClip.setY(screenClip.y() + m_viewRect.y());
    497     if (screenClip.x() < 0) {
    498         int w = screenClip.width();
    499         w += screenClip.x();
    500         screenClip.setX(0);
    501         screenClip.setWidth(w);
    502     }
    503     if (screenClip.y() < 0) {
    504         int h = screenClip.height();
    505         h += screenClip.y();
    506         screenClip.setY(0);
    507         screenClip.setHeight(h);
    508     }
    509 
    510     glScissor(screenClip.x(), screenClip.y(), screenClip.width(), screenClip.height());
    511 
    512     m_clipRect = clip;
    513 }
    514 
    515 IntRect ShaderProgram::clippedRectWithViewport(const IntRect& rect, int margin)
    516 {
    517     IntRect viewport(m_viewport.fLeft - margin, m_viewport.fTop - margin,
    518                      m_viewport.width() + margin, m_viewport.height() + margin);
    519     viewport.intersect(rect);
    520     return viewport;
    521 }
    522 
    523 float ShaderProgram::zValue(const TransformationMatrix& drawMatrix, float w, float h)
    524 {
    525     TransformationMatrix modifiedDrawMatrix = drawMatrix;
    526     modifiedDrawMatrix.scale3d(w, h, 1);
    527     TransformationMatrix renderMatrix = m_projectionMatrix * modifiedDrawMatrix;
    528     FloatPoint3D point(0.5, 0.5, 0.0);
    529     FloatPoint3D result = renderMatrix.mapPoint(point);
    530     return result.z();
    531 }
    532 
    533 void ShaderProgram::drawLayerQuadInternal(const GLfloat* projectionMatrix,
    534                                           int textureId, float opacity,
    535                                           GLenum textureTarget, GLint program,
    536                                           GLint matrix, GLint texSample,
    537                                           GLint position, GLint alpha,
    538                                           GLint contrast)
    539 {
    540     glUseProgram(program);
    541     glUniformMatrix4fv(matrix, 1, GL_FALSE, projectionMatrix);
    542 
    543     glActiveTexture(GL_TEXTURE0);
    544     glUniform1i(texSample, 0);
    545     glBindTexture(textureTarget, textureId);
    546     glTexParameteri(textureTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    547     glTexParameteri(textureTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    548     glTexParameteri(textureTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    549     glTexParameteri(textureTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    550 
    551 
    552     glBindBuffer(GL_ARRAY_BUFFER, m_textureBuffer[0]);
    553     glEnableVertexAttribArray(position);
    554     glVertexAttribPointer(position, 2, GL_FLOAT, GL_FALSE, 0, 0);
    555     glUniform1f(alpha, opacity);
    556     if (contrast != -1)
    557         glUniform1f(contrast, m_contrast);
    558 }
    559 
    560 
    561 void ShaderProgram::drawLayerQuad(const TransformationMatrix& drawMatrix,
    562                                   const SkRect& geometry, int textureId,
    563                                   float opacity, bool forceBlending,
    564                                   GLenum textureTarget)
    565 {
    566 
    567     TransformationMatrix modifiedDrawMatrix = drawMatrix;
    568     // move the drawing depending on where the texture is on the layer
    569     modifiedDrawMatrix.translate(geometry.fLeft, geometry.fTop);
    570     modifiedDrawMatrix.scale3d(geometry.width(), geometry.height(), 1);
    571 
    572     TransformationMatrix renderMatrix;
    573     if (!m_alphaLayer)
    574         renderMatrix = m_projectionMatrix * m_repositionMatrix
    575                        * m_webViewMatrix * modifiedDrawMatrix;
    576     else
    577         renderMatrix = m_projectionMatrix * modifiedDrawMatrix;
    578 
    579     GLfloat projectionMatrix[16];
    580     GLUtils::toGLMatrix(projectionMatrix, renderMatrix);
    581     if (textureTarget == GL_TEXTURE_2D) {
    582         if (!TilesManager::instance()->invertedScreen()) {
    583             drawLayerQuadInternal(projectionMatrix, textureId, opacity,
    584                                   GL_TEXTURE_2D, m_program,
    585                                   m_hProjectionMatrix, m_hTexSampler,
    586                                   m_hPosition, m_hAlpha);
    587         } else {
    588             drawLayerQuadInternal(projectionMatrix, textureId, opacity,
    589                                   GL_TEXTURE_2D, m_programInverted,
    590                                   m_hProjectionMatrixInverted, m_hTexSamplerInverted,
    591                                   m_hPositionInverted, m_hAlphaInverted,
    592                                   m_hContrastInverted);
    593         }
    594     } else if (textureTarget == GL_TEXTURE_EXTERNAL_OES
    595                && !TilesManager::instance()->invertedScreen()) {
    596         drawLayerQuadInternal(projectionMatrix, textureId, opacity,
    597                               GL_TEXTURE_EXTERNAL_OES, m_surfTexOESProgram,
    598                               m_hSTOESProjectionMatrix, m_hSTOESTexSampler,
    599                               m_hSTOESPosition, m_hSTOESAlpha);
    600     } else if (textureTarget == GL_TEXTURE_EXTERNAL_OES
    601                && TilesManager::instance()->invertedScreen()) {
    602         drawLayerQuadInternal(projectionMatrix, textureId, opacity,
    603                               GL_TEXTURE_EXTERNAL_OES, m_surfTexOESProgramInverted,
    604                               m_hSTOESProjectionMatrixInverted, m_hSTOESTexSamplerInverted,
    605                               m_hSTOESPositionInverted, m_hSTOESAlphaInverted,
    606                               m_hSTOESContrastInverted);
    607     }
    608 
    609     setBlendingState(forceBlending || opacity < 1.0);
    610     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
    611 
    612     GLUtils::checkGlError("drawLayerQuad");
    613 }
    614 
    615 void ShaderProgram::drawVideoLayerQuad(const TransformationMatrix& drawMatrix,
    616                                        float* textureMatrix, SkRect& geometry,
    617                                        int textureId)
    618 {
    619     // switch to our custom yuv video rendering program
    620     glUseProgram(m_videoProgram);
    621 
    622     TransformationMatrix modifiedDrawMatrix = drawMatrix;
    623     modifiedDrawMatrix.translate(geometry.fLeft, geometry.fTop);
    624     modifiedDrawMatrix.scale3d(geometry.width(), geometry.height(), 1);
    625     TransformationMatrix renderMatrix = m_projectionMatrix * modifiedDrawMatrix;
    626 
    627     GLfloat projectionMatrix[16];
    628     GLUtils::toGLMatrix(projectionMatrix, renderMatrix);
    629     glUniformMatrix4fv(m_hVideoProjectionMatrix, 1, GL_FALSE, projectionMatrix);
    630     glUniformMatrix4fv(m_hVideoTextureMatrix, 1, GL_FALSE, textureMatrix);
    631 
    632     glActiveTexture(GL_TEXTURE0);
    633     glUniform1i(m_hVideoTexSampler, 0);
    634     glBindTexture(GL_TEXTURE_EXTERNAL_OES, textureId);
    635 
    636     glBindBuffer(GL_ARRAY_BUFFER, m_textureBuffer[0]);
    637     glEnableVertexAttribArray(m_hVideoPosition);
    638     glVertexAttribPointer(m_hVideoPosition, 2, GL_FLOAT, GL_FALSE, 0, 0);
    639 
    640     setBlendingState(false);
    641     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
    642 }
    643 
    644 void ShaderProgram::setWebViewMatrix(const float* matrix, bool alphaLayer)
    645 {
    646     GLUtils::convertToTransformationMatrix(matrix, m_webViewMatrix);
    647     m_alphaLayer = alphaLayer;
    648 }
    649 
    650 void ShaderProgram::calculateAnimationDelta()
    651 {
    652     // The matrix contains the scrolling info, so this rect is starting from
    653     // the m_viewport.
    654     // So we just need to map the webview's visible rect using the matrix,
    655     // calculate the difference b/t transformed rect and the webViewRect,
    656     // then we can get the delta x , y caused by the animation.
    657     // Note that the Y is for reporting back to GL viewport, so it is inverted.
    658     // When it is alpha animation, then we rely on the framework implementation
    659     // such that there is no matrix applied in native webkit.
    660     if (!m_alphaLayer) {
    661         FloatRect rect(m_viewport.fLeft * m_currentScale,
    662                        m_viewport.fTop * m_currentScale,
    663                        m_webViewRect.width(),
    664                        m_webViewRect.height());
    665         rect = m_webViewMatrix.mapRect(rect);
    666         m_animationDelta.setX(rect.x() - m_webViewRect.x() );
    667         m_animationDelta.setY(rect.y() + rect.height() - m_webViewRect.y()
    668                               - m_webViewRect.height() - m_titleBarHeight);
    669 
    670         m_repositionMatrix.makeIdentity();
    671         m_repositionMatrix.translate3d(-m_webViewRect.x(), -m_webViewRect.y() - m_titleBarHeight, 0);
    672         m_repositionMatrix.translate3d(m_viewport.fLeft * m_currentScale, m_viewport.fTop * m_currentScale, 0);
    673         m_repositionMatrix.translate3d(-m_animationDelta.x(), -m_animationDelta.y(), 0);
    674     } else {
    675         m_animationDelta.setX(0);
    676         m_animationDelta.setY(0);
    677         m_repositionMatrix.makeIdentity();
    678     }
    679 
    680 }
    681 
    682 } // namespace WebCore
    683 
    684 #endif // USE(ACCELERATED_COMPOSITING)
    685