| /* |
| * Copyright 2010, The Android Open Source Project |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY |
| * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY |
| * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #define LOG_TAG "ShaderProgram" |
| #define LOG_NDEBUG 1 |
| |
| #include "config.h" |
| #include "ShaderProgram.h" |
| |
| #if USE(ACCELERATED_COMPOSITING) |
| |
| #include "AndroidLog.h" |
| #include "DrawQuadData.h" |
| #include "FloatPoint3D.h" |
| #include "GLUtils.h" |
| #include "TilesManager.h" |
| |
| #include <GLES2/gl2.h> |
| #include <GLES2/gl2ext.h> |
| |
| #define EPSILON 0.00001f |
| |
| namespace WebCore { |
| |
| // fillPortion.xy = starting UV coordinates. |
| // fillPortion.zw = UV coordinates width and height. |
| static const char gVertexShader[] = |
| "attribute vec4 vPosition;\n" |
| "uniform mat4 projectionMatrix;\n" |
| "uniform vec4 fillPortion;\n" |
| "varying vec2 v_texCoord;\n" |
| "void main() {\n" |
| " gl_Position = projectionMatrix * vPosition;\n" |
| " v_texCoord = vPosition.xy * fillPortion.zw + fillPortion.xy;\n" |
| "}\n"; |
| |
| static const char gRepeatTexFragmentShader[] = |
| "precision mediump float;\n" |
| "varying vec2 v_texCoord; \n" |
| "uniform float alpha; \n" |
| "uniform sampler2D s_texture; \n" |
| "uniform vec2 repeatScale;\n" |
| "void main() {\n" |
| " vec2 repeatedTexCoord; " |
| " repeatedTexCoord.x = v_texCoord.x - floor(v_texCoord.x); " |
| " repeatedTexCoord.y = v_texCoord.y - floor(v_texCoord.y); " |
| " repeatedTexCoord.x = repeatedTexCoord.x * repeatScale.x; " |
| " repeatedTexCoord.y = repeatedTexCoord.y * repeatScale.y; " |
| " gl_FragColor = texture2D(s_texture, repeatedTexCoord); \n" |
| " gl_FragColor *= alpha; " |
| "}\n"; |
| |
| static const char gRepeatTexFragmentShaderInverted[] = |
| "precision mediump float;\n" |
| "varying vec2 v_texCoord; \n" |
| "uniform float alpha; \n" |
| "uniform float contrast; \n" |
| "uniform sampler2D s_texture; \n" |
| "uniform vec2 repeatScale;\n" |
| "void main() {\n" |
| " vec2 repeatedTexCoord; " |
| " repeatedTexCoord.x = v_texCoord.x - floor(v_texCoord.x); " |
| " repeatedTexCoord.y = v_texCoord.y - floor(v_texCoord.y); " |
| " repeatedTexCoord.x = repeatedTexCoord.x * repeatScale.x; " |
| " repeatedTexCoord.y = repeatedTexCoord.y * repeatScale.y; " |
| " vec4 pixel = texture2D(s_texture, repeatedTexCoord); \n" |
| " float a = pixel.a; \n" |
| " float color = a - (0.2989 * pixel.r + 0.5866 * pixel.g + 0.1145 * pixel.b);\n" |
| " color = ((color - a/2.0) * contrast) + a/2.0; \n" |
| " pixel.rgb = vec3(color, color, color); \n " |
| " gl_FragColor = pixel; \n" |
| " gl_FragColor *= alpha; " |
| "}\n"; |
| |
| static const char gFragmentShader[] = |
| "precision mediump float;\n" |
| "varying vec2 v_texCoord; \n" |
| "uniform float alpha; \n" |
| "uniform sampler2D s_texture; \n" |
| "void main() {\n" |
| " gl_FragColor = texture2D(s_texture, v_texCoord); \n" |
| " gl_FragColor *= alpha; " |
| "}\n"; |
| |
| // We could pass the pureColor into either Vertex or Frag Shader. |
| // The reason we passed the color into the Vertex Shader is that some driver |
| // might create redundant copy when uniforms in fragment shader changed. |
| static const char gPureColorVertexShader[] = |
| "attribute vec4 vPosition;\n" |
| "uniform mat4 projectionMatrix;\n" |
| "uniform vec4 inputColor;\n" |
| "varying vec4 v_color;\n" |
| "void main() {\n" |
| " gl_Position = projectionMatrix * vPosition;\n" |
| " v_color = inputColor;\n" |
| "}\n"; |
| |
| static const char gPureColorFragmentShader[] = |
| "precision mediump float;\n" |
| "varying vec4 v_color;\n" |
| "void main() {\n" |
| " gl_FragColor = v_color;\n" |
| "}\n"; |
| |
| static const char gFragmentShaderInverted[] = |
| "precision mediump float;\n" |
| "varying vec2 v_texCoord; \n" |
| "uniform float alpha; \n" |
| "uniform float contrast; \n" |
| "uniform sampler2D s_texture; \n" |
| "void main() {\n" |
| " vec4 pixel = texture2D(s_texture, v_texCoord); \n" |
| " float a = pixel.a; \n" |
| " float color = a - (0.2989 * pixel.r + 0.5866 * pixel.g + 0.1145 * pixel.b);\n" |
| " color = ((color - a/2.0) * contrast) + a/2.0; \n" |
| " pixel.rgb = vec3(color, color, color); \n " |
| " gl_FragColor = pixel; \n" |
| " gl_FragColor *= alpha; \n" |
| "}\n"; |
| |
| static const char gVideoVertexShader[] = |
| "attribute vec4 vPosition;\n" |
| "uniform mat4 textureMatrix;\n" |
| "uniform mat4 projectionMatrix;\n" |
| "varying vec2 v_texCoord;\n" |
| "void main() {\n" |
| " gl_Position = projectionMatrix * vPosition;\n" |
| " v_texCoord = vec2(textureMatrix * vec4(vPosition.x, 1.0 - vPosition.y, 0.0, 1.0));\n" |
| "}\n"; |
| |
| static const char gVideoFragmentShader[] = |
| "#extension GL_OES_EGL_image_external : require\n" |
| "precision mediump float;\n" |
| "uniform samplerExternalOES s_yuvTexture;\n" |
| "varying vec2 v_texCoord;\n" |
| "void main() {\n" |
| " gl_FragColor = texture2D(s_yuvTexture, v_texCoord);\n" |
| "}\n"; |
| |
| static const char gSurfaceTextureOESFragmentShader[] = |
| "#extension GL_OES_EGL_image_external : require\n" |
| "precision mediump float;\n" |
| "varying vec2 v_texCoord; \n" |
| "uniform float alpha; \n" |
| "uniform samplerExternalOES s_texture; \n" |
| "void main() {\n" |
| " gl_FragColor = texture2D(s_texture, v_texCoord); \n" |
| " gl_FragColor *= alpha; " |
| "}\n"; |
| |
| static const char gSurfaceTextureOESFragmentShaderInverted[] = |
| "#extension GL_OES_EGL_image_external : require\n" |
| "precision mediump float;\n" |
| "varying vec2 v_texCoord; \n" |
| "uniform float alpha; \n" |
| "uniform float contrast; \n" |
| "uniform samplerExternalOES s_texture; \n" |
| "void main() {\n" |
| " vec4 pixel = texture2D(s_texture, v_texCoord); \n" |
| " float a = pixel.a; \n" |
| " float color = a - (0.2989 * pixel.r + 0.5866 * pixel.g + 0.1145 * pixel.b);\n" |
| " color = ((color - a/2.0) * contrast) + a/2.0; \n" |
| " pixel.rgb = vec3(color, color, color); \n " |
| " gl_FragColor = pixel; \n" |
| " gl_FragColor *= alpha; \n" |
| "}\n"; |
| |
| GLuint ShaderProgram::loadShader(GLenum shaderType, const char* pSource) |
| { |
| GLuint shader = glCreateShader(shaderType); |
| if (shader) { |
| glShaderSource(shader, 1, &pSource, 0); |
| glCompileShader(shader); |
| GLint compiled = 0; |
| glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled); |
| if (!compiled) { |
| GLint infoLen = 0; |
| glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen); |
| if (infoLen) { |
| char* buf = (char*) malloc(infoLen); |
| if (buf) { |
| glGetShaderInfoLog(shader, infoLen, 0, buf); |
| ALOGE("could not compile shader %d:\n%s\n", shaderType, buf); |
| free(buf); |
| } |
| glDeleteShader(shader); |
| shader = 0; |
| } |
| } |
| } |
| return shader; |
| } |
| |
| GLint ShaderProgram::createProgram(const char* pVertexSource, const char* pFragmentSource) |
| { |
| GLuint vertexShader = loadShader(GL_VERTEX_SHADER, pVertexSource); |
| if (!vertexShader) { |
| ALOGE("couldn't load the vertex shader!"); |
| return -1; |
| } |
| |
| GLuint pixelShader = loadShader(GL_FRAGMENT_SHADER, pFragmentSource); |
| if (!pixelShader) { |
| ALOGE("couldn't load the pixel shader!"); |
| return -1; |
| } |
| |
| GLuint program = glCreateProgram(); |
| if (program) { |
| glAttachShader(program, vertexShader); |
| GLUtils::checkGlError("glAttachShader vertex"); |
| glAttachShader(program, pixelShader); |
| GLUtils::checkGlError("glAttachShader pixel"); |
| glLinkProgram(program); |
| GLint linkStatus = GL_FALSE; |
| glGetProgramiv(program, GL_LINK_STATUS, &linkStatus); |
| if (linkStatus != GL_TRUE) { |
| GLint bufLength = 0; |
| glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength); |
| if (bufLength) { |
| char* buf = (char*) malloc(bufLength); |
| if (buf) { |
| glGetProgramInfoLog(program, bufLength, 0, buf); |
| ALOGE("could not link program:\n%s\n", buf); |
| free(buf); |
| } |
| } |
| glDeleteProgram(program); |
| program = -1; |
| } |
| } |
| |
| ShaderResource newResource(program, vertexShader, pixelShader); |
| m_resources.append(newResource); |
| return program; |
| } |
| |
| void ShaderProgram::initProgram(ShaderType type) |
| { |
| // initialize shader's static texSampler and position values |
| glUseProgram(m_handleArray[type].programHandle); |
| |
| if (m_handleArray[type].texSamplerHandle != -1) |
| glUniform1i(m_handleArray[type].texSamplerHandle, 0); |
| glEnableVertexAttribArray(m_handleArray[type].positionHandle); |
| } |
| |
| ShaderProgram::ShaderProgram() |
| : m_blendingEnabled(false) |
| , m_contrast(1) |
| , m_alphaLayer(false) |
| , m_currentScale(1.0f) |
| , m_needsInit(true) |
| { |
| // initialize the matrix to calculate z values correctly, since it can be |
| // used for that before setupDrawing is called. |
| GLUtils::setOrthographicMatrix(m_visibleContentRectProjectionMatrix, |
| 0,0,1,1, |
| -1000, 1000); |
| } |
| |
| void ShaderProgram::cleanupGLResources() |
| { |
| for (unsigned int i = 0; i < m_resources.size(); i++) { |
| glDetachShader(m_resources[i].program, m_resources[i].vertexShader); |
| glDetachShader(m_resources[i].program, m_resources[i].fragmentShader); |
| glDeleteShader(m_resources[i].vertexShader); |
| glDeleteShader(m_resources[i].fragmentShader); |
| glDeleteProgram(m_resources[i].program); |
| } |
| glDeleteBuffers(1, m_textureBuffer); |
| |
| m_resources.clear(); |
| m_needsInit = true; |
| GLUtils::checkGlError("cleanupGLResources"); |
| |
| return; |
| } |
| |
| void ShaderProgram::initGLResources() |
| { |
| // To detect whether or not resources for ShaderProgram allocated |
| // successfully, we clean up pre-existing errors here and will check for |
| // new errors at the end of this function. |
| GLUtils::checkGlError("before initGLResources"); |
| |
| GLint tex2DProgram = createProgram(gVertexShader, gFragmentShader); |
| GLint pureColorProgram = createProgram(gPureColorVertexShader, gPureColorFragmentShader); |
| GLint tex2DInvProgram = createProgram(gVertexShader, gFragmentShaderInverted); |
| GLint videoProgram = createProgram(gVideoVertexShader, gVideoFragmentShader); |
| GLint texOESProgram = |
| createProgram(gVertexShader, gSurfaceTextureOESFragmentShader); |
| GLint texOESInvProgram = |
| createProgram(gVertexShader, gSurfaceTextureOESFragmentShaderInverted); |
| GLint repeatTexProgram = |
| createProgram(gVertexShader, gRepeatTexFragmentShader); |
| GLint repeatTexInvProgram = |
| createProgram(gVertexShader, gRepeatTexFragmentShaderInverted); |
| |
| if (tex2DProgram == -1 |
| || pureColorProgram == -1 |
| || tex2DInvProgram == -1 |
| || videoProgram == -1 |
| || texOESProgram == -1 |
| || texOESInvProgram == -1 |
| || repeatTexProgram == -1 |
| || repeatTexInvProgram == -1) { |
| m_needsInit = true; |
| return; |
| } |
| |
| GLint pureColorPosition = glGetAttribLocation(pureColorProgram, "vPosition"); |
| GLint pureColorProjMtx = glGetUniformLocation(pureColorProgram, "projectionMatrix"); |
| GLint pureColorValue = glGetUniformLocation(pureColorProgram, "inputColor"); |
| m_handleArray[PureColor].init(-1, -1, pureColorPosition, pureColorProgram, |
| pureColorProjMtx, pureColorValue, -1, -1, -1, -1); |
| initProgram(PureColor); |
| |
| GLint tex2DAlpha = glGetUniformLocation(tex2DProgram, "alpha"); |
| GLint tex2DPosition = glGetAttribLocation(tex2DProgram, "vPosition"); |
| GLint tex2DProjMtx = glGetUniformLocation(tex2DProgram, "projectionMatrix"); |
| GLint tex2DTexSampler = glGetUniformLocation(tex2DProgram, "s_texture"); |
| GLint tex2DFillPortion = glGetUniformLocation(tex2DProgram, "fillPortion"); |
| m_handleArray[Tex2D].init(tex2DAlpha, -1, tex2DPosition, tex2DProgram, |
| tex2DProjMtx, -1, tex2DTexSampler, -1, tex2DFillPortion, -1); |
| initProgram(Tex2D); |
| |
| GLint tex2DInvAlpha = glGetUniformLocation(tex2DInvProgram, "alpha"); |
| GLint tex2DInvContrast = glGetUniformLocation(tex2DInvProgram, "contrast"); |
| GLint tex2DInvPosition = glGetAttribLocation(tex2DInvProgram, "vPosition"); |
| GLint tex2DInvProjMtx = glGetUniformLocation(tex2DInvProgram, "projectionMatrix"); |
| GLint tex2DInvTexSampler = glGetUniformLocation(tex2DInvProgram, "s_texture"); |
| GLint tex2DInvFillPortion = glGetUniformLocation(tex2DInvProgram, "fillPortion"); |
| m_handleArray[Tex2DInv].init(tex2DInvAlpha, tex2DInvContrast, |
| tex2DInvPosition, tex2DInvProgram, |
| tex2DInvProjMtx, -1, |
| tex2DInvTexSampler, -1, tex2DInvFillPortion, -1); |
| initProgram(Tex2DInv); |
| |
| GLint repeatTexAlpha = glGetUniformLocation(repeatTexProgram, "alpha"); |
| GLint repeatTexPosition = glGetAttribLocation(repeatTexProgram, "vPosition"); |
| GLint repeatTexProjMtx = glGetUniformLocation(repeatTexProgram, "projectionMatrix"); |
| GLint repeatTexTexSampler = glGetUniformLocation(repeatTexProgram, "s_texture"); |
| GLint repeatTexFillPortion = glGetUniformLocation(repeatTexProgram, "fillPortion"); |
| GLint repeatTexScale = glGetUniformLocation(repeatTexProgram, "repeatScale"); |
| m_handleArray[RepeatTex].init(repeatTexAlpha, -1, repeatTexPosition, |
| repeatTexProgram,repeatTexProjMtx, -1, |
| repeatTexTexSampler, -1, repeatTexFillPortion, |
| repeatTexScale); |
| initProgram(RepeatTex); |
| |
| GLint repeatTexInvAlpha = glGetUniformLocation(repeatTexInvProgram, "alpha"); |
| GLint repeatTexInvContrast = glGetUniformLocation(tex2DInvProgram, "contrast"); |
| GLint repeatTexInvPosition = glGetAttribLocation(repeatTexInvProgram, "vPosition"); |
| GLint repeatTexInvProjMtx = glGetUniformLocation(repeatTexInvProgram, "projectionMatrix"); |
| GLint repeatTexInvTexSampler = glGetUniformLocation(repeatTexInvProgram, "s_texture"); |
| GLint repeatTexInvFillPortion = glGetUniformLocation(repeatTexInvProgram, "fillPortion"); |
| GLint repeatTexInvScale = glGetUniformLocation(repeatTexInvProgram, "repeatScale"); |
| m_handleArray[RepeatTexInv].init(repeatTexInvAlpha, repeatTexInvContrast, |
| repeatTexInvPosition, repeatTexInvProgram, |
| repeatTexInvProjMtx, -1, |
| repeatTexInvTexSampler, -1, |
| repeatTexInvFillPortion, repeatTexInvScale); |
| initProgram(RepeatTexInv); |
| |
| GLint texOESAlpha = glGetUniformLocation(texOESProgram, "alpha"); |
| GLint texOESPosition = glGetAttribLocation(texOESProgram, "vPosition"); |
| GLint texOESProjMtx = glGetUniformLocation(texOESProgram, "projectionMatrix"); |
| GLint texOESTexSampler = glGetUniformLocation(texOESProgram, "s_texture"); |
| GLint texOESFillPortion = glGetUniformLocation(texOESProgram, "fillPortion"); |
| m_handleArray[TexOES].init(texOESAlpha, -1, texOESPosition, texOESProgram, |
| texOESProjMtx, -1, texOESTexSampler, -1, texOESFillPortion, -1); |
| initProgram(TexOES); |
| |
| GLint texOESInvAlpha = glGetUniformLocation(texOESInvProgram, "alpha"); |
| GLint texOESInvContrast = glGetUniformLocation(texOESInvProgram, "contrast"); |
| GLint texOESInvPosition = glGetAttribLocation(texOESInvProgram, "vPosition"); |
| GLint texOESInvProjMtx = glGetUniformLocation(texOESInvProgram, "projectionMatrix"); |
| GLint texOESInvTexSampler = glGetUniformLocation(texOESInvProgram, "s_texture"); |
| GLint texOESInvFillPortion = glGetUniformLocation(texOESInvProgram, "fillPortion"); |
| m_handleArray[TexOESInv].init(texOESInvAlpha, texOESInvContrast, |
| texOESInvPosition, texOESInvProgram, |
| texOESInvProjMtx, -1, |
| texOESInvTexSampler, -1, texOESInvFillPortion, -1); |
| initProgram(TexOESInv); |
| |
| GLint videoPosition = glGetAttribLocation(videoProgram, "vPosition"); |
| GLint videoProjMtx = glGetUniformLocation(videoProgram, "projectionMatrix"); |
| GLint videoTexSampler = glGetUniformLocation(videoProgram, "s_yuvTexture"); |
| GLint videoTexMtx = glGetUniformLocation(videoProgram, "textureMatrix"); |
| m_handleArray[Video].init(-1, -1, videoPosition, videoProgram, |
| videoProjMtx, -1, videoTexSampler, |
| videoTexMtx, -1, -1); |
| initProgram(Video); |
| |
| const GLfloat coord[] = { |
| 0.0f, 0.0f, // C |
| 1.0f, 0.0f, // D |
| 0.0f, 1.0f, // A |
| 1.0f, 1.0f // B |
| }; |
| |
| glGenBuffers(1, m_textureBuffer); |
| glBindBuffer(GL_ARRAY_BUFFER, m_textureBuffer[0]); |
| glBufferData(GL_ARRAY_BUFFER, 2 * 4 * sizeof(GLfloat), coord, GL_STATIC_DRAW); |
| |
| TransformationMatrix matrix; |
| // Map x,y from (0,1) to (-1, 1) |
| matrix.scale3d(2, 2, 1); |
| matrix.translate3d(-0.5, -0.5, 0); |
| GLUtils::toGLMatrix(m_transferProjMtx, matrix); |
| |
| m_needsInit = GLUtils::checkGlError("initGLResources"); |
| return; |
| } |
| |
| void ShaderProgram::resetBlending() |
| { |
| glDisable(GL_BLEND); |
| glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); |
| glBlendEquation(GL_FUNC_ADD); |
| m_blendingEnabled = false; |
| } |
| |
| void ShaderProgram::setBlendingState(bool enableBlending) |
| { |
| if (enableBlending == m_blendingEnabled) |
| return; |
| |
| if (enableBlending) |
| glEnable(GL_BLEND); |
| else |
| glDisable(GL_BLEND); |
| |
| m_blendingEnabled = enableBlending; |
| } |
| |
| ///////////////////////////////////////////////////////////////////////////////////////// |
| // Drawing |
| ///////////////////////////////////////////////////////////////////////////////////////// |
| |
| // We have multiple coordinates to deal with: first is the screen coordinates, |
| // second is the view coordinates and the last one is content(document) coordinates. |
| // Both screen and view coordinates are in pixels. |
| // All these coordinates start from upper left, but for the purpose of OpenGL |
| // operations, we may need a inverted Y version of such coordinates which |
| // start from lower left. |
| // |
| // invScreenRect - inv screen coordinates starting from lower left. |
| // visibleContentRect - local content(document) coordinates starting from upper left. |
| // screenRect - screen coordinates starting from upper left. |
| // screenClip - screen coordinates starting from upper left. |
| // ------------------------------------------ |
| // |(origin of screen) | |
| // |screen | |
| // | --------------------------------- | |
| // | | (origin of view) | | |
| // | | webview | | |
| // | | -------- | | |
| // | | | clip | | | |
| // | | | | | | |
| // | | -------- | | |
| // | | | | |
| // | |(origin of inv view) | | |
| // | --------------------------------- | |
| // |(origin of inv screen) | |
| // ------------------------------------------ |
| void ShaderProgram::setupDrawing(const IntRect& invScreenRect, |
| const SkRect& visibleContentRect, |
| const IntRect& screenRect, int titleBarHeight, |
| const IntRect& screenClip, float scale) |
| { |
| m_screenRect = screenRect; |
| m_titleBarHeight = titleBarHeight; |
| |
| //// viewport //// |
| GLUtils::setOrthographicMatrix(m_visibleContentRectProjectionMatrix, |
| visibleContentRect.fLeft, |
| visibleContentRect.fTop, |
| visibleContentRect.fRight, |
| visibleContentRect.fBottom, |
| -1000, 1000); |
| |
| ALOGV("set m_clipProjectionMatrix, %d, %d, %d, %d", |
| screenClip.x(), screenClip.y(), screenClip.x() + screenClip.width(), |
| screenClip.y() + screenClip.height()); |
| |
| // In order to incorporate the animation delta X and Y, using the clip as |
| // the GL viewport can save all the trouble of re-position from screenRect |
| // to final position. |
| GLUtils::setOrthographicMatrix(m_clipProjectionMatrix, screenClip.x(), screenClip.y(), |
| screenClip.x() + screenClip.width(), |
| screenClip.y() + screenClip.height(), -1000, 1000); |
| |
| glViewport(screenClip.x(), m_targetHeight - screenClip.y() - screenClip.height() , |
| screenClip.width(), screenClip.height()); |
| |
| m_visibleContentRect = visibleContentRect; |
| m_currentScale = scale; |
| |
| |
| //// viewRect //// |
| m_invScreenRect = invScreenRect; |
| |
| // The following matrices transform content coordinates into view coordinates |
| // and inv view coordinates. |
| // Note that GLUtils::setOrthographicMatrix is inverting the Y. |
| TransformationMatrix viewTranslate; |
| viewTranslate.translate(1.0, 1.0); |
| |
| TransformationMatrix viewScale; |
| viewScale.scale3d(m_invScreenRect.width() * 0.5f, m_invScreenRect.height() * 0.5f, 1); |
| |
| m_contentToInvViewMatrix = viewScale * viewTranslate * m_visibleContentRectProjectionMatrix; |
| |
| viewTranslate.scale3d(1, -1, 1); |
| m_contentToViewMatrix = viewScale * viewTranslate * m_visibleContentRectProjectionMatrix; |
| |
| IntRect invViewRect(0, 0, m_screenRect.width(), m_screenRect.height()); |
| m_contentViewport = m_contentToInvViewMatrix.inverse().mapRect(invViewRect); |
| |
| |
| //// clipping //// |
| IntRect viewClip = screenClip; |
| |
| // The incoming screenClip is in screen coordinates, we first |
| // translate it into view coordinates. |
| // Then we convert it into inverted view coordinates. |
| // Therefore, in the clip() function, we need to convert things back from |
| // inverted view coordinates to inverted screen coordinates which is used by GL. |
| viewClip.setX(screenClip.x() - m_screenRect.x()); |
| viewClip.setY(screenClip.y() - m_screenRect.y() - m_titleBarHeight); |
| FloatRect invViewClip = convertViewCoordToInvViewCoord(viewClip); |
| m_invViewClip.setLocation(IntPoint(invViewClip.x(), invViewClip.y())); |
| // use ceilf to handle view -> doc -> view coord rounding errors |
| m_invViewClip.setSize(IntSize(ceilf(invViewClip.width()), ceilf(invViewClip.height()))); |
| |
| resetBlending(); |
| |
| // Set up m_clipProjectionMatrix, m_currentScale and m_webViewMatrix before |
| // calling this function. |
| setupSurfaceProjectionMatrix(); |
| |
| //// initialize frame-constant values //// |
| glActiveTexture(GL_TEXTURE0); |
| glBindBuffer(GL_ARRAY_BUFFER, m_textureBuffer[0]); |
| |
| //// initialize GL cache //// |
| m_cachedProgramType = UndefinedShader; |
| m_cachedOpacity = -1; |
| m_cachedFillPortion = FloatRect(); |
| m_cachedPureColor = Color(); |
| } |
| |
| // Calculate the right color value sent into the shader considering the (0,1) |
| // clamp and alpha blending. |
| Color ShaderProgram::shaderColor(Color pureColor, float opacity) |
| { |
| float r = pureColor.red() / 255.0; |
| float g = pureColor.green() / 255.0; |
| float b = pureColor.blue() / 255.0; |
| float a = pureColor.alpha() / 255.0; |
| |
| if (TilesManager::instance()->invertedScreen()) { |
| float intensity = a - (0.2989 * r + 0.5866 * g + 0.1145 * b); |
| intensity = ((intensity - a / 2.0) * m_contrast) + a / 2.0; |
| intensity *= opacity; |
| return Color(intensity, intensity, intensity, a * opacity); |
| } |
| return Color(r * opacity, g * opacity, b * opacity, a * opacity); |
| } |
| |
| // For shaders using texture, it is easy to get the type from the textureTarget. |
| ShaderType ShaderProgram::getTextureShaderType(GLenum textureTarget, |
| bool hasRepeatScale) |
| { |
| ShaderType type = UndefinedShader; |
| if (textureTarget == GL_TEXTURE_2D) { |
| if (!TilesManager::instance()->invertedScreen()) |
| type = hasRepeatScale ? RepeatTex : Tex2D; |
| else { |
| // With the new GPU texture upload path, we do not use an FBO |
| // to blit the texture we receive from the TexturesGenerator thread. |
| // To implement inverted rendering, we thus have to do the rendering |
| // live, by using a different shader. |
| type = hasRepeatScale ? RepeatTexInv : Tex2DInv; |
| } |
| } else if (textureTarget == GL_TEXTURE_EXTERNAL_OES) { |
| if (!TilesManager::instance()->invertedScreen()) |
| type = TexOES; |
| else |
| type = TexOESInv; |
| } |
| return type; |
| } |
| |
| // This function transform a clip rect extracted from the current layer |
| // into a clip rect in InvView coordinates -- used by the clipping rects |
| FloatRect ShaderProgram::rectInInvViewCoord(const TransformationMatrix& drawMatrix, const IntSize& size) |
| { |
| FloatRect srect(0, 0, size.width(), size.height()); |
| TransformationMatrix renderMatrix = m_contentToInvViewMatrix * drawMatrix; |
| return renderMatrix.mapRect(srect); |
| } |
| |
| // used by the partial screen invals |
| FloatRect ShaderProgram::rectInViewCoord(const TransformationMatrix& drawMatrix, const IntSize& size) |
| { |
| FloatRect srect(0, 0, size.width(), size.height()); |
| TransformationMatrix renderMatrix = m_contentToViewMatrix * drawMatrix; |
| return renderMatrix.mapRect(srect); |
| } |
| |
| FloatRect ShaderProgram::rectInViewCoord(const FloatRect& rect) |
| { |
| return m_contentToViewMatrix.mapRect(rect); |
| } |
| |
| FloatRect ShaderProgram::rectInInvViewCoord(const FloatRect& rect) |
| { |
| return m_contentToInvViewMatrix.mapRect(rect); |
| } |
| |
| FloatRect ShaderProgram::convertInvViewCoordToContentCoord(const FloatRect& rect) |
| { |
| return m_contentToInvViewMatrix.inverse().mapRect(rect); |
| } |
| |
| FloatRect ShaderProgram::convertViewCoordToInvViewCoord(const FloatRect& rect) |
| { |
| FloatRect visibleContentRect = m_contentToViewMatrix.inverse().mapRect(rect); |
| return rectInInvViewCoord(visibleContentRect); |
| } |
| |
| FloatRect ShaderProgram::convertInvViewCoordToViewCoord(const FloatRect& rect) |
| { |
| FloatRect visibleContentRect = m_contentToInvViewMatrix.inverse().mapRect(rect); |
| return rectInViewCoord(visibleContentRect); |
| } |
| |
| // clip is in screen coordinates |
| void ShaderProgram::clip(const FloatRect& clip) |
| { |
| if (clip == m_clipRect) |
| return; |
| |
| ALOGV("--clipping rect %f %f, %f x %f", |
| clip.x(), clip.y(), clip.width(), clip.height()); |
| |
| // we should only call glScissor in this function, so that we can easily |
| // track the current clipping rect. |
| |
| IntRect screenClip(clip.x(), |
| clip.y(), |
| clip.width(), clip.height()); |
| |
| if (!m_invViewClip.isEmpty()) |
| screenClip.intersect(m_invViewClip); |
| |
| // The previous intersection calculation is using local screen coordinates. |
| // Now we need to convert things from local screen coordinates to global |
| // screen coordinates and pass to the GL functions. |
| screenClip.setX(screenClip.x() + m_invScreenRect.x()); |
| screenClip.setY(screenClip.y() + m_invScreenRect.y()); |
| if (screenClip.x() < 0) { |
| int w = screenClip.width(); |
| w += screenClip.x(); |
| screenClip.setX(0); |
| screenClip.setWidth(w); |
| } |
| if (screenClip.y() < 0) { |
| int h = screenClip.height(); |
| h += screenClip.y(); |
| screenClip.setY(0); |
| screenClip.setHeight(h); |
| } |
| |
| glScissor(screenClip.x(), screenClip.y(), screenClip.width(), screenClip.height()); |
| |
| m_clipRect = clip; |
| } |
| |
| IntRect ShaderProgram::clippedRectWithVisibleContentRect(const IntRect& rect, int margin) |
| { |
| IntRect viewport(m_visibleContentRect.fLeft - margin, m_visibleContentRect.fTop - margin, |
| m_visibleContentRect.width() + margin, |
| m_visibleContentRect.height() + margin); |
| viewport.intersect(rect); |
| return viewport; |
| } |
| |
| float ShaderProgram::zValue(const TransformationMatrix& drawMatrix, float w, float h) |
| { |
| TransformationMatrix modifiedDrawMatrix = drawMatrix; |
| modifiedDrawMatrix.scale3d(w, h, 1); |
| TransformationMatrix renderMatrix = |
| m_visibleContentRectProjectionMatrix * modifiedDrawMatrix; |
| FloatPoint3D point(0.5, 0.5, 0.0); |
| FloatPoint3D result = renderMatrix.mapPoint(point); |
| return result.z(); |
| } |
| |
| void ShaderProgram::drawQuadInternal(ShaderType type, const GLfloat* matrix, |
| int textureId, float opacity, |
| GLenum textureTarget, GLenum filter, |
| const Color& pureColor, const FloatRect& fillPortion, |
| const FloatSize& repeatScale) |
| { |
| if (m_cachedProgramType != type) { |
| glUseProgram(m_handleArray[type].programHandle); |
| glVertexAttribPointer(m_handleArray[type].positionHandle, |
| 2, GL_FLOAT, GL_FALSE, 0, 0); |
| m_cachedProgramType = type; |
| m_cachedFillPortion = FloatRect(); |
| m_cachedOpacity = -1; // reset cache for variable shared by multiple programs |
| } |
| glUniformMatrix4fv(m_handleArray[type].projMtxHandle, 1, GL_FALSE, matrix); |
| |
| if (type != PureColor) { |
| glBindTexture(textureTarget, textureId); |
| glTexParameteri(textureTarget, GL_TEXTURE_MIN_FILTER, filter); |
| glTexParameteri(textureTarget, GL_TEXTURE_MAG_FILTER, filter); |
| |
| if (m_cachedOpacity != opacity) { |
| glUniform1f(m_handleArray[type].alphaHandle, opacity); |
| m_cachedOpacity = opacity; |
| } |
| |
| GLint contrastHandle = m_handleArray[type].contrastHandle; |
| if (contrastHandle != -1) |
| glUniform1f(contrastHandle, m_contrast); |
| |
| if (m_cachedFillPortion != fillPortion) { |
| glUniform4f(m_handleArray[type].fillPortionHandle, fillPortion.x(), fillPortion.y(), |
| fillPortion.width(), fillPortion.height()); |
| m_cachedFillPortion = fillPortion; |
| } |
| |
| // Only when we have repeat scale, this handle can be >= 0; |
| if (m_handleArray[type].scaleHandle != -1) { |
| glUniform2f(m_handleArray[type].scaleHandle, |
| repeatScale.width(), repeatScale.height()); |
| } |
| } else { |
| if (m_cachedPureColor != pureColor) { |
| glUniform4f(m_handleArray[type].pureColorHandle, |
| pureColor.red() / 255.0, pureColor.green() / 255.0, |
| pureColor.blue() / 255.0, pureColor.alpha() / 255.0); |
| m_cachedPureColor = pureColor; |
| } |
| } |
| |
| glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); |
| } |
| |
| // Put the common matrix computation at higher level to avoid redundancy. |
| void ShaderProgram::setupSurfaceProjectionMatrix() |
| { |
| TransformationMatrix scaleMatrix; |
| scaleMatrix.scale3d(m_currentScale, m_currentScale, 1); |
| m_surfaceProjectionMatrix = m_clipProjectionMatrix * m_webViewMatrix * scaleMatrix; |
| } |
| |
| // Calculate the matrix given the geometry. |
| GLfloat* ShaderProgram::getTileProjectionMatrix(const DrawQuadData* data) |
| { |
| DrawQuadType type = data->type(); |
| if (type == Blit) |
| return m_transferProjMtx; |
| |
| const TransformationMatrix* matrix = data->drawMatrix(); |
| const SkRect* geometry = data->geometry(); |
| FloatRect fillPortion = data->fillPortion(); |
| ALOGV("fillPortion " FLOAT_RECT_FORMAT, FLOAT_RECT_ARGS(fillPortion)); |
| |
| // This modifiedDrawMatrix tranform (0,0)(1x1) to the final rect in screen |
| // coordinates, before applying the m_webViewMatrix. |
| // It first scale and translate the vertex array from (0,0)(1x1) to real |
| // tile position and size. Then apply the transform from the layer's. |
| // Finally scale to the currentScale to support zooming. |
| // Note the geometry contains the tile zoom scale, so visually we will see |
| // the tiles scale at a ratio as (m_currentScale/tile's scale). |
| TransformationMatrix modifiedDrawMatrix; |
| if (type == LayerQuad) |
| modifiedDrawMatrix = *matrix; |
| modifiedDrawMatrix.translate(geometry->fLeft + geometry->width() * fillPortion.x(), |
| geometry->fTop + geometry->height() * fillPortion.y()); |
| modifiedDrawMatrix.scale3d(geometry->width() * fillPortion.width(), |
| geometry->height() * fillPortion.height(), 1); |
| |
| // Even when we are on a alpha layer or not, we need to respect the |
| // m_webViewMatrix, it may contain the layout offset. Normally it is |
| // identity. |
| TransformationMatrix renderMatrix; |
| renderMatrix = m_surfaceProjectionMatrix * modifiedDrawMatrix; |
| |
| #if DEBUG_MATRIX |
| debugMatrixInfo(m_currentScale, m_clipProjectionMatrix, m_webViewMatrix, |
| modifiedDrawMatrix, matrix); |
| #endif |
| |
| GLUtils::toGLMatrix(m_tileProjMatrix, renderMatrix); |
| return m_tileProjMatrix; |
| } |
| |
| void ShaderProgram::drawQuad(const DrawQuadData* data) |
| { |
| GLfloat* matrix = getTileProjectionMatrix(data); |
| |
| float opacity = data->opacity(); |
| bool forceBlending = data->forceBlending(); |
| bool enableBlending = forceBlending || opacity < 1.0; |
| |
| ShaderType shaderType = UndefinedShader; |
| int textureId = 0; |
| GLint textureFilter = 0; |
| GLenum textureTarget = 0; |
| |
| Color quadColor = data->quadColor(); |
| if (data->pureColor()) { |
| shaderType = PureColor; |
| quadColor = shaderColor(quadColor, opacity); |
| enableBlending = enableBlending || quadColor.hasAlpha(); |
| if (!quadColor.alpha() && enableBlending) |
| return; |
| } else { |
| textureId = data->textureId(); |
| textureFilter = data->textureFilter(); |
| textureTarget = data->textureTarget(); |
| shaderType = getTextureShaderType(textureTarget, data->hasRepeatScale()); |
| } |
| setBlendingState(enableBlending); |
| drawQuadInternal(shaderType, matrix, textureId, opacity, |
| textureTarget, textureFilter, quadColor, data->fillPortion(), |
| data->repeatScale()); |
| } |
| |
| void ShaderProgram::drawVideoLayerQuad(const TransformationMatrix& drawMatrix, |
| float* textureMatrix, SkRect& geometry, |
| int textureId) |
| { |
| // switch to our custom yuv video rendering program |
| if (m_cachedProgramType != Video) { |
| glUseProgram(m_handleArray[Video].programHandle); |
| glVertexAttribPointer(m_handleArray[Video].positionHandle, |
| 2, GL_FLOAT, GL_FALSE, 0, 0); |
| m_cachedProgramType = Video; |
| } |
| |
| // TODO: Merge drawVideoLayerQuad into drawQuad. |
| TransformationMatrix modifiedDrawMatrix; |
| modifiedDrawMatrix.scale3d(m_currentScale, m_currentScale, 1); |
| modifiedDrawMatrix.multiply(drawMatrix); |
| modifiedDrawMatrix.translate(geometry.fLeft, geometry.fTop); |
| modifiedDrawMatrix.scale3d(geometry.width(), geometry.height(), 1); |
| TransformationMatrix renderMatrix = |
| m_clipProjectionMatrix * m_webViewMatrix * modifiedDrawMatrix; |
| |
| GLfloat projectionMatrix[16]; |
| GLUtils::toGLMatrix(projectionMatrix, renderMatrix); |
| glUniformMatrix4fv(m_handleArray[Video].projMtxHandle, 1, GL_FALSE, |
| projectionMatrix); |
| glUniformMatrix4fv(m_handleArray[Video].videoMtxHandle, 1, GL_FALSE, |
| textureMatrix); |
| glBindTexture(GL_TEXTURE_EXTERNAL_OES, textureId); |
| |
| setBlendingState(false); |
| glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); |
| } |
| |
| void ShaderProgram::setGLDrawInfo(const android::uirenderer::DrawGlInfo* info) |
| { |
| GLUtils::convertToTransformationMatrix(info->transform, m_webViewMatrix); |
| m_alphaLayer = info->isLayer; |
| m_targetHeight = info->height; |
| } |
| |
| // This function is called per tileGrid to minimize the computation overhead. |
| // The ortho projection and glViewport will map 1:1, so we don't need to |
| // worry about them here. Basically, if the current zoom scale / tile's scale |
| // plus the webview and layer transformation ends up at scale factor 1.0, |
| // then we can use point sampling. |
| bool ShaderProgram::usePointSampling(float tileScale, |
| const TransformationMatrix* layerTransform) |
| { |
| const float testSize = 1.0; |
| FloatRect rect(0, 0, testSize, testSize); |
| TransformationMatrix matrix; |
| matrix.scale3d(m_currentScale, m_currentScale, 1); |
| if (layerTransform) |
| matrix.multiply(*layerTransform); |
| matrix.scale3d(1.0 / tileScale, 1.0 / tileScale, 1); |
| |
| matrix = m_webViewMatrix * matrix; |
| |
| rect = matrix.mapRect(rect); |
| |
| float deltaWidth = abs(rect.width() - testSize); |
| float deltaHeight = abs(rect.height() - testSize); |
| |
| if (deltaWidth < EPSILON && deltaHeight < EPSILON) { |
| ALOGV("Point sampling : deltaWidth is %f, deltaHeight is %f", deltaWidth, deltaHeight); |
| return true; |
| } |
| return false; |
| } |
| |
| #if DEBUG_MATRIX |
| FloatRect ShaderProgram::debugMatrixTransform(const TransformationMatrix& matrix, |
| const char* matrixName) |
| { |
| FloatRect rect(0.0, 0.0, 1.0, 1.0); |
| rect = matrix.mapRect(rect); |
| ALOGV("After %s matrix:\n %f, %f rect.width() %f rect.height() %f", |
| matrixName, rect.x(), rect.y(), rect.width(), rect.height()); |
| return rect; |
| |
| } |
| |
| void ShaderProgram::debugMatrixInfo(float currentScale, |
| const TransformationMatrix& clipProjectionMatrix, |
| const TransformationMatrix& webViewMatrix, |
| const TransformationMatrix& modifiedDrawMatrix, |
| const TransformationMatrix* layerMatrix) |
| { |
| int viewport[4]; |
| glGetIntegerv(GL_VIEWPORT, viewport); |
| ALOGV("viewport %d, %d, %d, %d , currentScale %f", |
| viewport[0], viewport[1], viewport[2], viewport[3], currentScale); |
| IntRect currentGLViewport(viewport[0], viewport[1], viewport[2], viewport[3]); |
| |
| TransformationMatrix scaleMatrix; |
| scaleMatrix.scale3d(currentScale, currentScale, 1.0); |
| |
| if (layerMatrix) |
| debugMatrixTransform(*layerMatrix, "layerMatrix"); |
| |
| TransformationMatrix debugMatrix = scaleMatrix * modifiedDrawMatrix; |
| debugMatrixTransform(debugMatrix, "scaleMatrix * modifiedDrawMatrix"); |
| |
| debugMatrix = webViewMatrix * debugMatrix; |
| debugMatrixTransform(debugMatrix, "webViewMatrix * scaleMatrix * modifiedDrawMatrix"); |
| |
| debugMatrix = clipProjectionMatrix * debugMatrix; |
| FloatRect finalRect = |
| debugMatrixTransform(debugMatrix, "all Matrix"); |
| // After projection, we will be in a (-1, 1) range and now we can map it back |
| // to the (x,y) -> (x+width, y+height) |
| ALOGV("final convert to screen coord x, y %f, %f width %f height %f , ", |
| (finalRect.x() + 1) / 2 * currentGLViewport.width() + currentGLViewport.x(), |
| (finalRect.y() + 1) / 2 * currentGLViewport.height() + currentGLViewport.y(), |
| finalRect.width() * currentGLViewport.width() / 2, |
| finalRect.height() * currentGLViewport.height() / 2); |
| } |
| #endif // DEBUG_MATRIX |
| |
| } // namespace WebCore |
| #endif // USE(ACCELERATED_COMPOSITING) |
