Romain Guy | e4d0112 | 2010-06-16 18:44:05 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2010 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
Romain Guy | 85bf02f | 2010-06-22 13:11:24 -0700 | [diff] [blame] | 17 | #define LOG_TAG "OpenGLRenderer" |
Romain Guy | e4d0112 | 2010-06-16 18:44:05 -0700 | [diff] [blame] | 18 | |
| 19 | #include <stdlib.h> |
| 20 | #include <stdint.h> |
| 21 | #include <sys/types.h> |
| 22 | |
Romain Guy | 5cbbce5 | 2010-06-27 22:59:20 -0700 | [diff] [blame] | 23 | #include <SkCanvas.h> |
Romain Guy | 03d5852 | 2012-02-24 17:54:07 -0800 | [diff] [blame] | 24 | #include <SkPathMeasure.h> |
Romain Guy | 694b519 | 2010-07-21 21:33:20 -0700 | [diff] [blame] | 25 | #include <SkTypeface.h> |
Romain Guy | 5cbbce5 | 2010-06-27 22:59:20 -0700 | [diff] [blame] | 26 | |
Romain Guy | e4d0112 | 2010-06-16 18:44:05 -0700 | [diff] [blame] | 27 | #include <utils/Log.h> |
Romain Guy | e2d345e | 2010-09-24 18:39:22 -0700 | [diff] [blame] | 28 | #include <utils/StopWatch.h> |
Romain Guy | e4d0112 | 2010-06-16 18:44:05 -0700 | [diff] [blame] | 29 | |
Romain Guy | 08aa2cb | 2011-03-17 11:06:57 -0700 | [diff] [blame] | 30 | #include <private/hwui/DrawGlInfo.h> |
| 31 | |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 32 | #include <ui/Rect.h> |
| 33 | |
Romain Guy | 85bf02f | 2010-06-22 13:11:24 -0700 | [diff] [blame] | 34 | #include "OpenGLRenderer.h" |
Romain Guy | 0fe478e | 2010-11-08 12:08:41 -0800 | [diff] [blame] | 35 | #include "DisplayListRenderer.h" |
Romain Guy | a957eea | 2010-12-08 18:34:42 -0800 | [diff] [blame] | 36 | #include "Vector.h" |
Romain Guy | e4d0112 | 2010-06-16 18:44:05 -0700 | [diff] [blame] | 37 | |
| 38 | namespace android { |
Romain Guy | 9d5316e | 2010-06-24 19:30:36 -0700 | [diff] [blame] | 39 | namespace uirenderer { |
| 40 | |
| 41 | /////////////////////////////////////////////////////////////////////////////// |
| 42 | // Defines |
| 43 | /////////////////////////////////////////////////////////////////////////////// |
| 44 | |
Romain Guy | 759ea80 | 2010-09-16 20:49:46 -0700 | [diff] [blame] | 45 | #define RAD_TO_DEG (180.0f / 3.14159265f) |
| 46 | #define MIN_ANGLE 0.001f |
| 47 | |
Romain Guy | dbc26d2 | 2010-10-11 17:58:29 -0700 | [diff] [blame] | 48 | // TODO: This should be set in properties |
| 49 | #define ALPHA_THRESHOLD (0x7f / PANEL_BIT_DEPTH) |
| 50 | |
Romain Guy | d21b6e1 | 2011-11-30 20:21:23 -0800 | [diff] [blame] | 51 | #define FILTER(paint) (paint && paint->isFilterBitmap() ? GL_LINEAR : GL_NEAREST) |
| 52 | |
Romain Guy | 9d5316e | 2010-06-24 19:30:36 -0700 | [diff] [blame] | 53 | /////////////////////////////////////////////////////////////////////////////// |
| 54 | // Globals |
| 55 | /////////////////////////////////////////////////////////////////////////////// |
| 56 | |
Romain Guy | 889f8d1 | 2010-07-29 14:37:42 -0700 | [diff] [blame] | 57 | /** |
| 58 | * Structure mapping Skia xfermodes to OpenGL blending factors. |
| 59 | */ |
| 60 | struct Blender { |
| 61 | SkXfermode::Mode mode; |
| 62 | GLenum src; |
| 63 | GLenum dst; |
| 64 | }; // struct Blender |
| 65 | |
Romain Guy | 026c5e16 | 2010-06-28 17:12:22 -0700 | [diff] [blame] | 66 | // In this array, the index of each Blender equals the value of the first |
| 67 | // entry. For instance, gBlends[1] == gBlends[SkXfermode::kSrc_Mode] |
| 68 | static const Blender gBlends[] = { |
Romain Guy | 2ffefd4 | 2011-09-08 15:33:03 -0700 | [diff] [blame] | 69 | { SkXfermode::kClear_Mode, GL_ZERO, GL_ONE_MINUS_SRC_ALPHA }, |
| 70 | { SkXfermode::kSrc_Mode, GL_ONE, GL_ZERO }, |
| 71 | { SkXfermode::kDst_Mode, GL_ZERO, GL_ONE }, |
| 72 | { SkXfermode::kSrcOver_Mode, GL_ONE, GL_ONE_MINUS_SRC_ALPHA }, |
| 73 | { SkXfermode::kDstOver_Mode, GL_ONE_MINUS_DST_ALPHA, GL_ONE }, |
| 74 | { SkXfermode::kSrcIn_Mode, GL_DST_ALPHA, GL_ZERO }, |
| 75 | { SkXfermode::kDstIn_Mode, GL_ZERO, GL_SRC_ALPHA }, |
| 76 | { SkXfermode::kSrcOut_Mode, GL_ONE_MINUS_DST_ALPHA, GL_ZERO }, |
| 77 | { SkXfermode::kDstOut_Mode, GL_ZERO, GL_ONE_MINUS_SRC_ALPHA }, |
| 78 | { SkXfermode::kSrcATop_Mode, GL_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA }, |
| 79 | { SkXfermode::kDstATop_Mode, GL_ONE_MINUS_DST_ALPHA, GL_SRC_ALPHA }, |
| 80 | { SkXfermode::kXor_Mode, GL_ONE_MINUS_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA }, |
| 81 | { SkXfermode::kPlus_Mode, GL_ONE, GL_ONE }, |
| 82 | { SkXfermode::kMultiply_Mode, GL_ZERO, GL_SRC_COLOR }, |
| 83 | { SkXfermode::kScreen_Mode, GL_ONE, GL_ONE_MINUS_SRC_COLOR } |
Romain Guy | 026c5e16 | 2010-06-28 17:12:22 -0700 | [diff] [blame] | 84 | }; |
Romain Guy | e4d0112 | 2010-06-16 18:44:05 -0700 | [diff] [blame] | 85 | |
Romain Guy | 87a7657 | 2010-09-13 18:11:21 -0700 | [diff] [blame] | 86 | // This array contains the swapped version of each SkXfermode. For instance |
| 87 | // this array's SrcOver blending mode is actually DstOver. You can refer to |
| 88 | // createLayer() for more information on the purpose of this array. |
Romain Guy | f607bdc | 2010-09-10 19:20:06 -0700 | [diff] [blame] | 89 | static const Blender gBlendsSwap[] = { |
Romain Guy | 2ffefd4 | 2011-09-08 15:33:03 -0700 | [diff] [blame] | 90 | { SkXfermode::kClear_Mode, GL_ONE_MINUS_DST_ALPHA, GL_ZERO }, |
| 91 | { SkXfermode::kSrc_Mode, GL_ZERO, GL_ONE }, |
| 92 | { SkXfermode::kDst_Mode, GL_ONE, GL_ZERO }, |
| 93 | { SkXfermode::kSrcOver_Mode, GL_ONE_MINUS_DST_ALPHA, GL_ONE }, |
| 94 | { SkXfermode::kDstOver_Mode, GL_ONE, GL_ONE_MINUS_SRC_ALPHA }, |
| 95 | { SkXfermode::kSrcIn_Mode, GL_ZERO, GL_SRC_ALPHA }, |
| 96 | { SkXfermode::kDstIn_Mode, GL_DST_ALPHA, GL_ZERO }, |
| 97 | { SkXfermode::kSrcOut_Mode, GL_ZERO, GL_ONE_MINUS_SRC_ALPHA }, |
| 98 | { SkXfermode::kDstOut_Mode, GL_ONE_MINUS_DST_ALPHA, GL_ZERO }, |
| 99 | { SkXfermode::kSrcATop_Mode, GL_ONE_MINUS_DST_ALPHA, GL_SRC_ALPHA }, |
| 100 | { SkXfermode::kDstATop_Mode, GL_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA }, |
| 101 | { SkXfermode::kXor_Mode, GL_ONE_MINUS_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA }, |
| 102 | { SkXfermode::kPlus_Mode, GL_ONE, GL_ONE }, |
| 103 | { SkXfermode::kMultiply_Mode, GL_DST_COLOR, GL_ZERO }, |
| 104 | { SkXfermode::kScreen_Mode, GL_ONE_MINUS_DST_COLOR, GL_ONE } |
Romain Guy | f607bdc | 2010-09-10 19:20:06 -0700 | [diff] [blame] | 105 | }; |
| 106 | |
Romain Guy | f6a11b8 | 2010-06-23 17:47:49 -0700 | [diff] [blame] | 107 | /////////////////////////////////////////////////////////////////////////////// |
| 108 | // Constructors/destructor |
| 109 | /////////////////////////////////////////////////////////////////////////////// |
| 110 | |
Romain Guy | fb8b763 | 2010-08-23 21:05:08 -0700 | [diff] [blame] | 111 | OpenGLRenderer::OpenGLRenderer(): mCaches(Caches::getInstance()) { |
Romain Guy | 06f96e2 | 2010-07-30 19:18:16 -0700 | [diff] [blame] | 112 | mShader = NULL; |
Romain Guy | db1938e | 2010-08-02 18:50:22 -0700 | [diff] [blame] | 113 | mColorFilter = NULL; |
Romain Guy | 1e45aae | 2010-08-13 19:39:53 -0700 | [diff] [blame] | 114 | mHasShadow = false; |
Romain Guy | 5ff9df6 | 2012-01-23 17:09:05 -0800 | [diff] [blame] | 115 | mHasDrawFilter = false; |
Romain Guy | 026c5e16 | 2010-06-28 17:12:22 -0700 | [diff] [blame] | 116 | |
Romain Guy | ac670c0 | 2010-07-27 17:39:27 -0700 | [diff] [blame] | 117 | memcpy(mMeshVertices, gMeshVertices, sizeof(gMeshVertices)); |
| 118 | |
Romain Guy | ae5575b | 2010-07-29 18:48:04 -0700 | [diff] [blame] | 119 | mFirstSnapshot = new Snapshot; |
Romain Guy | e4d0112 | 2010-06-16 18:44:05 -0700 | [diff] [blame] | 120 | } |
| 121 | |
Romain Guy | 85bf02f | 2010-06-22 13:11:24 -0700 | [diff] [blame] | 122 | OpenGLRenderer::~OpenGLRenderer() { |
Romain Guy | 29d8997 | 2010-09-22 16:10:57 -0700 | [diff] [blame] | 123 | // The context has already been destroyed at this point, do not call |
| 124 | // GL APIs. All GL state should be kept in Caches.h |
Romain Guy | e4d0112 | 2010-06-16 18:44:05 -0700 | [diff] [blame] | 125 | } |
| 126 | |
Romain Guy | f6a11b8 | 2010-06-23 17:47:49 -0700 | [diff] [blame] | 127 | /////////////////////////////////////////////////////////////////////////////// |
Romain Guy | 13631f3 | 2012-01-30 17:41:55 -0800 | [diff] [blame] | 128 | // Debug |
| 129 | /////////////////////////////////////////////////////////////////////////////// |
| 130 | |
| 131 | void OpenGLRenderer::startMark(const char* name) const { |
| 132 | mCaches.startMark(0, name); |
| 133 | } |
| 134 | |
| 135 | void OpenGLRenderer::endMark() const { |
| 136 | mCaches.endMark(); |
| 137 | } |
| 138 | |
| 139 | /////////////////////////////////////////////////////////////////////////////// |
Romain Guy | f6a11b8 | 2010-06-23 17:47:49 -0700 | [diff] [blame] | 140 | // Setup |
| 141 | /////////////////////////////////////////////////////////////////////////////// |
| 142 | |
Romain Guy | 530041d | 2012-01-25 18:56:29 -0800 | [diff] [blame] | 143 | uint32_t OpenGLRenderer::getStencilSize() { |
| 144 | return STENCIL_BUFFER_SIZE; |
| 145 | } |
| 146 | |
Romain Guy | 85bf02f | 2010-06-22 13:11:24 -0700 | [diff] [blame] | 147 | void OpenGLRenderer::setViewport(int width, int height) { |
Romain Guy | 260e102 | 2010-07-12 14:41:06 -0700 | [diff] [blame] | 148 | mOrthoMatrix.loadOrtho(0, width, height, 0, -1, 1); |
Romain Guy | bb9524b | 2010-06-22 18:56:38 -0700 | [diff] [blame] | 149 | |
| 150 | mWidth = width; |
| 151 | mHeight = height; |
Romain Guy | eb99356 | 2010-10-05 18:14:38 -0700 | [diff] [blame] | 152 | |
| 153 | mFirstSnapshot->height = height; |
| 154 | mFirstSnapshot->viewport.set(0, 0, width, height); |
Romain Guy | 746b740 | 2010-10-26 16:27:31 -0700 | [diff] [blame] | 155 | |
Romain Guy | 3e263fa | 2011-12-12 16:47:48 -0800 | [diff] [blame] | 156 | glDisable(GL_DITHER); |
Romain Guy | 39d252a | 2011-12-12 18:14:06 -0800 | [diff] [blame] | 157 | glEnable(GL_SCISSOR_TEST); |
Romain Guy | 3e263fa | 2011-12-12 16:47:48 -0800 | [diff] [blame] | 158 | glClearColor(0.0f, 0.0f, 0.0f, 0.0f); |
Romain Guy | 15bc643 | 2011-12-13 13:11:32 -0800 | [diff] [blame] | 159 | |
Romain Guy | 3e263fa | 2011-12-12 16:47:48 -0800 | [diff] [blame] | 160 | glEnableVertexAttribArray(Program::kBindingPosition); |
Romain Guy | e4d0112 | 2010-06-16 18:44:05 -0700 | [diff] [blame] | 161 | } |
| 162 | |
Romain Guy | 6b7bd24 | 2010-10-06 19:49:23 -0700 | [diff] [blame] | 163 | void OpenGLRenderer::prepare(bool opaque) { |
Romain Guy | 7d7b549 | 2011-01-24 16:33:45 -0800 | [diff] [blame] | 164 | prepareDirty(0.0f, 0.0f, mWidth, mHeight, opaque); |
| 165 | } |
| 166 | |
| 167 | void OpenGLRenderer::prepareDirty(float left, float top, float right, float bottom, bool opaque) { |
Romain Guy | fe48f65 | 2010-11-11 15:36:56 -0800 | [diff] [blame] | 168 | mCaches.clearGarbage(); |
| 169 | |
Romain Guy | 8aef54f | 2010-09-01 15:13:49 -0700 | [diff] [blame] | 170 | mSnapshot = new Snapshot(mFirstSnapshot, |
| 171 | SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag); |
Romain Guy | 84962f2 | 2011-03-02 15:43:44 -0800 | [diff] [blame] | 172 | mSnapshot->fbo = getTargetFbo(); |
Romain Guy | 8fb9542 | 2010-08-17 18:38:51 -0700 | [diff] [blame] | 173 | mSaveCount = 1; |
Romain Guy | f6a11b8 | 2010-06-23 17:47:49 -0700 | [diff] [blame] | 174 | |
Romain Guy | 39d252a | 2011-12-12 18:14:06 -0800 | [diff] [blame] | 175 | glViewport(0, 0, mWidth, mHeight); |
Romain Guy | 8f85e80 | 2011-12-14 19:23:32 -0800 | [diff] [blame] | 176 | mCaches.setScissor(left, mSnapshot->height - bottom, right - left, bottom - top); |
Romain Guy | 39d252a | 2011-12-12 18:14:06 -0800 | [diff] [blame] | 177 | |
Romain Guy | 7d7b549 | 2011-01-24 16:33:45 -0800 | [diff] [blame] | 178 | mSnapshot->setClip(left, top, right, bottom); |
Romain Guy | 39d252a | 2011-12-12 18:14:06 -0800 | [diff] [blame] | 179 | mDirtyClip = false; |
Romain Guy | 7d7b549 | 2011-01-24 16:33:45 -0800 | [diff] [blame] | 180 | |
Romain Guy | 6b7bd24 | 2010-10-06 19:49:23 -0700 | [diff] [blame] | 181 | if (!opaque) { |
Romain Guy | 6b7bd24 | 2010-10-06 19:49:23 -0700 | [diff] [blame] | 182 | glClear(GL_COLOR_BUFFER_BIT); |
| 183 | } |
Romain Guy | bb9524b | 2010-06-22 18:56:38 -0700 | [diff] [blame] | 184 | } |
| 185 | |
Romain Guy | b025b9c | 2010-09-16 14:16:48 -0700 | [diff] [blame] | 186 | void OpenGLRenderer::finish() { |
| 187 | #if DEBUG_OPENGL |
| 188 | GLenum status = GL_NO_ERROR; |
| 189 | while ((status = glGetError()) != GL_NO_ERROR) { |
Steve Block | 5baa3a6 | 2011-12-20 16:23:08 +0000 | [diff] [blame] | 190 | ALOGD("GL error from OpenGLRenderer: 0x%x", status); |
Romain Guy | a07105b | 2011-01-10 21:14:18 -0800 | [diff] [blame] | 191 | switch (status) { |
| 192 | case GL_OUT_OF_MEMORY: |
Steve Block | 3762c31 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 193 | ALOGE(" OpenGLRenderer is out of memory!"); |
Romain Guy | a07105b | 2011-01-10 21:14:18 -0800 | [diff] [blame] | 194 | break; |
| 195 | } |
Romain Guy | b025b9c | 2010-09-16 14:16:48 -0700 | [diff] [blame] | 196 | } |
| 197 | #endif |
Romain Guy | c15008e | 2010-11-10 11:59:15 -0800 | [diff] [blame] | 198 | #if DEBUG_MEMORY_USAGE |
| 199 | mCaches.dumpMemoryUsage(); |
Romain Guy | e190aa6 | 2010-11-10 19:01:29 -0800 | [diff] [blame] | 200 | #else |
| 201 | if (mCaches.getDebugLevel() & kDebugMemory) { |
| 202 | mCaches.dumpMemoryUsage(); |
| 203 | } |
Romain Guy | c15008e | 2010-11-10 11:59:15 -0800 | [diff] [blame] | 204 | #endif |
Romain Guy | b025b9c | 2010-09-16 14:16:48 -0700 | [diff] [blame] | 205 | } |
| 206 | |
Romain Guy | 6c319ca | 2011-01-11 14:29:25 -0800 | [diff] [blame] | 207 | void OpenGLRenderer::interrupt() { |
Romain Guy | da8532c | 2010-08-31 11:50:35 -0700 | [diff] [blame] | 208 | if (mCaches.currentProgram) { |
| 209 | if (mCaches.currentProgram->isInUse()) { |
| 210 | mCaches.currentProgram->remove(); |
| 211 | mCaches.currentProgram = NULL; |
| 212 | } |
| 213 | } |
Romain Guy | 50c0f09 | 2010-10-19 11:42:22 -0700 | [diff] [blame] | 214 | mCaches.unbindMeshBuffer(); |
Romain Guy | 15bc643 | 2011-12-13 13:11:32 -0800 | [diff] [blame] | 215 | mCaches.unbindIndicesBuffer(); |
Romain Guy | f3a910b4 | 2011-12-12 20:35:21 -0800 | [diff] [blame] | 216 | mCaches.resetVertexPointers(); |
Romain Guy | 15bc643 | 2011-12-13 13:11:32 -0800 | [diff] [blame] | 217 | mCaches.disbaleTexCoordsVertexArray(); |
Romain Guy | da8532c | 2010-08-31 11:50:35 -0700 | [diff] [blame] | 218 | } |
| 219 | |
Romain Guy | 6c319ca | 2011-01-11 14:29:25 -0800 | [diff] [blame] | 220 | void OpenGLRenderer::resume() { |
Chet Haase | 08837c2 | 2011-11-28 11:53:21 -0800 | [diff] [blame] | 221 | sp<Snapshot> snapshot = (mSnapshot != NULL) ? mSnapshot : mFirstSnapshot; |
| 222 | |
| 223 | glViewport(0, 0, snapshot->viewport.getWidth(), snapshot->viewport.getHeight()); |
Romain Guy | 3e263fa | 2011-12-12 16:47:48 -0800 | [diff] [blame] | 224 | glClearColor(0.0f, 0.0f, 0.0f, 0.0f); |
| 225 | |
Romain Guy | da8532c | 2010-08-31 11:50:35 -0700 | [diff] [blame] | 226 | glEnable(GL_SCISSOR_TEST); |
Romain Guy | 82bc7a7 | 2012-01-03 14:13:39 -0800 | [diff] [blame] | 227 | mCaches.resetScissor(); |
Romain Guy | 746b740 | 2010-10-26 16:27:31 -0700 | [diff] [blame] | 228 | dirtyClip(); |
Romain Guy | da8532c | 2010-08-31 11:50:35 -0700 | [diff] [blame] | 229 | |
Romain Guy | a1d3c91 | 2011-12-13 14:55:06 -0800 | [diff] [blame] | 230 | mCaches.activeTexture(0); |
Chet Haase | 08837c2 | 2011-11-28 11:53:21 -0800 | [diff] [blame] | 231 | glBindFramebuffer(GL_FRAMEBUFFER, snapshot->fbo); |
Romain Guy | f607bdc | 2010-09-10 19:20:06 -0700 | [diff] [blame] | 232 | |
Romain Guy | 50c0f09 | 2010-10-19 11:42:22 -0700 | [diff] [blame] | 233 | mCaches.blend = true; |
| 234 | glEnable(GL_BLEND); |
| 235 | glBlendFunc(mCaches.lastSrcMode, mCaches.lastDstMode); |
| 236 | glBlendEquation(GL_FUNC_ADD); |
Romain Guy | da8532c | 2010-08-31 11:50:35 -0700 | [diff] [blame] | 237 | } |
| 238 | |
Romain Guy | 6554943 | 2012-03-26 16:45:05 -0700 | [diff] [blame] | 239 | status_t OpenGLRenderer::callDrawGLFunction(Functor *functor, Rect& dirty) { |
Chet Haase | daf98e9 | 2011-01-10 14:10:36 -0800 | [diff] [blame] | 240 | interrupt(); |
Romain Guy | f90f817 | 2011-01-25 22:53:24 -0800 | [diff] [blame] | 241 | if (mDirtyClip) { |
| 242 | setScissorFromClip(); |
| 243 | } |
Romain Guy | d643bb5 | 2011-03-01 14:55:21 -0800 | [diff] [blame] | 244 | |
Romain Guy | 80911b8 | 2011-03-16 15:30:12 -0700 | [diff] [blame] | 245 | Rect clip(*mSnapshot->clipRect); |
| 246 | clip.snapToPixelBoundaries(); |
| 247 | |
Romain Guy | d643bb5 | 2011-03-01 14:55:21 -0800 | [diff] [blame] | 248 | #if RENDER_LAYERS_AS_REGIONS |
| 249 | // Since we don't know what the functor will draw, let's dirty |
| 250 | // tne entire clip region |
| 251 | if (hasLayer()) { |
Romain Guy | d643bb5 | 2011-03-01 14:55:21 -0800 | [diff] [blame] | 252 | dirtyLayerUnchecked(clip, getRegion()); |
| 253 | } |
| 254 | #endif |
| 255 | |
Romain Guy | 08aa2cb | 2011-03-17 11:06:57 -0700 | [diff] [blame] | 256 | DrawGlInfo info; |
| 257 | info.clipLeft = clip.left; |
| 258 | info.clipTop = clip.top; |
| 259 | info.clipRight = clip.right; |
| 260 | info.clipBottom = clip.bottom; |
| 261 | info.isLayer = hasLayer(); |
| 262 | getSnapshot()->transform->copyTo(&info.transform[0]); |
Romain Guy | 80911b8 | 2011-03-16 15:30:12 -0700 | [diff] [blame] | 263 | |
Romain Guy | 08aa2cb | 2011-03-17 11:06:57 -0700 | [diff] [blame] | 264 | status_t result = (*functor)(0, &info); |
Romain Guy | cabfcc1 | 2011-03-07 18:06:46 -0800 | [diff] [blame] | 265 | |
| 266 | if (result != 0) { |
Romain Guy | 08aa2cb | 2011-03-17 11:06:57 -0700 | [diff] [blame] | 267 | Rect localDirty(info.dirtyLeft, info.dirtyTop, info.dirtyRight, info.dirtyBottom); |
Romain Guy | cabfcc1 | 2011-03-07 18:06:46 -0800 | [diff] [blame] | 268 | dirty.unionWith(localDirty); |
| 269 | } |
| 270 | |
Chet Haase | daf98e9 | 2011-01-10 14:10:36 -0800 | [diff] [blame] | 271 | resume(); |
Romain Guy | 6554943 | 2012-03-26 16:45:05 -0700 | [diff] [blame] | 272 | return result; |
Chet Haase | daf98e9 | 2011-01-10 14:10:36 -0800 | [diff] [blame] | 273 | } |
| 274 | |
Romain Guy | f6a11b8 | 2010-06-23 17:47:49 -0700 | [diff] [blame] | 275 | /////////////////////////////////////////////////////////////////////////////// |
| 276 | // State management |
| 277 | /////////////////////////////////////////////////////////////////////////////// |
| 278 | |
Romain Guy | bb9524b | 2010-06-22 18:56:38 -0700 | [diff] [blame] | 279 | int OpenGLRenderer::getSaveCount() const { |
Romain Guy | 7ae7ac4 | 2010-06-25 13:46:18 -0700 | [diff] [blame] | 280 | return mSaveCount; |
Romain Guy | bb9524b | 2010-06-22 18:56:38 -0700 | [diff] [blame] | 281 | } |
| 282 | |
| 283 | int OpenGLRenderer::save(int flags) { |
Romain Guy | 8aef54f | 2010-09-01 15:13:49 -0700 | [diff] [blame] | 284 | return saveSnapshot(flags); |
Romain Guy | bb9524b | 2010-06-22 18:56:38 -0700 | [diff] [blame] | 285 | } |
| 286 | |
| 287 | void OpenGLRenderer::restore() { |
Romain Guy | 2542d19 | 2010-08-18 11:47:12 -0700 | [diff] [blame] | 288 | if (mSaveCount > 1) { |
| 289 | restoreSnapshot(); |
Romain Guy | 7ae7ac4 | 2010-06-25 13:46:18 -0700 | [diff] [blame] | 290 | } |
Romain Guy | bb9524b | 2010-06-22 18:56:38 -0700 | [diff] [blame] | 291 | } |
| 292 | |
| 293 | void OpenGLRenderer::restoreToCount(int saveCount) { |
Romain Guy | 8fb9542 | 2010-08-17 18:38:51 -0700 | [diff] [blame] | 294 | if (saveCount < 1) saveCount = 1; |
Romain Guy | bb9524b | 2010-06-22 18:56:38 -0700 | [diff] [blame] | 295 | |
Romain Guy | 8fb9542 | 2010-08-17 18:38:51 -0700 | [diff] [blame] | 296 | while (mSaveCount > saveCount) { |
Romain Guy | 2542d19 | 2010-08-18 11:47:12 -0700 | [diff] [blame] | 297 | restoreSnapshot(); |
Romain Guy | 7ae7ac4 | 2010-06-25 13:46:18 -0700 | [diff] [blame] | 298 | } |
Romain Guy | bb9524b | 2010-06-22 18:56:38 -0700 | [diff] [blame] | 299 | } |
| 300 | |
Romain Guy | 8aef54f | 2010-09-01 15:13:49 -0700 | [diff] [blame] | 301 | int OpenGLRenderer::saveSnapshot(int flags) { |
| 302 | mSnapshot = new Snapshot(mSnapshot, flags); |
Romain Guy | 8fb9542 | 2010-08-17 18:38:51 -0700 | [diff] [blame] | 303 | return mSaveCount++; |
Romain Guy | bb9524b | 2010-06-22 18:56:38 -0700 | [diff] [blame] | 304 | } |
| 305 | |
| 306 | bool OpenGLRenderer::restoreSnapshot() { |
Romain Guy | 7ae7ac4 | 2010-06-25 13:46:18 -0700 | [diff] [blame] | 307 | bool restoreClip = mSnapshot->flags & Snapshot::kFlagClipSet; |
Romain Guy | bd6b79b | 2010-06-26 00:13:53 -0700 | [diff] [blame] | 308 | bool restoreLayer = mSnapshot->flags & Snapshot::kFlagIsLayer; |
Romain Guy | eb99356 | 2010-10-05 18:14:38 -0700 | [diff] [blame] | 309 | bool restoreOrtho = mSnapshot->flags & Snapshot::kFlagDirtyOrtho; |
Romain Guy | bb9524b | 2010-06-22 18:56:38 -0700 | [diff] [blame] | 310 | |
Romain Guy | bd6b79b | 2010-06-26 00:13:53 -0700 | [diff] [blame] | 311 | sp<Snapshot> current = mSnapshot; |
| 312 | sp<Snapshot> previous = mSnapshot->previous; |
| 313 | |
Romain Guy | eb99356 | 2010-10-05 18:14:38 -0700 | [diff] [blame] | 314 | if (restoreOrtho) { |
| 315 | Rect& r = previous->viewport; |
| 316 | glViewport(r.left, r.top, r.right, r.bottom); |
| 317 | mOrthoMatrix.load(current->orthoMatrix); |
| 318 | } |
| 319 | |
Romain Guy | 8b55f37 | 2010-08-18 17:10:07 -0700 | [diff] [blame] | 320 | mSaveCount--; |
| 321 | mSnapshot = previous; |
| 322 | |
Romain Guy | 2542d19 | 2010-08-18 11:47:12 -0700 | [diff] [blame] | 323 | if (restoreClip) { |
Romain Guy | 746b740 | 2010-10-26 16:27:31 -0700 | [diff] [blame] | 324 | dirtyClip(); |
Romain Guy | 8fb9542 | 2010-08-17 18:38:51 -0700 | [diff] [blame] | 325 | } |
Romain Guy | 2542d19 | 2010-08-18 11:47:12 -0700 | [diff] [blame] | 326 | |
Romain Guy | 5ec9924 | 2010-11-03 16:19:08 -0700 | [diff] [blame] | 327 | if (restoreLayer) { |
| 328 | composeLayer(current, previous); |
| 329 | } |
| 330 | |
Romain Guy | 2542d19 | 2010-08-18 11:47:12 -0700 | [diff] [blame] | 331 | return restoreClip; |
Romain Guy | bb9524b | 2010-06-22 18:56:38 -0700 | [diff] [blame] | 332 | } |
| 333 | |
Romain Guy | f6a11b8 | 2010-06-23 17:47:49 -0700 | [diff] [blame] | 334 | /////////////////////////////////////////////////////////////////////////////// |
Romain Guy | bd6b79b | 2010-06-26 00:13:53 -0700 | [diff] [blame] | 335 | // Layers |
| 336 | /////////////////////////////////////////////////////////////////////////////// |
| 337 | |
| 338 | int OpenGLRenderer::saveLayer(float left, float top, float right, float bottom, |
Chet Haase | 5c13d89 | 2010-10-08 08:37:55 -0700 | [diff] [blame] | 339 | SkPaint* p, int flags) { |
Romain Guy | eb99356 | 2010-10-05 18:14:38 -0700 | [diff] [blame] | 340 | const GLuint previousFbo = mSnapshot->fbo; |
| 341 | const int count = saveSnapshot(flags); |
Romain Guy | d55a861 | 2010-06-28 17:42:46 -0700 | [diff] [blame] | 342 | |
Romain Guy | af636eb | 2010-12-09 17:47:21 -0800 | [diff] [blame] | 343 | if (!mSnapshot->isIgnored()) { |
Romain Guy | e45362c | 2010-11-03 19:58:32 -0700 | [diff] [blame] | 344 | int alpha = 255; |
| 345 | SkXfermode::Mode mode; |
Romain Guy | d55a861 | 2010-06-28 17:42:46 -0700 | [diff] [blame] | 346 | |
Romain Guy | e45362c | 2010-11-03 19:58:32 -0700 | [diff] [blame] | 347 | if (p) { |
| 348 | alpha = p->getAlpha(); |
| 349 | if (!mCaches.extensions.hasFramebufferFetch()) { |
| 350 | const bool isMode = SkXfermode::IsMode(p->getXfermode(), &mode); |
| 351 | if (!isMode) { |
| 352 | // Assume SRC_OVER |
| 353 | mode = SkXfermode::kSrcOver_Mode; |
| 354 | } |
| 355 | } else { |
| 356 | mode = getXfermode(p->getXfermode()); |
Romain Guy | a5aed0d | 2010-09-09 14:42:43 -0700 | [diff] [blame] | 357 | } |
| 358 | } else { |
Romain Guy | e45362c | 2010-11-03 19:58:32 -0700 | [diff] [blame] | 359 | mode = SkXfermode::kSrcOver_Mode; |
Romain Guy | d55a861 | 2010-06-28 17:42:46 -0700 | [diff] [blame] | 360 | } |
Romain Guy | d55a861 | 2010-06-28 17:42:46 -0700 | [diff] [blame] | 361 | |
Romain Guy | dbc26d2 | 2010-10-11 17:58:29 -0700 | [diff] [blame] | 362 | createLayer(mSnapshot, left, top, right, bottom, alpha, mode, flags, previousFbo); |
| 363 | } |
Romain Guy | d55a861 | 2010-06-28 17:42:46 -0700 | [diff] [blame] | 364 | |
| 365 | return count; |
Romain Guy | bd6b79b | 2010-06-26 00:13:53 -0700 | [diff] [blame] | 366 | } |
| 367 | |
| 368 | int OpenGLRenderer::saveLayerAlpha(float left, float top, float right, float bottom, |
| 369 | int alpha, int flags) { |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 370 | if (alpha >= 255 - ALPHA_THRESHOLD) { |
Romain Guy | 8aef54f | 2010-09-01 15:13:49 -0700 | [diff] [blame] | 371 | return saveLayer(left, top, right, bottom, NULL, flags); |
Romain Guy | 8b55f37 | 2010-08-18 17:10:07 -0700 | [diff] [blame] | 372 | } else { |
Romain Guy | 8aef54f | 2010-09-01 15:13:49 -0700 | [diff] [blame] | 373 | SkPaint paint; |
| 374 | paint.setAlpha(alpha); |
| 375 | return saveLayer(left, top, right, bottom, &paint, flags); |
Romain Guy | 8b55f37 | 2010-08-18 17:10:07 -0700 | [diff] [blame] | 376 | } |
Romain Guy | d55a861 | 2010-06-28 17:42:46 -0700 | [diff] [blame] | 377 | } |
Romain Guy | bd6b79b | 2010-06-26 00:13:53 -0700 | [diff] [blame] | 378 | |
Romain Guy | 1c740bc | 2010-09-13 18:00:09 -0700 | [diff] [blame] | 379 | /** |
| 380 | * Layers are viewed by Skia are slightly different than layers in image editing |
| 381 | * programs (for instance.) When a layer is created, previously created layers |
| 382 | * and the frame buffer still receive every drawing command. For instance, if a |
| 383 | * layer is created and a shape intersecting the bounds of the layers and the |
| 384 | * framebuffer is draw, the shape will be drawn on both (unless the layer was |
| 385 | * created with the SkCanvas::kClipToLayer_SaveFlag flag.) |
| 386 | * |
| 387 | * A way to implement layers is to create an FBO for each layer, backed by an RGBA |
| 388 | * texture. Unfortunately, this is inefficient as it requires every primitive to |
| 389 | * be drawn n + 1 times, where n is the number of active layers. In practice this |
| 390 | * means, for every primitive: |
| 391 | * - Switch active frame buffer |
| 392 | * - Change viewport, clip and projection matrix |
| 393 | * - Issue the drawing |
| 394 | * |
| 395 | * Switching rendering target n + 1 times per drawn primitive is extremely costly. |
Romain Guy | 6b7bd24 | 2010-10-06 19:49:23 -0700 | [diff] [blame] | 396 | * To avoid this, layers are implemented in a different way here, at least in the |
| 397 | * general case. FBOs are used, as an optimization, when the "clip to layer" flag |
| 398 | * is set. When this flag is set we can redirect all drawing operations into a |
| 399 | * single FBO. |
Romain Guy | 1c740bc | 2010-09-13 18:00:09 -0700 | [diff] [blame] | 400 | * |
| 401 | * This implementation relies on the frame buffer being at least RGBA 8888. When |
| 402 | * a layer is created, only a texture is created, not an FBO. The content of the |
| 403 | * frame buffer contained within the layer's bounds is copied into this texture |
Romain Guy | 87a7657 | 2010-09-13 18:11:21 -0700 | [diff] [blame] | 404 | * using glCopyTexImage2D(). The layer's region is then cleared(1) in the frame |
Romain Guy | 1c740bc | 2010-09-13 18:00:09 -0700 | [diff] [blame] | 405 | * buffer and drawing continues as normal. This technique therefore treats the |
| 406 | * frame buffer as a scratch buffer for the layers. |
| 407 | * |
| 408 | * To compose the layers back onto the frame buffer, each layer texture |
| 409 | * (containing the original frame buffer data) is drawn as a simple quad over |
| 410 | * the frame buffer. The trick is that the quad is set as the composition |
| 411 | * destination in the blending equation, and the frame buffer becomes the source |
| 412 | * of the composition. |
| 413 | * |
| 414 | * Drawing layers with an alpha value requires an extra step before composition. |
| 415 | * An empty quad is drawn over the layer's region in the frame buffer. This quad |
| 416 | * is drawn with the rgba color (0,0,0,alpha). The alpha value offered by the |
| 417 | * quad is used to multiply the colors in the frame buffer. This is achieved by |
| 418 | * changing the GL blend functions for the GL_FUNC_ADD blend equation to |
| 419 | * GL_ZERO, GL_SRC_ALPHA. |
| 420 | * |
| 421 | * Because glCopyTexImage2D() can be slow, an alternative implementation might |
| 422 | * be use to draw a single clipped layer. The implementation described above |
| 423 | * is correct in every case. |
Romain Guy | 87a7657 | 2010-09-13 18:11:21 -0700 | [diff] [blame] | 424 | * |
| 425 | * (1) The frame buffer is actually not cleared right away. To allow the GPU |
| 426 | * to potentially optimize series of calls to glCopyTexImage2D, the frame |
| 427 | * buffer is left untouched until the first drawing operation. Only when |
| 428 | * something actually gets drawn are the layers regions cleared. |
Romain Guy | 1c740bc | 2010-09-13 18:00:09 -0700 | [diff] [blame] | 429 | */ |
Romain Guy | d55a861 | 2010-06-28 17:42:46 -0700 | [diff] [blame] | 430 | bool OpenGLRenderer::createLayer(sp<Snapshot> snapshot, float left, float top, |
Romain Guy | eb99356 | 2010-10-05 18:14:38 -0700 | [diff] [blame] | 431 | float right, float bottom, int alpha, SkXfermode::Mode mode, |
| 432 | int flags, GLuint previousFbo) { |
| 433 | LAYER_LOGD("Requesting layer %.2fx%.2f", right - left, bottom - top); |
Romain Guy | fb8b763 | 2010-08-23 21:05:08 -0700 | [diff] [blame] | 434 | LAYER_LOGD("Layer cache size = %d", mCaches.layerCache.getSize()); |
Romain Guy | 8ba548f | 2010-06-30 19:21:21 -0700 | [diff] [blame] | 435 | |
Romain Guy | eb99356 | 2010-10-05 18:14:38 -0700 | [diff] [blame] | 436 | const bool fboLayer = flags & SkCanvas::kClipToLayer_SaveFlag; |
| 437 | |
Romain Guy | f607bdc | 2010-09-10 19:20:06 -0700 | [diff] [blame] | 438 | // Window coordinates of the layer |
Romain Guy | 8aef54f | 2010-09-01 15:13:49 -0700 | [diff] [blame] | 439 | Rect bounds(left, top, right, bottom); |
Romain Guy | 7b5b6ab | 2011-03-14 18:05:08 -0700 | [diff] [blame] | 440 | if (!fboLayer) { |
Romain Guy | eb99356 | 2010-10-05 18:14:38 -0700 | [diff] [blame] | 441 | mSnapshot->transform->mapRect(bounds); |
Romain Guy | ae51759 | 2010-10-22 10:40:27 -0700 | [diff] [blame] | 442 | |
Romain Guy | eb99356 | 2010-10-05 18:14:38 -0700 | [diff] [blame] | 443 | // Layers only make sense if they are in the framebuffer's bounds |
Romain Guy | ad37cd3 | 2011-03-15 11:12:25 -0700 | [diff] [blame] | 444 | if (bounds.intersect(*snapshot->clipRect)) { |
| 445 | // We cannot work with sub-pixels in this case |
| 446 | bounds.snapToPixelBoundaries(); |
Romain Guy | ae51759 | 2010-10-22 10:40:27 -0700 | [diff] [blame] | 447 | |
Romain Guy | ad37cd3 | 2011-03-15 11:12:25 -0700 | [diff] [blame] | 448 | // When the layer is not an FBO, we may use glCopyTexImage so we |
| 449 | // need to make sure the layer does not extend outside the bounds |
| 450 | // of the framebuffer |
| 451 | if (!bounds.intersect(snapshot->previous->viewport)) { |
| 452 | bounds.setEmpty(); |
| 453 | } |
| 454 | } else { |
| 455 | bounds.setEmpty(); |
| 456 | } |
Romain Guy | eb99356 | 2010-10-05 18:14:38 -0700 | [diff] [blame] | 457 | } |
Romain Guy | bf43411 | 2010-09-16 14:40:17 -0700 | [diff] [blame] | 458 | |
Romain Guy | 746b740 | 2010-10-26 16:27:31 -0700 | [diff] [blame] | 459 | if (bounds.isEmpty() || bounds.getWidth() > mCaches.maxTextureSize || |
| 460 | bounds.getHeight() > mCaches.maxTextureSize) { |
Romain Guy | 32963c3 | 2010-12-10 14:43:41 -0800 | [diff] [blame] | 461 | snapshot->empty = fboLayer; |
Romain Guy | dbc26d2 | 2010-10-11 17:58:29 -0700 | [diff] [blame] | 462 | } else { |
Romain Guy | e45362c | 2010-11-03 19:58:32 -0700 | [diff] [blame] | 463 | snapshot->invisible = snapshot->invisible || (alpha <= ALPHA_THRESHOLD && fboLayer); |
Romain Guy | dbc26d2 | 2010-10-11 17:58:29 -0700 | [diff] [blame] | 464 | } |
| 465 | |
| 466 | // Bail out if we won't draw in this snapshot |
Romain Guy | af636eb | 2010-12-09 17:47:21 -0800 | [diff] [blame] | 467 | if (snapshot->invisible || snapshot->empty) { |
Romain Guy | b025b9c | 2010-09-16 14:16:48 -0700 | [diff] [blame] | 468 | return false; |
| 469 | } |
Romain Guy | f18fd99 | 2010-07-08 11:45:51 -0700 | [diff] [blame] | 470 | |
Romain Guy | a1d3c91 | 2011-12-13 14:55:06 -0800 | [diff] [blame] | 471 | mCaches.activeTexture(0); |
Romain Guy | 8550c4c | 2010-10-08 15:49:53 -0700 | [diff] [blame] | 472 | Layer* layer = mCaches.layerCache.get(bounds.getWidth(), bounds.getHeight()); |
Romain Guy | dda5702 | 2010-07-06 11:39:32 -0700 | [diff] [blame] | 473 | if (!layer) { |
Romain Guy | f18fd99 | 2010-07-08 11:45:51 -0700 | [diff] [blame] | 474 | return false; |
Romain Guy | bd6b79b | 2010-06-26 00:13:53 -0700 | [diff] [blame] | 475 | } |
| 476 | |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 477 | layer->setAlpha(alpha, mode); |
Romain Guy | 8aef54f | 2010-09-01 15:13:49 -0700 | [diff] [blame] | 478 | layer->layer.set(bounds); |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 479 | layer->texCoords.set(0.0f, bounds.getHeight() / float(layer->getHeight()), |
| 480 | bounds.getWidth() / float(layer->getWidth()), 0.0f); |
| 481 | layer->setColorFilter(mColorFilter); |
Romain Guy | dda5702 | 2010-07-06 11:39:32 -0700 | [diff] [blame] | 482 | |
Romain Guy | 8fb9542 | 2010-08-17 18:38:51 -0700 | [diff] [blame] | 483 | // Save the layer in the snapshot |
| 484 | snapshot->flags |= Snapshot::kFlagIsLayer; |
Romain Guy | dda5702 | 2010-07-06 11:39:32 -0700 | [diff] [blame] | 485 | snapshot->layer = layer; |
Romain Guy | 1d83e19 | 2010-08-17 11:37:00 -0700 | [diff] [blame] | 486 | |
Romain Guy | eb99356 | 2010-10-05 18:14:38 -0700 | [diff] [blame] | 487 | if (fboLayer) { |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 488 | return createFboLayer(layer, bounds, snapshot, previousFbo); |
Romain Guy | eb99356 | 2010-10-05 18:14:38 -0700 | [diff] [blame] | 489 | } else { |
| 490 | // Copy the framebuffer into the layer |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 491 | layer->bindTexture(); |
Romain Guy | 514fb18 | 2011-01-19 14:38:29 -0800 | [diff] [blame] | 492 | if (!bounds.isEmpty()) { |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 493 | if (layer->isEmpty()) { |
| 494 | glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, |
| 495 | bounds.left, snapshot->height - bounds.bottom, |
| 496 | layer->getWidth(), layer->getHeight(), 0); |
| 497 | layer->setEmpty(false); |
Romain Guy | 514fb18 | 2011-01-19 14:38:29 -0800 | [diff] [blame] | 498 | } else { |
| 499 | glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, bounds.left, |
| 500 | snapshot->height - bounds.bottom, bounds.getWidth(), bounds.getHeight()); |
| 501 | } |
Romain Guy | 7b5b6ab | 2011-03-14 18:05:08 -0700 | [diff] [blame] | 502 | |
Romain Guy | 54be1cd | 2011-06-13 19:04:27 -0700 | [diff] [blame] | 503 | // Enqueue the buffer coordinates to clear the corresponding region later |
| 504 | mLayers.push(new Rect(bounds)); |
Romain Guy | ae88e5e | 2010-10-22 17:49:18 -0700 | [diff] [blame] | 505 | } |
Romain Guy | eb99356 | 2010-10-05 18:14:38 -0700 | [diff] [blame] | 506 | } |
Romain Guy | f86ef57 | 2010-07-01 11:05:42 -0700 | [diff] [blame] | 507 | |
Romain Guy | d55a861 | 2010-06-28 17:42:46 -0700 | [diff] [blame] | 508 | return true; |
Romain Guy | bd6b79b | 2010-06-26 00:13:53 -0700 | [diff] [blame] | 509 | } |
| 510 | |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 511 | bool OpenGLRenderer::createFboLayer(Layer* layer, Rect& bounds, sp<Snapshot> snapshot, |
| 512 | GLuint previousFbo) { |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 513 | layer->setFbo(mCaches.fboCache.get()); |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 514 | |
| 515 | #if RENDER_LAYERS_AS_REGIONS |
| 516 | snapshot->region = &snapshot->layer->region; |
| 517 | snapshot->flags |= Snapshot::kFlagFboTarget; |
| 518 | #endif |
| 519 | |
| 520 | Rect clip(bounds); |
| 521 | snapshot->transform->mapRect(clip); |
| 522 | clip.intersect(*snapshot->clipRect); |
| 523 | clip.snapToPixelBoundaries(); |
| 524 | clip.intersect(snapshot->previous->viewport); |
| 525 | |
| 526 | mat4 inverse; |
| 527 | inverse.loadInverse(*mSnapshot->transform); |
| 528 | |
| 529 | inverse.mapRect(clip); |
| 530 | clip.snapToPixelBoundaries(); |
| 531 | clip.intersect(bounds); |
Romain Guy | 5ec9924 | 2010-11-03 16:19:08 -0700 | [diff] [blame] | 532 | clip.translate(-bounds.left, -bounds.top); |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 533 | |
| 534 | snapshot->flags |= Snapshot::kFlagIsFboLayer; |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 535 | snapshot->fbo = layer->getFbo(); |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 536 | snapshot->resetTransform(-bounds.left, -bounds.top, 0.0f); |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 537 | snapshot->resetClip(clip.left, clip.top, clip.right, clip.bottom); |
| 538 | snapshot->viewport.set(0.0f, 0.0f, bounds.getWidth(), bounds.getHeight()); |
| 539 | snapshot->height = bounds.getHeight(); |
| 540 | snapshot->flags |= Snapshot::kFlagDirtyOrtho; |
| 541 | snapshot->orthoMatrix.load(mOrthoMatrix); |
| 542 | |
| 543 | // Bind texture to FBO |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 544 | glBindFramebuffer(GL_FRAMEBUFFER, layer->getFbo()); |
| 545 | layer->bindTexture(); |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 546 | |
| 547 | // Initialize the texture if needed |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 548 | if (layer->isEmpty()) { |
| 549 | layer->allocateTexture(GL_RGBA, GL_UNSIGNED_BYTE); |
| 550 | layer->setEmpty(false); |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 551 | } |
| 552 | |
| 553 | glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 554 | layer->getTexture(), 0); |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 555 | |
| 556 | #if DEBUG_LAYERS_AS_REGIONS |
| 557 | GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER); |
| 558 | if (status != GL_FRAMEBUFFER_COMPLETE) { |
Steve Block | 3762c31 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 559 | ALOGE("Framebuffer incomplete (GL error code 0x%x)", status); |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 560 | |
| 561 | glBindFramebuffer(GL_FRAMEBUFFER, previousFbo); |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 562 | layer->deleteTexture(); |
| 563 | mCaches.fboCache.put(layer->getFbo()); |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 564 | |
| 565 | delete layer; |
| 566 | |
| 567 | return false; |
| 568 | } |
| 569 | #endif |
| 570 | |
| 571 | // Clear the FBO, expand the clear region by 1 to get nice bilinear filtering |
Romain Guy | 8f85e80 | 2011-12-14 19:23:32 -0800 | [diff] [blame] | 572 | mCaches.setScissor(clip.left - 1.0f, bounds.getHeight() - clip.bottom - 1.0f, |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 573 | clip.getWidth() + 2.0f, clip.getHeight() + 2.0f); |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 574 | glClear(GL_COLOR_BUFFER_BIT); |
| 575 | |
| 576 | dirtyClip(); |
| 577 | |
| 578 | // Change the ortho projection |
| 579 | glViewport(0, 0, bounds.getWidth(), bounds.getHeight()); |
| 580 | mOrthoMatrix.loadOrtho(0.0f, bounds.getWidth(), bounds.getHeight(), 0.0f, -1.0f, 1.0f); |
| 581 | |
| 582 | return true; |
| 583 | } |
| 584 | |
Romain Guy | 1c740bc | 2010-09-13 18:00:09 -0700 | [diff] [blame] | 585 | /** |
| 586 | * Read the documentation of createLayer() before doing anything in this method. |
| 587 | */ |
Romain Guy | 1d83e19 | 2010-08-17 11:37:00 -0700 | [diff] [blame] | 588 | void OpenGLRenderer::composeLayer(sp<Snapshot> current, sp<Snapshot> previous) { |
| 589 | if (!current->layer) { |
Steve Block | 3762c31 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 590 | ALOGE("Attempting to compose a layer that does not exist"); |
Romain Guy | 1d83e19 | 2010-08-17 11:37:00 -0700 | [diff] [blame] | 591 | return; |
| 592 | } |
| 593 | |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 594 | const bool fboLayer = current->flags & Snapshot::kFlagIsFboLayer; |
Romain Guy | eb99356 | 2010-10-05 18:14:38 -0700 | [diff] [blame] | 595 | |
| 596 | if (fboLayer) { |
| 597 | // Unbind current FBO and restore previous one |
| 598 | glBindFramebuffer(GL_FRAMEBUFFER, previous->fbo); |
| 599 | } |
| 600 | |
Romain Guy | 1d83e19 | 2010-08-17 11:37:00 -0700 | [diff] [blame] | 601 | Layer* layer = current->layer; |
| 602 | const Rect& rect = layer->layer; |
| 603 | |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 604 | if (!fboLayer && layer->getAlpha() < 255) { |
Romain Guy | f607bdc | 2010-09-10 19:20:06 -0700 | [diff] [blame] | 605 | drawColorRect(rect.left, rect.top, rect.right, rect.bottom, |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 606 | layer->getAlpha() << 24, SkXfermode::kDstIn_Mode, true); |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 607 | // Required below, composeLayerRect() will divide by 255 |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 608 | layer->setAlpha(255); |
Romain Guy | f607bdc | 2010-09-10 19:20:06 -0700 | [diff] [blame] | 609 | } |
| 610 | |
Romain Guy | 03750a0 | 2010-10-18 14:06:08 -0700 | [diff] [blame] | 611 | mCaches.unbindMeshBuffer(); |
Romain Guy | 8b55f37 | 2010-08-18 17:10:07 -0700 | [diff] [blame] | 612 | |
Romain Guy | a1d3c91 | 2011-12-13 14:55:06 -0800 | [diff] [blame] | 613 | mCaches.activeTexture(0); |
Romain Guy | 1d83e19 | 2010-08-17 11:37:00 -0700 | [diff] [blame] | 614 | |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 615 | // When the layer is stored in an FBO, we can save a bit of fillrate by |
| 616 | // drawing only the dirty region |
| 617 | if (fboLayer) { |
| 618 | dirtyLayer(rect.left, rect.top, rect.right, rect.bottom, *previous->transform); |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 619 | if (layer->getColorFilter()) { |
| 620 | setupColorFilter(layer->getColorFilter()); |
Romain Guy | 171c592 | 2011-01-06 10:04:23 -0800 | [diff] [blame] | 621 | } |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 622 | composeLayerRegion(layer, rect); |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 623 | if (layer->getColorFilter()) { |
Romain Guy | 171c592 | 2011-01-06 10:04:23 -0800 | [diff] [blame] | 624 | resetColorFilter(); |
| 625 | } |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 626 | } else if (!rect.isEmpty()) { |
| 627 | dirtyLayer(rect.left, rect.top, rect.right, rect.bottom); |
| 628 | composeLayerRect(layer, rect, true); |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 629 | } |
Romain Guy | 8b55f37 | 2010-08-18 17:10:07 -0700 | [diff] [blame] | 630 | |
Romain Guy | eb99356 | 2010-10-05 18:14:38 -0700 | [diff] [blame] | 631 | if (fboLayer) { |
Romain Guy | 9c4b79a | 2011-11-10 19:23:58 -0800 | [diff] [blame] | 632 | // Note: No need to use glDiscardFramebufferEXT() since we never |
| 633 | // create/compose layers that are not on screen with this |
| 634 | // code path |
| 635 | // See LayerRenderer::destroyLayer(Layer*) |
| 636 | |
Romain Guy | eb99356 | 2010-10-05 18:14:38 -0700 | [diff] [blame] | 637 | // Detach the texture from the FBO |
| 638 | glBindFramebuffer(GL_FRAMEBUFFER, current->fbo); |
| 639 | glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0); |
| 640 | glBindFramebuffer(GL_FRAMEBUFFER, previous->fbo); |
| 641 | |
| 642 | // Put the FBO name back in the cache, if it doesn't fit, it will be destroyed |
| 643 | mCaches.fboCache.put(current->fbo); |
| 644 | } |
| 645 | |
Romain Guy | 746b740 | 2010-10-26 16:27:31 -0700 | [diff] [blame] | 646 | dirtyClip(); |
| 647 | |
Romain Guy | eb99356 | 2010-10-05 18:14:38 -0700 | [diff] [blame] | 648 | // Failing to add the layer to the cache should happen only if the layer is too large |
Romain Guy | 8550c4c | 2010-10-08 15:49:53 -0700 | [diff] [blame] | 649 | if (!mCaches.layerCache.put(layer)) { |
Romain Guy | 1d83e19 | 2010-08-17 11:37:00 -0700 | [diff] [blame] | 650 | LAYER_LOGD("Deleting layer"); |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 651 | layer->deleteTexture(); |
Romain Guy | 1d83e19 | 2010-08-17 11:37:00 -0700 | [diff] [blame] | 652 | delete layer; |
| 653 | } |
| 654 | } |
| 655 | |
Romain Guy | aa6c24c | 2011-04-28 18:40:04 -0700 | [diff] [blame] | 656 | void OpenGLRenderer::drawTextureLayer(Layer* layer, const Rect& rect) { |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 657 | float alpha = layer->getAlpha() / 255.0f; |
Romain Guy | aa6c24c | 2011-04-28 18:40:04 -0700 | [diff] [blame] | 658 | |
Romain Guy | 302a9df | 2011-08-16 13:55:02 -0700 | [diff] [blame] | 659 | mat4& transform = layer->getTransform(); |
| 660 | if (!transform.isIdentity()) { |
| 661 | save(0); |
| 662 | mSnapshot->transform->multiply(transform); |
| 663 | } |
| 664 | |
Romain Guy | aa6c24c | 2011-04-28 18:40:04 -0700 | [diff] [blame] | 665 | setupDraw(); |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 666 | if (layer->getRenderTarget() == GL_TEXTURE_2D) { |
Romain Guy | 8f0095c | 2011-05-02 17:24:22 -0700 | [diff] [blame] | 667 | setupDrawWithTexture(); |
| 668 | } else { |
| 669 | setupDrawWithExternalTexture(); |
| 670 | } |
| 671 | setupDrawTextureTransform(); |
Romain Guy | aa6c24c | 2011-04-28 18:40:04 -0700 | [diff] [blame] | 672 | setupDrawColor(alpha, alpha, alpha, alpha); |
| 673 | setupDrawColorFilter(); |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 674 | setupDrawBlending(layer->isBlend() || alpha < 1.0f, layer->getMode()); |
Romain Guy | aa6c24c | 2011-04-28 18:40:04 -0700 | [diff] [blame] | 675 | setupDrawProgram(); |
Romain Guy | aa6c24c | 2011-04-28 18:40:04 -0700 | [diff] [blame] | 676 | setupDrawPureColorUniforms(); |
| 677 | setupDrawColorFilterUniforms(); |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 678 | if (layer->getRenderTarget() == GL_TEXTURE_2D) { |
| 679 | setupDrawTexture(layer->getTexture()); |
Romain Guy | 8f0095c | 2011-05-02 17:24:22 -0700 | [diff] [blame] | 680 | } else { |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 681 | setupDrawExternalTexture(layer->getTexture()); |
Romain Guy | 8f0095c | 2011-05-02 17:24:22 -0700 | [diff] [blame] | 682 | } |
Romain Guy | ec19b4a | 2011-07-07 21:05:04 -0700 | [diff] [blame] | 683 | if (mSnapshot->transform->isPureTranslate() && |
| 684 | layer->getWidth() == (uint32_t) rect.getWidth() && |
| 685 | layer->getHeight() == (uint32_t) rect.getHeight()) { |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 686 | const float x = (int) floorf(rect.left + mSnapshot->transform->getTranslateX() + 0.5f); |
| 687 | const float y = (int) floorf(rect.top + mSnapshot->transform->getTranslateY() + 0.5f); |
| 688 | |
Romain Guy | d21b6e1 | 2011-11-30 20:21:23 -0800 | [diff] [blame] | 689 | layer->setFilter(GL_NEAREST); |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 690 | setupDrawModelView(x, y, x + rect.getWidth(), y + rect.getHeight(), true); |
| 691 | } else { |
Romain Guy | d21b6e1 | 2011-11-30 20:21:23 -0800 | [diff] [blame] | 692 | layer->setFilter(GL_LINEAR); |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 693 | setupDrawModelView(rect.left, rect.top, rect.right, rect.bottom); |
| 694 | } |
| 695 | setupDrawTextureTransformUniforms(layer->getTexTransform()); |
Romain Guy | aa6c24c | 2011-04-28 18:40:04 -0700 | [diff] [blame] | 696 | setupDrawMesh(&mMeshVertices[0].position[0], &mMeshVertices[0].texture[0]); |
| 697 | |
| 698 | glDrawArrays(GL_TRIANGLE_STRIP, 0, gMeshCount); |
| 699 | |
| 700 | finishDrawTexture(); |
Romain Guy | 302a9df | 2011-08-16 13:55:02 -0700 | [diff] [blame] | 701 | |
| 702 | if (!transform.isIdentity()) { |
| 703 | restore(); |
| 704 | } |
Romain Guy | aa6c24c | 2011-04-28 18:40:04 -0700 | [diff] [blame] | 705 | } |
| 706 | |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 707 | void OpenGLRenderer::composeLayerRect(Layer* layer, const Rect& rect, bool swap) { |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 708 | if (!layer->isTextureLayer()) { |
Romain Guy | aa6c24c | 2011-04-28 18:40:04 -0700 | [diff] [blame] | 709 | const Rect& texCoords = layer->texCoords; |
| 710 | resetDrawTextureTexCoords(texCoords.left, texCoords.top, |
| 711 | texCoords.right, texCoords.bottom); |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 712 | |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 713 | float x = rect.left; |
| 714 | float y = rect.top; |
Romain Guy | b247915 | 2011-07-08 11:57:29 -0700 | [diff] [blame] | 715 | bool simpleTransform = mSnapshot->transform->isPureTranslate() && |
Romain Guy | ec19b4a | 2011-07-07 21:05:04 -0700 | [diff] [blame] | 716 | layer->getWidth() == (uint32_t) rect.getWidth() && |
Romain Guy | b247915 | 2011-07-08 11:57:29 -0700 | [diff] [blame] | 717 | layer->getHeight() == (uint32_t) rect.getHeight(); |
| 718 | |
| 719 | if (simpleTransform) { |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 720 | // When we're swapping, the layer is already in screen coordinates |
| 721 | if (!swap) { |
| 722 | x = (int) floorf(rect.left + mSnapshot->transform->getTranslateX() + 0.5f); |
| 723 | y = (int) floorf(rect.top + mSnapshot->transform->getTranslateY() + 0.5f); |
| 724 | } |
| 725 | |
Romain Guy | d21b6e1 | 2011-11-30 20:21:23 -0800 | [diff] [blame] | 726 | layer->setFilter(GL_NEAREST, true); |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 727 | } else { |
Romain Guy | d21b6e1 | 2011-11-30 20:21:23 -0800 | [diff] [blame] | 728 | layer->setFilter(GL_LINEAR, true); |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 729 | } |
| 730 | |
| 731 | drawTextureMesh(x, y, x + rect.getWidth(), y + rect.getHeight(), |
| 732 | layer->getTexture(), layer->getAlpha() / 255.0f, |
| 733 | layer->getMode(), layer->isBlend(), |
| 734 | &mMeshVertices[0].position[0], &mMeshVertices[0].texture[0], |
| 735 | GL_TRIANGLE_STRIP, gMeshCount, swap, swap || simpleTransform); |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 736 | |
Romain Guy | aa6c24c | 2011-04-28 18:40:04 -0700 | [diff] [blame] | 737 | resetDrawTextureTexCoords(0.0f, 0.0f, 1.0f, 1.0f); |
| 738 | } else { |
| 739 | resetDrawTextureTexCoords(0.0f, 1.0f, 1.0f, 0.0f); |
| 740 | drawTextureLayer(layer, rect); |
| 741 | resetDrawTextureTexCoords(0.0f, 0.0f, 1.0f, 1.0f); |
| 742 | } |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 743 | } |
| 744 | |
| 745 | void OpenGLRenderer::composeLayerRegion(Layer* layer, const Rect& rect) { |
| 746 | #if RENDER_LAYERS_AS_REGIONS |
| 747 | if (layer->region.isRect()) { |
Romain Guy | 9fc2781 | 2011-04-27 14:21:41 -0700 | [diff] [blame] | 748 | layer->setRegionAsRect(); |
| 749 | |
Romain Guy | 4066767 | 2011-03-18 14:34:03 -0700 | [diff] [blame] | 750 | composeLayerRect(layer, layer->regionRect); |
Romain Guy | 9fc2781 | 2011-04-27 14:21:41 -0700 | [diff] [blame] | 751 | |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 752 | layer->region.clear(); |
| 753 | return; |
| 754 | } |
| 755 | |
Romain Guy | 8a3957d | 2011-09-07 17:55:15 -0700 | [diff] [blame] | 756 | // TODO: See LayerRenderer.cpp::generateMesh() for important |
| 757 | // information about this implementation |
Romain Guy | 211370f | 2012-02-01 16:10:55 -0800 | [diff] [blame] | 758 | if (CC_LIKELY(!layer->region.isEmpty())) { |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 759 | size_t count; |
| 760 | const android::Rect* rects = layer->region.getArray(&count); |
| 761 | |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 762 | const float alpha = layer->getAlpha() / 255.0f; |
| 763 | const float texX = 1.0f / float(layer->getWidth()); |
| 764 | const float texY = 1.0f / float(layer->getHeight()); |
Romain Guy | f219da5 | 2011-01-16 12:54:25 -0800 | [diff] [blame] | 765 | const float height = rect.getHeight(); |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 766 | |
| 767 | TextureVertex* mesh = mCaches.getRegionMesh(); |
| 768 | GLsizei numQuads = 0; |
| 769 | |
Romain Guy | 7230a74 | 2011-01-10 22:26:16 -0800 | [diff] [blame] | 770 | setupDraw(); |
| 771 | setupDrawWithTexture(); |
| 772 | setupDrawColor(alpha, alpha, alpha, alpha); |
Romain Guy | ada830f | 2011-01-13 12:13:20 -0800 | [diff] [blame] | 773 | setupDrawColorFilter(); |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 774 | setupDrawBlending(layer->isBlend() || alpha < 1.0f, layer->getMode(), false); |
Romain Guy | 7230a74 | 2011-01-10 22:26:16 -0800 | [diff] [blame] | 775 | setupDrawProgram(); |
| 776 | setupDrawDirtyRegionsDisabled(); |
| 777 | setupDrawPureColorUniforms(); |
Romain Guy | ada830f | 2011-01-13 12:13:20 -0800 | [diff] [blame] | 778 | setupDrawColorFilterUniforms(); |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 779 | setupDrawTexture(layer->getTexture()); |
| 780 | if (mSnapshot->transform->isPureTranslate()) { |
| 781 | const float x = (int) floorf(rect.left + mSnapshot->transform->getTranslateX() + 0.5f); |
| 782 | const float y = (int) floorf(rect.top + mSnapshot->transform->getTranslateY() + 0.5f); |
| 783 | |
Romain Guy | d21b6e1 | 2011-11-30 20:21:23 -0800 | [diff] [blame] | 784 | layer->setFilter(GL_NEAREST); |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 785 | setupDrawModelViewTranslate(x, y, x + rect.getWidth(), y + rect.getHeight(), true); |
| 786 | } else { |
Romain Guy | d21b6e1 | 2011-11-30 20:21:23 -0800 | [diff] [blame] | 787 | layer->setFilter(GL_LINEAR); |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 788 | setupDrawModelViewTranslate(rect.left, rect.top, rect.right, rect.bottom); |
| 789 | } |
Romain Guy | 15bc643 | 2011-12-13 13:11:32 -0800 | [diff] [blame] | 790 | setupDrawMeshIndices(&mesh[0].position[0], &mesh[0].texture[0]); |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 791 | |
| 792 | for (size_t i = 0; i < count; i++) { |
| 793 | const android::Rect* r = &rects[i]; |
| 794 | |
| 795 | const float u1 = r->left * texX; |
Romain Guy | f219da5 | 2011-01-16 12:54:25 -0800 | [diff] [blame] | 796 | const float v1 = (height - r->top) * texY; |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 797 | const float u2 = r->right * texX; |
Romain Guy | f219da5 | 2011-01-16 12:54:25 -0800 | [diff] [blame] | 798 | const float v2 = (height - r->bottom) * texY; |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 799 | |
| 800 | // TODO: Reject quads outside of the clip |
| 801 | TextureVertex::set(mesh++, r->left, r->top, u1, v1); |
| 802 | TextureVertex::set(mesh++, r->right, r->top, u2, v1); |
| 803 | TextureVertex::set(mesh++, r->left, r->bottom, u1, v2); |
| 804 | TextureVertex::set(mesh++, r->right, r->bottom, u2, v2); |
| 805 | |
| 806 | numQuads++; |
| 807 | |
| 808 | if (numQuads >= REGION_MESH_QUAD_COUNT) { |
| 809 | glDrawElements(GL_TRIANGLES, numQuads * 6, GL_UNSIGNED_SHORT, NULL); |
| 810 | numQuads = 0; |
| 811 | mesh = mCaches.getRegionMesh(); |
| 812 | } |
| 813 | } |
| 814 | |
| 815 | if (numQuads > 0) { |
| 816 | glDrawElements(GL_TRIANGLES, numQuads * 6, GL_UNSIGNED_SHORT, NULL); |
| 817 | } |
| 818 | |
Romain Guy | 7230a74 | 2011-01-10 22:26:16 -0800 | [diff] [blame] | 819 | finishDrawTexture(); |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 820 | |
| 821 | #if DEBUG_LAYERS_AS_REGIONS |
Romain Guy | 3a3133d | 2011-02-01 22:59:58 -0800 | [diff] [blame] | 822 | drawRegionRects(layer->region); |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 823 | #endif |
| 824 | |
| 825 | layer->region.clear(); |
| 826 | } |
| 827 | #else |
| 828 | composeLayerRect(layer, rect); |
| 829 | #endif |
| 830 | } |
| 831 | |
Romain Guy | 3a3133d | 2011-02-01 22:59:58 -0800 | [diff] [blame] | 832 | void OpenGLRenderer::drawRegionRects(const Region& region) { |
| 833 | #if DEBUG_LAYERS_AS_REGIONS |
| 834 | size_t count; |
| 835 | const android::Rect* rects = region.getArray(&count); |
| 836 | |
| 837 | uint32_t colors[] = { |
| 838 | 0x7fff0000, 0x7f00ff00, |
| 839 | 0x7f0000ff, 0x7fff00ff, |
| 840 | }; |
| 841 | |
| 842 | int offset = 0; |
| 843 | int32_t top = rects[0].top; |
| 844 | |
| 845 | for (size_t i = 0; i < count; i++) { |
| 846 | if (top != rects[i].top) { |
| 847 | offset ^= 0x2; |
| 848 | top = rects[i].top; |
| 849 | } |
| 850 | |
| 851 | Rect r(rects[i].left, rects[i].top, rects[i].right, rects[i].bottom); |
| 852 | drawColorRect(r.left, r.top, r.right, r.bottom, colors[offset + (i & 0x1)], |
| 853 | SkXfermode::kSrcOver_Mode); |
| 854 | } |
| 855 | #endif |
| 856 | } |
| 857 | |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 858 | void OpenGLRenderer::dirtyLayer(const float left, const float top, |
| 859 | const float right, const float bottom, const mat4 transform) { |
| 860 | #if RENDER_LAYERS_AS_REGIONS |
Romain Guy | f219da5 | 2011-01-16 12:54:25 -0800 | [diff] [blame] | 861 | if (hasLayer()) { |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 862 | Rect bounds(left, top, right, bottom); |
| 863 | transform.mapRect(bounds); |
Romain Guy | f219da5 | 2011-01-16 12:54:25 -0800 | [diff] [blame] | 864 | dirtyLayerUnchecked(bounds, getRegion()); |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 865 | } |
| 866 | #endif |
| 867 | } |
| 868 | |
| 869 | void OpenGLRenderer::dirtyLayer(const float left, const float top, |
| 870 | const float right, const float bottom) { |
| 871 | #if RENDER_LAYERS_AS_REGIONS |
Romain Guy | f219da5 | 2011-01-16 12:54:25 -0800 | [diff] [blame] | 872 | if (hasLayer()) { |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 873 | Rect bounds(left, top, right, bottom); |
Romain Guy | f219da5 | 2011-01-16 12:54:25 -0800 | [diff] [blame] | 874 | dirtyLayerUnchecked(bounds, getRegion()); |
Romain Guy | 1bd1bad | 2011-01-14 20:07:20 -0800 | [diff] [blame] | 875 | } |
| 876 | #endif |
| 877 | } |
| 878 | |
| 879 | void OpenGLRenderer::dirtyLayerUnchecked(Rect& bounds, Region* region) { |
| 880 | #if RENDER_LAYERS_AS_REGIONS |
| 881 | if (bounds.intersect(*mSnapshot->clipRect)) { |
| 882 | bounds.snapToPixelBoundaries(); |
| 883 | android::Rect dirty(bounds.left, bounds.top, bounds.right, bounds.bottom); |
| 884 | if (!dirty.isEmpty()) { |
| 885 | region->orSelf(dirty); |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 886 | } |
| 887 | } |
| 888 | #endif |
| 889 | } |
| 890 | |
Romain Guy | 54be1cd | 2011-06-13 19:04:27 -0700 | [diff] [blame] | 891 | void OpenGLRenderer::clearLayerRegions() { |
| 892 | const size_t count = mLayers.size(); |
| 893 | if (count == 0) return; |
| 894 | |
| 895 | if (!mSnapshot->isIgnored()) { |
| 896 | // Doing several glScissor/glClear here can negatively impact |
| 897 | // GPUs with a tiler architecture, instead we draw quads with |
| 898 | // the Clear blending mode |
| 899 | |
| 900 | // The list contains bounds that have already been clipped |
| 901 | // against their initial clip rect, and the current clip |
| 902 | // is likely different so we need to disable clipping here |
| 903 | glDisable(GL_SCISSOR_TEST); |
| 904 | |
| 905 | Vertex mesh[count * 6]; |
| 906 | Vertex* vertex = mesh; |
| 907 | |
| 908 | for (uint32_t i = 0; i < count; i++) { |
| 909 | Rect* bounds = mLayers.itemAt(i); |
| 910 | |
| 911 | Vertex::set(vertex++, bounds->left, bounds->bottom); |
| 912 | Vertex::set(vertex++, bounds->left, bounds->top); |
| 913 | Vertex::set(vertex++, bounds->right, bounds->top); |
| 914 | Vertex::set(vertex++, bounds->left, bounds->bottom); |
| 915 | Vertex::set(vertex++, bounds->right, bounds->top); |
| 916 | Vertex::set(vertex++, bounds->right, bounds->bottom); |
| 917 | |
| 918 | delete bounds; |
| 919 | } |
| 920 | |
| 921 | setupDraw(false); |
| 922 | setupDrawColor(0.0f, 0.0f, 0.0f, 1.0f); |
| 923 | setupDrawBlending(true, SkXfermode::kClear_Mode); |
| 924 | setupDrawProgram(); |
| 925 | setupDrawPureColorUniforms(); |
| 926 | setupDrawModelViewTranslate(0.0f, 0.0f, 0.0f, 0.0f, true); |
Romain Guy | 39d252a | 2011-12-12 18:14:06 -0800 | [diff] [blame] | 927 | setupDrawVertices(&mesh[0].position[0]); |
Romain Guy | 54be1cd | 2011-06-13 19:04:27 -0700 | [diff] [blame] | 928 | |
Romain Guy | 54be1cd | 2011-06-13 19:04:27 -0700 | [diff] [blame] | 929 | glDrawArrays(GL_TRIANGLES, 0, count * 6); |
| 930 | |
| 931 | glEnable(GL_SCISSOR_TEST); |
| 932 | } else { |
| 933 | for (uint32_t i = 0; i < count; i++) { |
| 934 | delete mLayers.itemAt(i); |
| 935 | } |
| 936 | } |
| 937 | |
| 938 | mLayers.clear(); |
| 939 | } |
| 940 | |
Romain Guy | bd6b79b | 2010-06-26 00:13:53 -0700 | [diff] [blame] | 941 | /////////////////////////////////////////////////////////////////////////////// |
Romain Guy | f6a11b8 | 2010-06-23 17:47:49 -0700 | [diff] [blame] | 942 | // Transforms |
| 943 | /////////////////////////////////////////////////////////////////////////////// |
| 944 | |
| 945 | void OpenGLRenderer::translate(float dx, float dy) { |
Romain Guy | 8aef54f | 2010-09-01 15:13:49 -0700 | [diff] [blame] | 946 | mSnapshot->transform->translate(dx, dy, 0.0f); |
Romain Guy | f6a11b8 | 2010-06-23 17:47:49 -0700 | [diff] [blame] | 947 | } |
| 948 | |
| 949 | void OpenGLRenderer::rotate(float degrees) { |
Romain Guy | 8aef54f | 2010-09-01 15:13:49 -0700 | [diff] [blame] | 950 | mSnapshot->transform->rotate(degrees, 0.0f, 0.0f, 1.0f); |
Romain Guy | f6a11b8 | 2010-06-23 17:47:49 -0700 | [diff] [blame] | 951 | } |
| 952 | |
| 953 | void OpenGLRenderer::scale(float sx, float sy) { |
Romain Guy | 8aef54f | 2010-09-01 15:13:49 -0700 | [diff] [blame] | 954 | mSnapshot->transform->scale(sx, sy, 1.0f); |
Romain Guy | f6a11b8 | 2010-06-23 17:47:49 -0700 | [diff] [blame] | 955 | } |
| 956 | |
Romain Guy | 807daf7 | 2011-01-18 11:19:19 -0800 | [diff] [blame] | 957 | void OpenGLRenderer::skew(float sx, float sy) { |
| 958 | mSnapshot->transform->skew(sx, sy); |
| 959 | } |
| 960 | |
Romain Guy | f6a11b8 | 2010-06-23 17:47:49 -0700 | [diff] [blame] | 961 | void OpenGLRenderer::setMatrix(SkMatrix* matrix) { |
Romain Guy | e707859 | 2011-10-28 14:32:20 -0700 | [diff] [blame] | 962 | if (matrix) { |
| 963 | mSnapshot->transform->load(*matrix); |
| 964 | } else { |
| 965 | mSnapshot->transform->loadIdentity(); |
| 966 | } |
Romain Guy | f6a11b8 | 2010-06-23 17:47:49 -0700 | [diff] [blame] | 967 | } |
| 968 | |
| 969 | void OpenGLRenderer::getMatrix(SkMatrix* matrix) { |
Romain Guy | 8aef54f | 2010-09-01 15:13:49 -0700 | [diff] [blame] | 970 | mSnapshot->transform->copyTo(*matrix); |
Romain Guy | f6a11b8 | 2010-06-23 17:47:49 -0700 | [diff] [blame] | 971 | } |
| 972 | |
| 973 | void OpenGLRenderer::concatMatrix(SkMatrix* matrix) { |
Romain Guy | e5ebcb0 | 2010-10-15 13:57:28 -0700 | [diff] [blame] | 974 | SkMatrix transform; |
| 975 | mSnapshot->transform->copyTo(transform); |
| 976 | transform.preConcat(*matrix); |
| 977 | mSnapshot->transform->load(transform); |
Romain Guy | f6a11b8 | 2010-06-23 17:47:49 -0700 | [diff] [blame] | 978 | } |
| 979 | |
| 980 | /////////////////////////////////////////////////////////////////////////////// |
| 981 | // Clipping |
| 982 | /////////////////////////////////////////////////////////////////////////////// |
| 983 | |
Romain Guy | bb9524b | 2010-06-22 18:56:38 -0700 | [diff] [blame] | 984 | void OpenGLRenderer::setScissorFromClip() { |
Romain Guy | e5ebcb0 | 2010-10-15 13:57:28 -0700 | [diff] [blame] | 985 | Rect clip(*mSnapshot->clipRect); |
| 986 | clip.snapToPixelBoundaries(); |
Romain Guy | 8f85e80 | 2011-12-14 19:23:32 -0800 | [diff] [blame] | 987 | |
| 988 | mCaches.setScissor(clip.left, mSnapshot->height - clip.bottom, |
| 989 | clip.getWidth(), clip.getHeight()); |
| 990 | |
Romain Guy | 746b740 | 2010-10-26 16:27:31 -0700 | [diff] [blame] | 991 | mDirtyClip = false; |
Romain Guy | 9d5316e | 2010-06-24 19:30:36 -0700 | [diff] [blame] | 992 | } |
| 993 | |
| 994 | const Rect& OpenGLRenderer::getClipBounds() { |
Romain Guy | 079ba2c | 2010-07-16 14:12:24 -0700 | [diff] [blame] | 995 | return mSnapshot->getLocalClip(); |
Romain Guy | bb9524b | 2010-06-22 18:56:38 -0700 | [diff] [blame] | 996 | } |
| 997 | |
Romain Guy | c7d5349 | 2010-06-25 13:41:57 -0700 | [diff] [blame] | 998 | bool OpenGLRenderer::quickReject(float left, float top, float right, float bottom) { |
Romain Guy | af636eb | 2010-12-09 17:47:21 -0800 | [diff] [blame] | 999 | if (mSnapshot->isIgnored()) { |
Romain Guy | dbc26d2 | 2010-10-11 17:58:29 -0700 | [diff] [blame] | 1000 | return true; |
| 1001 | } |
| 1002 | |
Romain Guy | 1d83e19 | 2010-08-17 11:37:00 -0700 | [diff] [blame] | 1003 | Rect r(left, top, right, bottom); |
Romain Guy | 8aef54f | 2010-09-01 15:13:49 -0700 | [diff] [blame] | 1004 | mSnapshot->transform->mapRect(r); |
Romain Guy | d2a1ff0 | 2010-10-14 14:46:44 -0700 | [diff] [blame] | 1005 | r.snapToPixelBoundaries(); |
| 1006 | |
| 1007 | Rect clipRect(*mSnapshot->clipRect); |
| 1008 | clipRect.snapToPixelBoundaries(); |
| 1009 | |
| 1010 | return !clipRect.intersects(r); |
Romain Guy | c7d5349 | 2010-06-25 13:41:57 -0700 | [diff] [blame] | 1011 | } |
| 1012 | |
Romain Guy | 079ba2c | 2010-07-16 14:12:24 -0700 | [diff] [blame] | 1013 | bool OpenGLRenderer::clipRect(float left, float top, float right, float bottom, SkRegion::Op op) { |
| 1014 | bool clipped = mSnapshot->clip(left, top, right, bottom, op); |
Romain Guy | 7ae7ac4 | 2010-06-25 13:46:18 -0700 | [diff] [blame] | 1015 | if (clipped) { |
Romain Guy | 746b740 | 2010-10-26 16:27:31 -0700 | [diff] [blame] | 1016 | dirtyClip(); |
Romain Guy | 7ae7ac4 | 2010-06-25 13:46:18 -0700 | [diff] [blame] | 1017 | } |
Romain Guy | 8aef54f | 2010-09-01 15:13:49 -0700 | [diff] [blame] | 1018 | return !mSnapshot->clipRect->isEmpty(); |
Romain Guy | e4d0112 | 2010-06-16 18:44:05 -0700 | [diff] [blame] | 1019 | } |
| 1020 | |
Romain Guy | f6a11b8 | 2010-06-23 17:47:49 -0700 | [diff] [blame] | 1021 | /////////////////////////////////////////////////////////////////////////////// |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 1022 | // Drawing commands |
| 1023 | /////////////////////////////////////////////////////////////////////////////// |
| 1024 | |
Romain Guy | 54be1cd | 2011-06-13 19:04:27 -0700 | [diff] [blame] | 1025 | void OpenGLRenderer::setupDraw(bool clear) { |
| 1026 | if (clear) clearLayerRegions(); |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 1027 | if (mDirtyClip) { |
| 1028 | setScissorFromClip(); |
| 1029 | } |
| 1030 | mDescription.reset(); |
| 1031 | mSetShaderColor = false; |
| 1032 | mColorSet = false; |
| 1033 | mColorA = mColorR = mColorG = mColorB = 0.0f; |
| 1034 | mTextureUnit = 0; |
| 1035 | mTrackDirtyRegions = true; |
| 1036 | } |
| 1037 | |
| 1038 | void OpenGLRenderer::setupDrawWithTexture(bool isAlpha8) { |
| 1039 | mDescription.hasTexture = true; |
| 1040 | mDescription.hasAlpha8Texture = isAlpha8; |
| 1041 | } |
| 1042 | |
Romain Guy | aa6c24c | 2011-04-28 18:40:04 -0700 | [diff] [blame] | 1043 | void OpenGLRenderer::setupDrawWithExternalTexture() { |
| 1044 | mDescription.hasExternalTexture = true; |
| 1045 | } |
| 1046 | |
Romain Guy | 15bc643 | 2011-12-13 13:11:32 -0800 | [diff] [blame] | 1047 | void OpenGLRenderer::setupDrawNoTexture() { |
| 1048 | mCaches.disbaleTexCoordsVertexArray(); |
| 1049 | } |
| 1050 | |
Chet Haase | 5b0200b | 2011-04-13 17:58:08 -0700 | [diff] [blame] | 1051 | void OpenGLRenderer::setupDrawAALine() { |
Chet Haase | 99585ad | 2011-05-02 15:00:16 -0700 | [diff] [blame] | 1052 | mDescription.isAA = true; |
Chet Haase | 5b0200b | 2011-04-13 17:58:08 -0700 | [diff] [blame] | 1053 | } |
| 1054 | |
Romain Guy | ed6fcb0 | 2011-03-21 13:11:28 -0700 | [diff] [blame] | 1055 | void OpenGLRenderer::setupDrawPoint(float pointSize) { |
| 1056 | mDescription.isPoint = true; |
| 1057 | mDescription.pointSize = pointSize; |
| 1058 | } |
| 1059 | |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 1060 | void OpenGLRenderer::setupDrawColor(int color) { |
Romain Guy | 8d0d478 | 2010-12-14 20:13:35 -0800 | [diff] [blame] | 1061 | setupDrawColor(color, (color >> 24) & 0xFF); |
| 1062 | } |
| 1063 | |
| 1064 | void OpenGLRenderer::setupDrawColor(int color, int alpha) { |
| 1065 | mColorA = alpha / 255.0f; |
Chet Haase | 6cfdf45 | 2011-04-22 16:42:10 -0700 | [diff] [blame] | 1066 | // Second divide of a by 255 is an optimization, allowing us to simply multiply |
| 1067 | // the rgb values by a instead of also dividing by 255 |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 1068 | const float a = mColorA / 255.0f; |
Romain Guy | fa7952d | 2010-12-14 13:45:54 -0800 | [diff] [blame] | 1069 | mColorR = a * ((color >> 16) & 0xFF); |
| 1070 | mColorG = a * ((color >> 8) & 0xFF); |
| 1071 | mColorB = a * ((color ) & 0xFF); |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 1072 | mColorSet = true; |
| 1073 | mSetShaderColor = mDescription.setColor(mColorR, mColorG, mColorB, mColorA); |
| 1074 | } |
| 1075 | |
Romain Guy | 8656819 | 2010-12-14 15:55:39 -0800 | [diff] [blame] | 1076 | void OpenGLRenderer::setupDrawAlpha8Color(int color, int alpha) { |
| 1077 | mColorA = alpha / 255.0f; |
Chet Haase | 6cfdf45 | 2011-04-22 16:42:10 -0700 | [diff] [blame] | 1078 | // Double-divide of a by 255 is an optimization, allowing us to simply multiply |
| 1079 | // the rgb values by a instead of also dividing by 255 |
Romain Guy | 8656819 | 2010-12-14 15:55:39 -0800 | [diff] [blame] | 1080 | const float a = mColorA / 255.0f; |
| 1081 | mColorR = a * ((color >> 16) & 0xFF); |
| 1082 | mColorG = a * ((color >> 8) & 0xFF); |
| 1083 | mColorB = a * ((color ) & 0xFF); |
| 1084 | mColorSet = true; |
| 1085 | mSetShaderColor = mDescription.setAlpha8Color(mColorR, mColorG, mColorB, mColorA); |
| 1086 | } |
| 1087 | |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 1088 | void OpenGLRenderer::setupDrawColor(float r, float g, float b, float a) { |
| 1089 | mColorA = a; |
| 1090 | mColorR = r; |
| 1091 | mColorG = g; |
| 1092 | mColorB = b; |
| 1093 | mColorSet = true; |
| 1094 | mSetShaderColor = mDescription.setColor(r, g, b, a); |
| 1095 | } |
| 1096 | |
Romain Guy | 8656819 | 2010-12-14 15:55:39 -0800 | [diff] [blame] | 1097 | void OpenGLRenderer::setupDrawAlpha8Color(float r, float g, float b, float a) { |
| 1098 | mColorA = a; |
| 1099 | mColorR = r; |
| 1100 | mColorG = g; |
| 1101 | mColorB = b; |
| 1102 | mColorSet = true; |
| 1103 | mSetShaderColor = mDescription.setAlpha8Color(r, g, b, a); |
| 1104 | } |
| 1105 | |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 1106 | void OpenGLRenderer::setupDrawShader() { |
| 1107 | if (mShader) { |
| 1108 | mShader->describe(mDescription, mCaches.extensions); |
| 1109 | } |
| 1110 | } |
| 1111 | |
| 1112 | void OpenGLRenderer::setupDrawColorFilter() { |
| 1113 | if (mColorFilter) { |
| 1114 | mColorFilter->describe(mDescription, mCaches.extensions); |
| 1115 | } |
| 1116 | } |
| 1117 | |
Romain Guy | f09ef51 | 2011-05-27 11:43:46 -0700 | [diff] [blame] | 1118 | void OpenGLRenderer::accountForClear(SkXfermode::Mode mode) { |
| 1119 | if (mColorSet && mode == SkXfermode::kClear_Mode) { |
| 1120 | mColorA = 1.0f; |
| 1121 | mColorR = mColorG = mColorB = 0.0f; |
Romain Guy | 54be1cd | 2011-06-13 19:04:27 -0700 | [diff] [blame] | 1122 | mSetShaderColor = mDescription.modulate = true; |
Romain Guy | f09ef51 | 2011-05-27 11:43:46 -0700 | [diff] [blame] | 1123 | } |
| 1124 | } |
| 1125 | |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 1126 | void OpenGLRenderer::setupDrawBlending(SkXfermode::Mode mode, bool swapSrcDst) { |
Romain Guy | f09ef51 | 2011-05-27 11:43:46 -0700 | [diff] [blame] | 1127 | // When the blending mode is kClear_Mode, we need to use a modulate color |
| 1128 | // argb=1,0,0,0 |
| 1129 | accountForClear(mode); |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 1130 | chooseBlending((mColorSet && mColorA < 1.0f) || (mShader && mShader->blend()), mode, |
| 1131 | mDescription, swapSrcDst); |
| 1132 | } |
| 1133 | |
| 1134 | void OpenGLRenderer::setupDrawBlending(bool blend, SkXfermode::Mode mode, bool swapSrcDst) { |
Romain Guy | f09ef51 | 2011-05-27 11:43:46 -0700 | [diff] [blame] | 1135 | // When the blending mode is kClear_Mode, we need to use a modulate color |
| 1136 | // argb=1,0,0,0 |
| 1137 | accountForClear(mode); |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 1138 | chooseBlending(blend || (mColorSet && mColorA < 1.0f) || (mShader && mShader->blend()), mode, |
| 1139 | mDescription, swapSrcDst); |
| 1140 | } |
| 1141 | |
| 1142 | void OpenGLRenderer::setupDrawProgram() { |
| 1143 | useProgram(mCaches.programCache.get(mDescription)); |
| 1144 | } |
| 1145 | |
| 1146 | void OpenGLRenderer::setupDrawDirtyRegionsDisabled() { |
| 1147 | mTrackDirtyRegions = false; |
| 1148 | } |
| 1149 | |
| 1150 | void OpenGLRenderer::setupDrawModelViewTranslate(float left, float top, float right, float bottom, |
| 1151 | bool ignoreTransform) { |
| 1152 | mModelView.loadTranslate(left, top, 0.0f); |
| 1153 | if (!ignoreTransform) { |
| 1154 | mCaches.currentProgram->set(mOrthoMatrix, mModelView, *mSnapshot->transform); |
| 1155 | if (mTrackDirtyRegions) dirtyLayer(left, top, right, bottom, *mSnapshot->transform); |
| 1156 | } else { |
| 1157 | mCaches.currentProgram->set(mOrthoMatrix, mModelView, mIdentity); |
| 1158 | if (mTrackDirtyRegions) dirtyLayer(left, top, right, bottom); |
| 1159 | } |
| 1160 | } |
| 1161 | |
Chet Haase | 8a5cc92 | 2011-04-26 07:28:09 -0700 | [diff] [blame] | 1162 | void OpenGLRenderer::setupDrawModelViewIdentity(bool offset) { |
| 1163 | mCaches.currentProgram->set(mOrthoMatrix, mIdentity, *mSnapshot->transform, offset); |
Romain Guy | 8d0d478 | 2010-12-14 20:13:35 -0800 | [diff] [blame] | 1164 | } |
| 1165 | |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 1166 | void OpenGLRenderer::setupDrawModelView(float left, float top, float right, float bottom, |
| 1167 | bool ignoreTransform, bool ignoreModelView) { |
| 1168 | if (!ignoreModelView) { |
| 1169 | mModelView.loadTranslate(left, top, 0.0f); |
| 1170 | mModelView.scale(right - left, bottom - top, 1.0f); |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 1171 | } else { |
| 1172 | mModelView.loadIdentity(); |
| 1173 | } |
Romain Guy | 8656819 | 2010-12-14 15:55:39 -0800 | [diff] [blame] | 1174 | bool dirty = right - left > 0.0f && bottom - top > 0.0f; |
| 1175 | if (!ignoreTransform) { |
| 1176 | mCaches.currentProgram->set(mOrthoMatrix, mModelView, *mSnapshot->transform); |
| 1177 | if (mTrackDirtyRegions && dirty) { |
| 1178 | dirtyLayer(left, top, right, bottom, *mSnapshot->transform); |
| 1179 | } |
| 1180 | } else { |
| 1181 | mCaches.currentProgram->set(mOrthoMatrix, mModelView, mIdentity); |
| 1182 | if (mTrackDirtyRegions && dirty) dirtyLayer(left, top, right, bottom); |
| 1183 | } |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 1184 | } |
| 1185 | |
Romain Guy | ed6fcb0 | 2011-03-21 13:11:28 -0700 | [diff] [blame] | 1186 | void OpenGLRenderer::setupDrawPointUniforms() { |
| 1187 | int slot = mCaches.currentProgram->getUniform("pointSize"); |
| 1188 | glUniform1f(slot, mDescription.pointSize); |
| 1189 | } |
| 1190 | |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 1191 | void OpenGLRenderer::setupDrawColorUniforms() { |
Romain Guy | 55fd2c9 | 2012-03-09 17:36:01 -0800 | [diff] [blame] | 1192 | if ((mColorSet && !mShader) || (mShader && mSetShaderColor)) { |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 1193 | mCaches.currentProgram->setColor(mColorR, mColorG, mColorB, mColorA); |
| 1194 | } |
| 1195 | } |
| 1196 | |
Romain Guy | 8656819 | 2010-12-14 15:55:39 -0800 | [diff] [blame] | 1197 | void OpenGLRenderer::setupDrawPureColorUniforms() { |
Romain Guy | 5536841 | 2010-12-14 10:59:41 -0800 | [diff] [blame] | 1198 | if (mSetShaderColor) { |
Romain Guy | 8656819 | 2010-12-14 15:55:39 -0800 | [diff] [blame] | 1199 | mCaches.currentProgram->setColor(mColorR, mColorG, mColorB, mColorA); |
Romain Guy | 5536841 | 2010-12-14 10:59:41 -0800 | [diff] [blame] | 1200 | } |
| 1201 | } |
| 1202 | |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 1203 | void OpenGLRenderer::setupDrawShaderUniforms(bool ignoreTransform) { |
| 1204 | if (mShader) { |
| 1205 | if (ignoreTransform) { |
| 1206 | mModelView.loadInverse(*mSnapshot->transform); |
| 1207 | } |
| 1208 | mShader->setupProgram(mCaches.currentProgram, mModelView, *mSnapshot, &mTextureUnit); |
| 1209 | } |
| 1210 | } |
| 1211 | |
Romain Guy | 8d0d478 | 2010-12-14 20:13:35 -0800 | [diff] [blame] | 1212 | void OpenGLRenderer::setupDrawShaderIdentityUniforms() { |
| 1213 | if (mShader) { |
| 1214 | mShader->setupProgram(mCaches.currentProgram, mIdentity, *mSnapshot, &mTextureUnit); |
| 1215 | } |
| 1216 | } |
| 1217 | |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 1218 | void OpenGLRenderer::setupDrawColorFilterUniforms() { |
| 1219 | if (mColorFilter) { |
| 1220 | mColorFilter->setupProgram(mCaches.currentProgram); |
| 1221 | } |
| 1222 | } |
| 1223 | |
| 1224 | void OpenGLRenderer::setupDrawSimpleMesh() { |
Romain Guy | f3a910b4 | 2011-12-12 20:35:21 -0800 | [diff] [blame] | 1225 | bool force = mCaches.bindMeshBuffer(); |
| 1226 | mCaches.bindPositionVertexPointer(force, mCaches.currentProgram->position, 0); |
Romain Guy | 15bc643 | 2011-12-13 13:11:32 -0800 | [diff] [blame] | 1227 | mCaches.unbindIndicesBuffer(); |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 1228 | } |
| 1229 | |
| 1230 | void OpenGLRenderer::setupDrawTexture(GLuint texture) { |
| 1231 | bindTexture(texture); |
Romain Guy | 2d4fd36 | 2011-12-13 22:00:19 -0800 | [diff] [blame] | 1232 | mTextureUnit++; |
Romain Guy | 15bc643 | 2011-12-13 13:11:32 -0800 | [diff] [blame] | 1233 | mCaches.enableTexCoordsVertexArray(); |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 1234 | } |
| 1235 | |
Romain Guy | aa6c24c | 2011-04-28 18:40:04 -0700 | [diff] [blame] | 1236 | void OpenGLRenderer::setupDrawExternalTexture(GLuint texture) { |
| 1237 | bindExternalTexture(texture); |
Romain Guy | 2d4fd36 | 2011-12-13 22:00:19 -0800 | [diff] [blame] | 1238 | mTextureUnit++; |
Romain Guy | 15bc643 | 2011-12-13 13:11:32 -0800 | [diff] [blame] | 1239 | mCaches.enableTexCoordsVertexArray(); |
Romain Guy | aa6c24c | 2011-04-28 18:40:04 -0700 | [diff] [blame] | 1240 | } |
| 1241 | |
Romain Guy | 8f0095c | 2011-05-02 17:24:22 -0700 | [diff] [blame] | 1242 | void OpenGLRenderer::setupDrawTextureTransform() { |
| 1243 | mDescription.hasTextureTransform = true; |
| 1244 | } |
| 1245 | |
| 1246 | void OpenGLRenderer::setupDrawTextureTransformUniforms(mat4& transform) { |
Romain Guy | aa6c24c | 2011-04-28 18:40:04 -0700 | [diff] [blame] | 1247 | glUniformMatrix4fv(mCaches.currentProgram->getUniform("mainTextureTransform"), 1, |
| 1248 | GL_FALSE, &transform.data[0]); |
| 1249 | } |
| 1250 | |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 1251 | void OpenGLRenderer::setupDrawMesh(GLvoid* vertices, GLvoid* texCoords, GLuint vbo) { |
Romain Guy | f3a910b4 | 2011-12-12 20:35:21 -0800 | [diff] [blame] | 1252 | bool force = false; |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 1253 | if (!vertices) { |
Romain Guy | f3a910b4 | 2011-12-12 20:35:21 -0800 | [diff] [blame] | 1254 | force = mCaches.bindMeshBuffer(vbo == 0 ? mCaches.meshBuffer : vbo); |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 1255 | } else { |
Romain Guy | f3a910b4 | 2011-12-12 20:35:21 -0800 | [diff] [blame] | 1256 | force = mCaches.unbindMeshBuffer(); |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 1257 | } |
Romain Guy | d71dd36 | 2011-12-12 19:03:35 -0800 | [diff] [blame] | 1258 | |
Romain Guy | f3a910b4 | 2011-12-12 20:35:21 -0800 | [diff] [blame] | 1259 | mCaches.bindPositionVertexPointer(force, mCaches.currentProgram->position, vertices); |
Romain Guy | 15bc643 | 2011-12-13 13:11:32 -0800 | [diff] [blame] | 1260 | if (mCaches.currentProgram->texCoords >= 0) { |
| 1261 | mCaches.bindTexCoordsVertexPointer(force, mCaches.currentProgram->texCoords, texCoords); |
| 1262 | } |
| 1263 | |
| 1264 | mCaches.unbindIndicesBuffer(); |
| 1265 | } |
| 1266 | |
| 1267 | void OpenGLRenderer::setupDrawMeshIndices(GLvoid* vertices, GLvoid* texCoords) { |
| 1268 | bool force = mCaches.unbindMeshBuffer(); |
| 1269 | mCaches.bindPositionVertexPointer(force, mCaches.currentProgram->position, vertices); |
| 1270 | if (mCaches.currentProgram->texCoords >= 0) { |
| 1271 | mCaches.bindTexCoordsVertexPointer(force, mCaches.currentProgram->texCoords, texCoords); |
Romain Guy | 8d0d478 | 2010-12-14 20:13:35 -0800 | [diff] [blame] | 1272 | } |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 1273 | } |
| 1274 | |
Chet Haase | 5b0200b | 2011-04-13 17:58:08 -0700 | [diff] [blame] | 1275 | void OpenGLRenderer::setupDrawVertices(GLvoid* vertices) { |
Romain Guy | f3a910b4 | 2011-12-12 20:35:21 -0800 | [diff] [blame] | 1276 | bool force = mCaches.unbindMeshBuffer(); |
| 1277 | mCaches.bindPositionVertexPointer(force, mCaches.currentProgram->position, |
| 1278 | vertices, gVertexStride); |
Romain Guy | 15bc643 | 2011-12-13 13:11:32 -0800 | [diff] [blame] | 1279 | mCaches.unbindIndicesBuffer(); |
Chet Haase | 5b0200b | 2011-04-13 17:58:08 -0700 | [diff] [blame] | 1280 | } |
| 1281 | |
| 1282 | /** |
| 1283 | * Sets up the shader to draw an AA line. We draw AA lines with quads, where there is an |
Chet Haase | 99585ad | 2011-05-02 15:00:16 -0700 | [diff] [blame] | 1284 | * outer boundary that fades out to 0. The variables set in the shader define the proportion of |
| 1285 | * the width and length of the primitive occupied by the AA region. The vtxWidth and vtxLength |
| 1286 | * attributes (one per vertex) are values from zero to one that tells the fragment |
| 1287 | * shader where the fragment is in relation to the line width/length overall; these values are |
| 1288 | * then used to compute the proper color, based on whether the fragment lies in the fading AA |
| 1289 | * region of the line. |
| 1290 | * Note that we only pass down the width values in this setup function. The length coordinates |
| 1291 | * are set up for each individual segment. |
Chet Haase | 5b0200b | 2011-04-13 17:58:08 -0700 | [diff] [blame] | 1292 | */ |
Chet Haase | 99585ad | 2011-05-02 15:00:16 -0700 | [diff] [blame] | 1293 | void OpenGLRenderer::setupDrawAALine(GLvoid* vertices, GLvoid* widthCoords, |
Chet Haase | 99ecdc4 | 2011-05-06 12:06:34 -0700 | [diff] [blame] | 1294 | GLvoid* lengthCoords, float boundaryWidthProportion) { |
Romain Guy | f3a910b4 | 2011-12-12 20:35:21 -0800 | [diff] [blame] | 1295 | bool force = mCaches.unbindMeshBuffer(); |
| 1296 | mCaches.bindPositionVertexPointer(force, mCaches.currentProgram->position, |
| 1297 | vertices, gAAVertexStride); |
| 1298 | mCaches.resetTexCoordsVertexPointer(); |
Romain Guy | 15bc643 | 2011-12-13 13:11:32 -0800 | [diff] [blame] | 1299 | mCaches.unbindIndicesBuffer(); |
Romain Guy | d71dd36 | 2011-12-12 19:03:35 -0800 | [diff] [blame] | 1300 | |
Chet Haase | 99585ad | 2011-05-02 15:00:16 -0700 | [diff] [blame] | 1301 | int widthSlot = mCaches.currentProgram->getAttrib("vtxWidth"); |
| 1302 | glEnableVertexAttribArray(widthSlot); |
| 1303 | glVertexAttribPointer(widthSlot, 1, GL_FLOAT, GL_FALSE, gAAVertexStride, widthCoords); |
Romain Guy | d71dd36 | 2011-12-12 19:03:35 -0800 | [diff] [blame] | 1304 | |
Chet Haase | 99585ad | 2011-05-02 15:00:16 -0700 | [diff] [blame] | 1305 | int lengthSlot = mCaches.currentProgram->getAttrib("vtxLength"); |
| 1306 | glEnableVertexAttribArray(lengthSlot); |
| 1307 | glVertexAttribPointer(lengthSlot, 1, GL_FLOAT, GL_FALSE, gAAVertexStride, lengthCoords); |
Romain Guy | d71dd36 | 2011-12-12 19:03:35 -0800 | [diff] [blame] | 1308 | |
Chet Haase | 5b0200b | 2011-04-13 17:58:08 -0700 | [diff] [blame] | 1309 | int boundaryWidthSlot = mCaches.currentProgram->getUniform("boundaryWidth"); |
Chet Haase | 99ecdc4 | 2011-05-06 12:06:34 -0700 | [diff] [blame] | 1310 | glUniform1f(boundaryWidthSlot, boundaryWidthProportion); |
Romain Guy | d71dd36 | 2011-12-12 19:03:35 -0800 | [diff] [blame] | 1311 | |
Chet Haase | 99585ad | 2011-05-02 15:00:16 -0700 | [diff] [blame] | 1312 | // Setting the inverse value saves computations per-fragment in the shader |
Chet Haase | 5b0200b | 2011-04-13 17:58:08 -0700 | [diff] [blame] | 1313 | int inverseBoundaryWidthSlot = mCaches.currentProgram->getUniform("inverseBoundaryWidth"); |
Chet Haase | 99ecdc4 | 2011-05-06 12:06:34 -0700 | [diff] [blame] | 1314 | glUniform1f(inverseBoundaryWidthSlot, (1 / boundaryWidthProportion)); |
Chet Haase | 5b0200b | 2011-04-13 17:58:08 -0700 | [diff] [blame] | 1315 | } |
| 1316 | |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 1317 | void OpenGLRenderer::finishDrawTexture() { |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 1318 | } |
| 1319 | |
| 1320 | /////////////////////////////////////////////////////////////////////////////// |
Romain Guy | f6a11b8 | 2010-06-23 17:47:49 -0700 | [diff] [blame] | 1321 | // Drawing |
| 1322 | /////////////////////////////////////////////////////////////////////////////// |
| 1323 | |
Romain Guy | 6554943 | 2012-03-26 16:45:05 -0700 | [diff] [blame] | 1324 | status_t OpenGLRenderer::drawDisplayList(DisplayList* displayList, uint32_t width, uint32_t height, |
Romain Guy | 33f6beb | 2012-02-16 19:24:51 -0800 | [diff] [blame] | 1325 | Rect& dirty, int32_t flags, uint32_t level) { |
Chet Haase | b85967b | 2012-03-26 14:37:51 -0700 | [diff] [blame] | 1326 | |
| 1327 | if (!USE_DISPLAY_LIST_PROPERTIES && quickReject(0, 0, width, height)) { |
Romain Guy | 7b5b6ab | 2011-03-14 18:05:08 -0700 | [diff] [blame] | 1328 | return false; |
| 1329 | } |
| 1330 | |
Romain Guy | 0fe478e | 2010-11-08 12:08:41 -0800 | [diff] [blame] | 1331 | // All the usual checks and setup operations (quickReject, setupDraw, etc.) |
| 1332 | // will be performed by the display list itself |
Romain Guy | 04c9d8c | 2011-08-25 14:01:48 -0700 | [diff] [blame] | 1333 | if (displayList && displayList->isRenderable()) { |
Chet Haase | a1cff50 | 2012-02-21 13:43:44 -0800 | [diff] [blame] | 1334 | return displayList->replay(*this, width, height, dirty, flags, level); |
Romain Guy | 0fe478e | 2010-11-08 12:08:41 -0800 | [diff] [blame] | 1335 | } |
Romain Guy | 7b5b6ab | 2011-03-14 18:05:08 -0700 | [diff] [blame] | 1336 | |
Romain Guy | 6554943 | 2012-03-26 16:45:05 -0700 | [diff] [blame] | 1337 | return DrawGlInfo::kStatusDone; |
Romain Guy | 0fe478e | 2010-11-08 12:08:41 -0800 | [diff] [blame] | 1338 | } |
| 1339 | |
Chet Haase | ed30fd8 | 2011-04-22 16:18:45 -0700 | [diff] [blame] | 1340 | void OpenGLRenderer::outputDisplayList(DisplayList* displayList, uint32_t level) { |
| 1341 | if (displayList) { |
| 1342 | displayList->output(*this, level); |
| 1343 | } |
| 1344 | } |
| 1345 | |
Romain Guy | a168d73 | 2011-03-18 16:50:13 -0700 | [diff] [blame] | 1346 | void OpenGLRenderer::drawAlphaBitmap(Texture* texture, float left, float top, SkPaint* paint) { |
| 1347 | int alpha; |
| 1348 | SkXfermode::Mode mode; |
| 1349 | getAlphaAndMode(paint, &alpha, &mode); |
| 1350 | |
Romain Guy | a168d73 | 2011-03-18 16:50:13 -0700 | [diff] [blame] | 1351 | float x = left; |
| 1352 | float y = top; |
| 1353 | |
Romain Guy | e3c2685 | 2011-07-25 16:36:01 -0700 | [diff] [blame] | 1354 | GLenum filter = GL_LINEAR; |
Romain Guy | a168d73 | 2011-03-18 16:50:13 -0700 | [diff] [blame] | 1355 | bool ignoreTransform = false; |
| 1356 | if (mSnapshot->transform->isPureTranslate()) { |
| 1357 | x = (int) floorf(left + mSnapshot->transform->getTranslateX() + 0.5f); |
| 1358 | y = (int) floorf(top + mSnapshot->transform->getTranslateY() + 0.5f); |
| 1359 | ignoreTransform = true; |
Romain Guy | e3c2685 | 2011-07-25 16:36:01 -0700 | [diff] [blame] | 1360 | filter = GL_NEAREST; |
Romain Guy | d21b6e1 | 2011-11-30 20:21:23 -0800 | [diff] [blame] | 1361 | } else { |
| 1362 | filter = FILTER(paint); |
Romain Guy | a168d73 | 2011-03-18 16:50:13 -0700 | [diff] [blame] | 1363 | } |
| 1364 | |
| 1365 | setupDraw(); |
| 1366 | setupDrawWithTexture(true); |
Romain Guy | 5b7a315 | 2011-03-23 17:15:38 -0700 | [diff] [blame] | 1367 | if (paint) { |
| 1368 | setupDrawAlpha8Color(paint->getColor(), alpha); |
| 1369 | } |
Romain Guy | a168d73 | 2011-03-18 16:50:13 -0700 | [diff] [blame] | 1370 | setupDrawColorFilter(); |
| 1371 | setupDrawShader(); |
| 1372 | setupDrawBlending(true, mode); |
| 1373 | setupDrawProgram(); |
| 1374 | setupDrawModelView(x, y, x + texture->width, y + texture->height, ignoreTransform); |
Romain Guy | e3c2685 | 2011-07-25 16:36:01 -0700 | [diff] [blame] | 1375 | |
Romain Guy | a168d73 | 2011-03-18 16:50:13 -0700 | [diff] [blame] | 1376 | setupDrawTexture(texture->id); |
Romain Guy | d21b6e1 | 2011-11-30 20:21:23 -0800 | [diff] [blame] | 1377 | texture->setWrap(GL_CLAMP_TO_EDGE); |
| 1378 | texture->setFilter(filter); |
Romain Guy | e3c2685 | 2011-07-25 16:36:01 -0700 | [diff] [blame] | 1379 | |
Romain Guy | a168d73 | 2011-03-18 16:50:13 -0700 | [diff] [blame] | 1380 | setupDrawPureColorUniforms(); |
| 1381 | setupDrawColorFilterUniforms(); |
| 1382 | setupDrawShaderUniforms(); |
| 1383 | setupDrawMesh(NULL, (GLvoid*) gMeshTextureOffset); |
| 1384 | |
| 1385 | glDrawArrays(GL_TRIANGLE_STRIP, 0, gMeshCount); |
| 1386 | |
| 1387 | finishDrawTexture(); |
| 1388 | } |
| 1389 | |
Chet Haase | 5c13d89 | 2010-10-08 08:37:55 -0700 | [diff] [blame] | 1390 | void OpenGLRenderer::drawBitmap(SkBitmap* bitmap, float left, float top, SkPaint* paint) { |
Romain Guy | 6926c72 | 2010-07-12 20:20:03 -0700 | [diff] [blame] | 1391 | const float right = left + bitmap->width(); |
| 1392 | const float bottom = top + bitmap->height(); |
| 1393 | |
| 1394 | if (quickReject(left, top, right, bottom)) { |
| 1395 | return; |
| 1396 | } |
| 1397 | |
Romain Guy | a1d3c91 | 2011-12-13 14:55:06 -0800 | [diff] [blame] | 1398 | mCaches.activeTexture(0); |
Romain Guy | 8164c2d | 2010-10-25 18:03:28 -0700 | [diff] [blame] | 1399 | Texture* texture = mCaches.textureCache.get(bitmap); |
Romain Guy | 9cccc2b | 2010-08-07 23:46:15 -0700 | [diff] [blame] | 1400 | if (!texture) return; |
Romain Guy | 22158e1 | 2010-08-06 11:18:34 -0700 | [diff] [blame] | 1401 | const AutoTexture autoCleanup(texture); |
| 1402 | |
Romain Guy | 211370f | 2012-02-01 16:10:55 -0800 | [diff] [blame] | 1403 | if (CC_UNLIKELY(bitmap->getConfig() == SkBitmap::kA8_Config)) { |
Romain Guy | a168d73 | 2011-03-18 16:50:13 -0700 | [diff] [blame] | 1404 | drawAlphaBitmap(texture, left, top, paint); |
| 1405 | } else { |
| 1406 | drawTextureRect(left, top, right, bottom, texture, paint); |
| 1407 | } |
Romain Guy | ce0537b | 2010-06-29 21:05:21 -0700 | [diff] [blame] | 1408 | } |
| 1409 | |
Chet Haase | 5c13d89 | 2010-10-08 08:37:55 -0700 | [diff] [blame] | 1410 | void OpenGLRenderer::drawBitmap(SkBitmap* bitmap, SkMatrix* matrix, SkPaint* paint) { |
Romain Guy | f86ef57 | 2010-07-01 11:05:42 -0700 | [diff] [blame] | 1411 | Rect r(0.0f, 0.0f, bitmap->width(), bitmap->height()); |
| 1412 | const mat4 transform(*matrix); |
| 1413 | transform.mapRect(r); |
| 1414 | |
Romain Guy | 6926c72 | 2010-07-12 20:20:03 -0700 | [diff] [blame] | 1415 | if (quickReject(r.left, r.top, r.right, r.bottom)) { |
| 1416 | return; |
| 1417 | } |
| 1418 | |
Romain Guy | a1d3c91 | 2011-12-13 14:55:06 -0800 | [diff] [blame] | 1419 | mCaches.activeTexture(0); |
Romain Guy | 8164c2d | 2010-10-25 18:03:28 -0700 | [diff] [blame] | 1420 | Texture* texture = mCaches.textureCache.get(bitmap); |
Romain Guy | 9cccc2b | 2010-08-07 23:46:15 -0700 | [diff] [blame] | 1421 | if (!texture) return; |
Romain Guy | 22158e1 | 2010-08-06 11:18:34 -0700 | [diff] [blame] | 1422 | const AutoTexture autoCleanup(texture); |
| 1423 | |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 1424 | // This could be done in a cheaper way, all we need is pass the matrix |
| 1425 | // to the vertex shader. The save/restore is a bit overkill. |
| 1426 | save(SkCanvas::kMatrix_SaveFlag); |
| 1427 | concatMatrix(matrix); |
| 1428 | drawTextureRect(0.0f, 0.0f, bitmap->width(), bitmap->height(), texture, paint); |
| 1429 | restore(); |
Romain Guy | f86ef57 | 2010-07-01 11:05:42 -0700 | [diff] [blame] | 1430 | } |
| 1431 | |
Romain Guy | 5a7b466 | 2011-01-20 19:09:30 -0800 | [diff] [blame] | 1432 | void OpenGLRenderer::drawBitmapMesh(SkBitmap* bitmap, int meshWidth, int meshHeight, |
| 1433 | float* vertices, int* colors, SkPaint* paint) { |
| 1434 | // TODO: Do a quickReject |
| 1435 | if (!vertices || mSnapshot->isIgnored()) { |
| 1436 | return; |
| 1437 | } |
| 1438 | |
Romain Guy | a1d3c91 | 2011-12-13 14:55:06 -0800 | [diff] [blame] | 1439 | mCaches.activeTexture(0); |
Romain Guy | 5a7b466 | 2011-01-20 19:09:30 -0800 | [diff] [blame] | 1440 | Texture* texture = mCaches.textureCache.get(bitmap); |
| 1441 | if (!texture) return; |
| 1442 | const AutoTexture autoCleanup(texture); |
Romain Guy | e3c2685 | 2011-07-25 16:36:01 -0700 | [diff] [blame] | 1443 | |
Romain Guy | d21b6e1 | 2011-11-30 20:21:23 -0800 | [diff] [blame] | 1444 | texture->setWrap(GL_CLAMP_TO_EDGE, true); |
| 1445 | texture->setFilter(FILTER(paint), true); |
Romain Guy | 5a7b466 | 2011-01-20 19:09:30 -0800 | [diff] [blame] | 1446 | |
| 1447 | int alpha; |
| 1448 | SkXfermode::Mode mode; |
| 1449 | getAlphaAndMode(paint, &alpha, &mode); |
| 1450 | |
Romain Guy | 5a7b466 | 2011-01-20 19:09:30 -0800 | [diff] [blame] | 1451 | const uint32_t count = meshWidth * meshHeight * 6; |
Romain Guy | 5a7b466 | 2011-01-20 19:09:30 -0800 | [diff] [blame] | 1452 | |
Romain Guy | b18d2d0 | 2011-02-10 15:52:54 -0800 | [diff] [blame] | 1453 | float left = FLT_MAX; |
| 1454 | float top = FLT_MAX; |
| 1455 | float right = FLT_MIN; |
| 1456 | float bottom = FLT_MIN; |
| 1457 | |
| 1458 | #if RENDER_LAYERS_AS_REGIONS |
Romain Guy | 211370f | 2012-02-01 16:10:55 -0800 | [diff] [blame] | 1459 | const bool hasActiveLayer = hasLayer(); |
Romain Guy | b18d2d0 | 2011-02-10 15:52:54 -0800 | [diff] [blame] | 1460 | #else |
Romain Guy | 211370f | 2012-02-01 16:10:55 -0800 | [diff] [blame] | 1461 | const bool hasActiveLayer = false; |
Romain Guy | b18d2d0 | 2011-02-10 15:52:54 -0800 | [diff] [blame] | 1462 | #endif |
| 1463 | |
Romain Guy | a566b7c | 2011-01-23 16:36:11 -0800 | [diff] [blame] | 1464 | // TODO: Support the colors array |
| 1465 | TextureVertex mesh[count]; |
Romain Guy | 5a7b466 | 2011-01-20 19:09:30 -0800 | [diff] [blame] | 1466 | TextureVertex* vertex = mesh; |
| 1467 | for (int32_t y = 0; y < meshHeight; y++) { |
| 1468 | for (int32_t x = 0; x < meshWidth; x++) { |
| 1469 | uint32_t i = (y * (meshWidth + 1) + x) * 2; |
| 1470 | |
| 1471 | float u1 = float(x) / meshWidth; |
| 1472 | float u2 = float(x + 1) / meshWidth; |
| 1473 | float v1 = float(y) / meshHeight; |
| 1474 | float v2 = float(y + 1) / meshHeight; |
| 1475 | |
| 1476 | int ax = i + (meshWidth + 1) * 2; |
| 1477 | int ay = ax + 1; |
| 1478 | int bx = i; |
| 1479 | int by = bx + 1; |
| 1480 | int cx = i + 2; |
| 1481 | int cy = cx + 1; |
| 1482 | int dx = i + (meshWidth + 1) * 2 + 2; |
| 1483 | int dy = dx + 1; |
| 1484 | |
| 1485 | TextureVertex::set(vertex++, vertices[ax], vertices[ay], u1, v2); |
| 1486 | TextureVertex::set(vertex++, vertices[bx], vertices[by], u1, v1); |
| 1487 | TextureVertex::set(vertex++, vertices[cx], vertices[cy], u2, v1); |
| 1488 | |
| 1489 | TextureVertex::set(vertex++, vertices[ax], vertices[ay], u1, v2); |
| 1490 | TextureVertex::set(vertex++, vertices[cx], vertices[cy], u2, v1); |
| 1491 | TextureVertex::set(vertex++, vertices[dx], vertices[dy], u2, v2); |
Romain Guy | b18d2d0 | 2011-02-10 15:52:54 -0800 | [diff] [blame] | 1492 | |
| 1493 | #if RENDER_LAYERS_AS_REGIONS |
| 1494 | if (hasActiveLayer) { |
| 1495 | // TODO: This could be optimized to avoid unnecessary ops |
| 1496 | left = fminf(left, fminf(vertices[ax], fminf(vertices[bx], vertices[cx]))); |
| 1497 | top = fminf(top, fminf(vertices[ay], fminf(vertices[by], vertices[cy]))); |
| 1498 | right = fmaxf(right, fmaxf(vertices[ax], fmaxf(vertices[bx], vertices[cx]))); |
| 1499 | bottom = fmaxf(bottom, fmaxf(vertices[ay], fmaxf(vertices[by], vertices[cy]))); |
| 1500 | } |
| 1501 | #endif |
Romain Guy | 5a7b466 | 2011-01-20 19:09:30 -0800 | [diff] [blame] | 1502 | } |
| 1503 | } |
| 1504 | |
Romain Guy | b18d2d0 | 2011-02-10 15:52:54 -0800 | [diff] [blame] | 1505 | #if RENDER_LAYERS_AS_REGIONS |
| 1506 | if (hasActiveLayer) { |
| 1507 | dirtyLayer(left, top, right, bottom, *mSnapshot->transform); |
| 1508 | } |
| 1509 | #endif |
| 1510 | |
Romain Guy | 5a7b466 | 2011-01-20 19:09:30 -0800 | [diff] [blame] | 1511 | drawTextureMesh(0.0f, 0.0f, 1.0f, 1.0f, texture->id, alpha / 255.0f, |
| 1512 | mode, texture->blend, &mesh[0].position[0], &mesh[0].texture[0], |
Romain Guy | b18d2d0 | 2011-02-10 15:52:54 -0800 | [diff] [blame] | 1513 | GL_TRIANGLES, count, false, false, 0, false, false); |
Romain Guy | 5a7b466 | 2011-01-20 19:09:30 -0800 | [diff] [blame] | 1514 | } |
| 1515 | |
Romain Guy | 8ba548f | 2010-06-30 19:21:21 -0700 | [diff] [blame] | 1516 | void OpenGLRenderer::drawBitmap(SkBitmap* bitmap, |
| 1517 | float srcLeft, float srcTop, float srcRight, float srcBottom, |
| 1518 | float dstLeft, float dstTop, float dstRight, float dstBottom, |
Chet Haase | 5c13d89 | 2010-10-08 08:37:55 -0700 | [diff] [blame] | 1519 | SkPaint* paint) { |
Romain Guy | 6926c72 | 2010-07-12 20:20:03 -0700 | [diff] [blame] | 1520 | if (quickReject(dstLeft, dstTop, dstRight, dstBottom)) { |
| 1521 | return; |
| 1522 | } |
| 1523 | |
Romain Guy | a1d3c91 | 2011-12-13 14:55:06 -0800 | [diff] [blame] | 1524 | mCaches.activeTexture(0); |
Romain Guy | 8164c2d | 2010-10-25 18:03:28 -0700 | [diff] [blame] | 1525 | Texture* texture = mCaches.textureCache.get(bitmap); |
Romain Guy | 9cccc2b | 2010-08-07 23:46:15 -0700 | [diff] [blame] | 1526 | if (!texture) return; |
Romain Guy | 22158e1 | 2010-08-06 11:18:34 -0700 | [diff] [blame] | 1527 | const AutoTexture autoCleanup(texture); |
Romain Guy | 8ba548f | 2010-06-30 19:21:21 -0700 | [diff] [blame] | 1528 | |
Romain Guy | 8ba548f | 2010-06-30 19:21:21 -0700 | [diff] [blame] | 1529 | const float width = texture->width; |
| 1530 | const float height = texture->height; |
| 1531 | |
Romain Guy | 6816972 | 2011-08-22 17:33:33 -0700 | [diff] [blame] | 1532 | const float u1 = fmax(0.0f, srcLeft / width); |
| 1533 | const float v1 = fmax(0.0f, srcTop / height); |
| 1534 | const float u2 = fmin(1.0f, srcRight / width); |
| 1535 | const float v2 = fmin(1.0f, srcBottom / height); |
Romain Guy | 8ba548f | 2010-06-30 19:21:21 -0700 | [diff] [blame] | 1536 | |
Romain Guy | 03750a0 | 2010-10-18 14:06:08 -0700 | [diff] [blame] | 1537 | mCaches.unbindMeshBuffer(); |
Romain Guy | 8ba548f | 2010-06-30 19:21:21 -0700 | [diff] [blame] | 1538 | resetDrawTextureTexCoords(u1, v1, u2, v2); |
| 1539 | |
Romain Guy | 03750a0 | 2010-10-18 14:06:08 -0700 | [diff] [blame] | 1540 | int alpha; |
| 1541 | SkXfermode::Mode mode; |
| 1542 | getAlphaAndMode(paint, &alpha, &mode); |
| 1543 | |
Romain Guy | d21b6e1 | 2011-11-30 20:21:23 -0800 | [diff] [blame] | 1544 | texture->setWrap(GL_CLAMP_TO_EDGE, true); |
| 1545 | |
Romain Guy | 211370f | 2012-02-01 16:10:55 -0800 | [diff] [blame] | 1546 | if (CC_LIKELY(mSnapshot->transform->isPureTranslate())) { |
Romain Guy | 6620c6d | 2010-12-06 18:07:02 -0800 | [diff] [blame] | 1547 | const float x = (int) floorf(dstLeft + mSnapshot->transform->getTranslateX() + 0.5f); |
| 1548 | const float y = (int) floorf(dstTop + mSnapshot->transform->getTranslateY() + 0.5f); |
| 1549 | |
Romain Guy | b501498 | 2011-07-28 15:39:12 -0700 | [diff] [blame] | 1550 | GLenum filter = GL_NEAREST; |
Romain Guy | 631582f | 2011-08-24 11:51:35 -0700 | [diff] [blame] | 1551 | // Enable linear filtering if the source rectangle is scaled |
| 1552 | if (srcRight - srcLeft != dstRight - dstLeft || srcBottom - srcTop != dstBottom - dstTop) { |
Romain Guy | d21b6e1 | 2011-11-30 20:21:23 -0800 | [diff] [blame] | 1553 | filter = FILTER(paint); |
Romain Guy | b501498 | 2011-07-28 15:39:12 -0700 | [diff] [blame] | 1554 | } |
Romain Guy | b501498 | 2011-07-28 15:39:12 -0700 | [diff] [blame] | 1555 | |
Romain Guy | d21b6e1 | 2011-11-30 20:21:23 -0800 | [diff] [blame] | 1556 | texture->setFilter(filter, true); |
Romain Guy | 6620c6d | 2010-12-06 18:07:02 -0800 | [diff] [blame] | 1557 | drawTextureMesh(x, y, x + (dstRight - dstLeft), y + (dstBottom - dstTop), |
| 1558 | texture->id, alpha / 255.0f, mode, texture->blend, |
| 1559 | &mMeshVertices[0].position[0], &mMeshVertices[0].texture[0], |
| 1560 | GL_TRIANGLE_STRIP, gMeshCount, false, true); |
| 1561 | } else { |
Romain Guy | d21b6e1 | 2011-11-30 20:21:23 -0800 | [diff] [blame] | 1562 | texture->setFilter(FILTER(paint), true); |
Romain Guy | 6620c6d | 2010-12-06 18:07:02 -0800 | [diff] [blame] | 1563 | drawTextureMesh(dstLeft, dstTop, dstRight, dstBottom, texture->id, alpha / 255.0f, |
| 1564 | mode, texture->blend, &mMeshVertices[0].position[0], &mMeshVertices[0].texture[0], |
| 1565 | GL_TRIANGLE_STRIP, gMeshCount); |
| 1566 | } |
Romain Guy | 8ba548f | 2010-06-30 19:21:21 -0700 | [diff] [blame] | 1567 | |
| 1568 | resetDrawTextureTexCoords(0.0f, 0.0f, 1.0f, 1.0f); |
| 1569 | } |
| 1570 | |
Romain Guy | 4aa9057 | 2010-09-26 18:40:37 -0700 | [diff] [blame] | 1571 | void OpenGLRenderer::drawPatch(SkBitmap* bitmap, const int32_t* xDivs, const int32_t* yDivs, |
Romain Guy | 4bb9420 | 2010-10-12 15:59:26 -0700 | [diff] [blame] | 1572 | const uint32_t* colors, uint32_t width, uint32_t height, int8_t numColors, |
Chet Haase | 5c13d89 | 2010-10-08 08:37:55 -0700 | [diff] [blame] | 1573 | float left, float top, float right, float bottom, SkPaint* paint) { |
Romain Guy | 6926c72 | 2010-07-12 20:20:03 -0700 | [diff] [blame] | 1574 | if (quickReject(left, top, right, bottom)) { |
| 1575 | return; |
| 1576 | } |
| 1577 | |
Romain Guy | a1d3c91 | 2011-12-13 14:55:06 -0800 | [diff] [blame] | 1578 | mCaches.activeTexture(0); |
Romain Guy | 8164c2d | 2010-10-25 18:03:28 -0700 | [diff] [blame] | 1579 | Texture* texture = mCaches.textureCache.get(bitmap); |
Romain Guy | 9cccc2b | 2010-08-07 23:46:15 -0700 | [diff] [blame] | 1580 | if (!texture) return; |
Romain Guy | 22158e1 | 2010-08-06 11:18:34 -0700 | [diff] [blame] | 1581 | const AutoTexture autoCleanup(texture); |
Romain Guy | d21b6e1 | 2011-11-30 20:21:23 -0800 | [diff] [blame] | 1582 | texture->setWrap(GL_CLAMP_TO_EDGE, true); |
| 1583 | texture->setFilter(GL_LINEAR, true); |
Romain Guy | f7f9355 | 2010-07-08 19:17:03 -0700 | [diff] [blame] | 1584 | |
| 1585 | int alpha; |
| 1586 | SkXfermode::Mode mode; |
| 1587 | getAlphaAndMode(paint, &alpha, &mode); |
| 1588 | |
Romain Guy | 2728f96 | 2010-10-08 18:36:15 -0700 | [diff] [blame] | 1589 | const Patch* mesh = mCaches.patchCache.get(bitmap->width(), bitmap->height(), |
Romain Guy | 4bb9420 | 2010-10-12 15:59:26 -0700 | [diff] [blame] | 1590 | right - left, bottom - top, xDivs, yDivs, colors, width, height, numColors); |
Romain Guy | f7f9355 | 2010-07-08 19:17:03 -0700 | [diff] [blame] | 1591 | |
Romain Guy | 211370f | 2012-02-01 16:10:55 -0800 | [diff] [blame] | 1592 | if (CC_LIKELY(mesh && mesh->verticesCount > 0)) { |
Romain Guy | 6620c6d | 2010-12-06 18:07:02 -0800 | [diff] [blame] | 1593 | const bool pureTranslate = mSnapshot->transform->isPureTranslate(); |
Romain Guy | a5ef39a | 2010-12-03 16:48:20 -0800 | [diff] [blame] | 1594 | #if RENDER_LAYERS_AS_REGIONS |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 1595 | // Mark the current layer dirty where we are going to draw the patch |
Romain Guy | 8168396 | 2011-01-24 20:40:18 -0800 | [diff] [blame] | 1596 | if (hasLayer() && mesh->hasEmptyQuads) { |
Romain Guy | c78b5d5 | 2011-02-04 14:00:42 -0800 | [diff] [blame] | 1597 | const float offsetX = left + mSnapshot->transform->getTranslateX(); |
| 1598 | const float offsetY = top + mSnapshot->transform->getTranslateY(); |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 1599 | const size_t count = mesh->quads.size(); |
| 1600 | for (size_t i = 0; i < count; i++) { |
Romain Guy | 8ab4079 | 2010-12-07 13:30:10 -0800 | [diff] [blame] | 1601 | const Rect& bounds = mesh->quads.itemAt(i); |
Romain Guy | 211370f | 2012-02-01 16:10:55 -0800 | [diff] [blame] | 1602 | if (CC_LIKELY(pureTranslate)) { |
Romain Guy | c78b5d5 | 2011-02-04 14:00:42 -0800 | [diff] [blame] | 1603 | const float x = (int) floorf(bounds.left + offsetX + 0.5f); |
| 1604 | const float y = (int) floorf(bounds.top + offsetY + 0.5f); |
| 1605 | dirtyLayer(x, y, x + bounds.getWidth(), y + bounds.getHeight()); |
Romain Guy | 6620c6d | 2010-12-06 18:07:02 -0800 | [diff] [blame] | 1606 | } else { |
Romain Guy | c78b5d5 | 2011-02-04 14:00:42 -0800 | [diff] [blame] | 1607 | dirtyLayer(left + bounds.left, top + bounds.top, |
| 1608 | left + bounds.right, top + bounds.bottom, *mSnapshot->transform); |
Romain Guy | 6620c6d | 2010-12-06 18:07:02 -0800 | [diff] [blame] | 1609 | } |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 1610 | } |
| 1611 | } |
Romain Guy | a5ef39a | 2010-12-03 16:48:20 -0800 | [diff] [blame] | 1612 | #endif |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 1613 | |
Romain Guy | 211370f | 2012-02-01 16:10:55 -0800 | [diff] [blame] | 1614 | if (CC_LIKELY(pureTranslate)) { |
Romain Guy | 6620c6d | 2010-12-06 18:07:02 -0800 | [diff] [blame] | 1615 | const float x = (int) floorf(left + mSnapshot->transform->getTranslateX() + 0.5f); |
| 1616 | const float y = (int) floorf(top + mSnapshot->transform->getTranslateY() + 0.5f); |
| 1617 | |
| 1618 | drawTextureMesh(x, y, x + right - left, y + bottom - top, texture->id, alpha / 255.0f, |
| 1619 | mode, texture->blend, (GLvoid*) 0, (GLvoid*) gMeshTextureOffset, |
| 1620 | GL_TRIANGLES, mesh->verticesCount, false, true, mesh->meshBuffer, |
| 1621 | true, !mesh->hasEmptyQuads); |
| 1622 | } else { |
| 1623 | drawTextureMesh(left, top, right, bottom, texture->id, alpha / 255.0f, |
| 1624 | mode, texture->blend, (GLvoid*) 0, (GLvoid*) gMeshTextureOffset, |
| 1625 | GL_TRIANGLES, mesh->verticesCount, false, false, mesh->meshBuffer, |
| 1626 | true, !mesh->hasEmptyQuads); |
| 1627 | } |
Romain Guy | 054dc18 | 2010-10-15 17:55:25 -0700 | [diff] [blame] | 1628 | } |
Romain Guy | f7f9355 | 2010-07-08 19:17:03 -0700 | [diff] [blame] | 1629 | } |
| 1630 | |
Chet Haase | 99ecdc4 | 2011-05-06 12:06:34 -0700 | [diff] [blame] | 1631 | /** |
Chet Haase | 858aa93 | 2011-05-12 09:06:00 -0700 | [diff] [blame] | 1632 | * This function uses a similar approach to that of AA lines in the drawLines() function. |
| 1633 | * We expand the rectangle by a half pixel in screen space on all sides, and use a fragment |
| 1634 | * shader to compute the translucency of the color, determined by whether a given pixel is |
| 1635 | * within that boundary region and how far into the region it is. |
| 1636 | */ |
| 1637 | void OpenGLRenderer::drawAARect(float left, float top, float right, float bottom, |
Romain Guy | 181d0a6 | 2011-06-09 18:52:38 -0700 | [diff] [blame] | 1638 | int color, SkXfermode::Mode mode) { |
Chet Haase | 858aa93 | 2011-05-12 09:06:00 -0700 | [diff] [blame] | 1639 | float inverseScaleX = 1.0f; |
| 1640 | float inverseScaleY = 1.0f; |
| 1641 | // The quad that we use needs to account for scaling. |
Romain Guy | 211370f | 2012-02-01 16:10:55 -0800 | [diff] [blame] | 1642 | if (CC_UNLIKELY(!mSnapshot->transform->isPureTranslate())) { |
Chet Haase | 858aa93 | 2011-05-12 09:06:00 -0700 | [diff] [blame] | 1643 | Matrix4 *mat = mSnapshot->transform; |
| 1644 | float m00 = mat->data[Matrix4::kScaleX]; |
| 1645 | float m01 = mat->data[Matrix4::kSkewY]; |
| 1646 | float m02 = mat->data[2]; |
| 1647 | float m10 = mat->data[Matrix4::kSkewX]; |
| 1648 | float m11 = mat->data[Matrix4::kScaleX]; |
| 1649 | float m12 = mat->data[6]; |
| 1650 | float scaleX = sqrt(m00 * m00 + m01 * m01); |
| 1651 | float scaleY = sqrt(m10 * m10 + m11 * m11); |
| 1652 | inverseScaleX = (scaleX != 0) ? (inverseScaleX / scaleX) : 0; |
| 1653 | inverseScaleY = (scaleY != 0) ? (inverseScaleY / scaleY) : 0; |
| 1654 | } |
| 1655 | |
| 1656 | setupDraw(); |
Romain Guy | 15bc643 | 2011-12-13 13:11:32 -0800 | [diff] [blame] | 1657 | setupDrawNoTexture(); |
Chet Haase | 858aa93 | 2011-05-12 09:06:00 -0700 | [diff] [blame] | 1658 | setupDrawAALine(); |
| 1659 | setupDrawColor(color); |
| 1660 | setupDrawColorFilter(); |
| 1661 | setupDrawShader(); |
| 1662 | setupDrawBlending(true, mode); |
| 1663 | setupDrawProgram(); |
| 1664 | setupDrawModelViewIdentity(true); |
| 1665 | setupDrawColorUniforms(); |
| 1666 | setupDrawColorFilterUniforms(); |
| 1667 | setupDrawShaderIdentityUniforms(); |
| 1668 | |
| 1669 | AAVertex rects[4]; |
| 1670 | AAVertex* aaVertices = &rects[0]; |
| 1671 | void* widthCoords = ((GLbyte*) aaVertices) + gVertexAAWidthOffset; |
| 1672 | void* lengthCoords = ((GLbyte*) aaVertices) + gVertexAALengthOffset; |
| 1673 | |
| 1674 | float boundarySizeX = .5 * inverseScaleX; |
| 1675 | float boundarySizeY = .5 * inverseScaleY; |
| 1676 | |
| 1677 | // Adjust the rect by the AA boundary padding |
| 1678 | left -= boundarySizeX; |
| 1679 | right += boundarySizeX; |
| 1680 | top -= boundarySizeY; |
| 1681 | bottom += boundarySizeY; |
| 1682 | |
| 1683 | float width = right - left; |
| 1684 | float height = bottom - top; |
| 1685 | |
| 1686 | float boundaryWidthProportion = (width != 0) ? (2 * boundarySizeX) / width : 0; |
| 1687 | float boundaryHeightProportion = (height != 0) ? (2 * boundarySizeY) / height : 0; |
| 1688 | setupDrawAALine((void*) aaVertices, widthCoords, lengthCoords, boundaryWidthProportion); |
| 1689 | int boundaryLengthSlot = mCaches.currentProgram->getUniform("boundaryLength"); |
| 1690 | int inverseBoundaryLengthSlot = mCaches.currentProgram->getUniform("inverseBoundaryLength"); |
| 1691 | glUniform1f(boundaryLengthSlot, boundaryHeightProportion); |
| 1692 | glUniform1f(inverseBoundaryLengthSlot, (1 / boundaryHeightProportion)); |
| 1693 | |
| 1694 | if (!quickReject(left, top, right, bottom)) { |
| 1695 | AAVertex::set(aaVertices++, left, bottom, 1, 1); |
| 1696 | AAVertex::set(aaVertices++, left, top, 1, 0); |
| 1697 | AAVertex::set(aaVertices++, right, bottom, 0, 1); |
| 1698 | AAVertex::set(aaVertices++, right, top, 0, 0); |
| 1699 | dirtyLayer(left, top, right, bottom, *mSnapshot->transform); |
| 1700 | glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); |
| 1701 | } |
| 1702 | } |
| 1703 | |
| 1704 | /** |
Chet Haase | 99ecdc4 | 2011-05-06 12:06:34 -0700 | [diff] [blame] | 1705 | * We draw lines as quads (tristrips). Using GL_LINES can be difficult because the rasterization |
| 1706 | * rules for those lines produces some unexpected results, and may vary between hardware devices. |
| 1707 | * The basics of lines-as-quads is easy; we simply find the normal to the line and position the |
| 1708 | * corners of the quads on either side of each line endpoint, separated by the strokeWidth |
| 1709 | * of the line. Hairlines are more involved because we need to account for transform scaling |
| 1710 | * to end up with a one-pixel-wide line in screen space.. |
| 1711 | * Anti-aliased lines add another factor to the approach. We use a specialized fragment shader |
| 1712 | * in combination with values that we calculate and pass down in this method. The basic approach |
| 1713 | * is that the quad we create contains both the core line area plus a bounding area in which |
| 1714 | * the translucent/AA pixels are drawn. The values we calculate tell the shader what |
| 1715 | * proportion of the width and the length of a given segment is represented by the boundary |
| 1716 | * region. The quad ends up being exactly .5 pixel larger in all directions than the non-AA quad. |
| 1717 | * The bounding region is actually 1 pixel wide on all sides (half pixel on the outside, half pixel |
| 1718 | * on the inside). This ends up giving the result we want, with pixels that are completely |
| 1719 | * 'inside' the line area being filled opaquely and the other pixels being filled according to |
| 1720 | * how far into the boundary region they are, which is determined by shader interpolation. |
| 1721 | */ |
Chet Haase | 8a5cc92 | 2011-04-26 07:28:09 -0700 | [diff] [blame] | 1722 | void OpenGLRenderer::drawLines(float* points, int count, SkPaint* paint) { |
| 1723 | if (mSnapshot->isIgnored()) return; |
| 1724 | |
| 1725 | const bool isAA = paint->isAntiAlias(); |
Chet Haase | 99ecdc4 | 2011-05-06 12:06:34 -0700 | [diff] [blame] | 1726 | // We use half the stroke width here because we're going to position the quad |
| 1727 | // corner vertices half of the width away from the line endpoints |
| 1728 | float halfStrokeWidth = paint->getStrokeWidth() * 0.5f; |
Chet Haase | 8a5cc92 | 2011-04-26 07:28:09 -0700 | [diff] [blame] | 1729 | // A stroke width of 0 has a special meaning in Skia: |
| 1730 | // it draws a line 1 px wide regardless of current transform |
| 1731 | bool isHairLine = paint->getStrokeWidth() == 0.0f; |
Chet Haase | 99ecdc4 | 2011-05-06 12:06:34 -0700 | [diff] [blame] | 1732 | float inverseScaleX = 1.0f; |
| 1733 | float inverseScaleY = 1.0f; |
| 1734 | bool scaled = false; |
Chet Haase | 8a5cc92 | 2011-04-26 07:28:09 -0700 | [diff] [blame] | 1735 | int alpha; |
| 1736 | SkXfermode::Mode mode; |
| 1737 | int generatedVerticesCount = 0; |
Chet Haase | 5b0200b | 2011-04-13 17:58:08 -0700 | [diff] [blame] | 1738 | int verticesCount = count; |
| 1739 | if (count > 4) { |
Chet Haase | c54ed96 | 2011-05-06 14:13:05 -0700 | [diff] [blame] | 1740 | // Polyline: account for extra vertices needed for continuous tri-strip |
Chet Haase | 99ecdc4 | 2011-05-06 12:06:34 -0700 | [diff] [blame] | 1741 | verticesCount += (count - 4); |
| 1742 | } |
| 1743 | |
| 1744 | if (isHairLine || isAA) { |
| 1745 | // The quad that we use for AA and hairlines needs to account for scaling. For hairlines |
| 1746 | // the line on the screen should always be one pixel wide regardless of scale. For |
| 1747 | // AA lines, we only want one pixel of translucent boundary around the quad. |
Romain Guy | 211370f | 2012-02-01 16:10:55 -0800 | [diff] [blame] | 1748 | if (CC_UNLIKELY(!mSnapshot->transform->isPureTranslate())) { |
Chet Haase | 99ecdc4 | 2011-05-06 12:06:34 -0700 | [diff] [blame] | 1749 | Matrix4 *mat = mSnapshot->transform; |
| 1750 | float m00 = mat->data[Matrix4::kScaleX]; |
| 1751 | float m01 = mat->data[Matrix4::kSkewY]; |
| 1752 | float m02 = mat->data[2]; |
| 1753 | float m10 = mat->data[Matrix4::kSkewX]; |
| 1754 | float m11 = mat->data[Matrix4::kScaleX]; |
| 1755 | float m12 = mat->data[6]; |
Romain Guy | 211370f | 2012-02-01 16:10:55 -0800 | [diff] [blame] | 1756 | float scaleX = sqrtf(m00 * m00 + m01 * m01); |
| 1757 | float scaleY = sqrtf(m10 * m10 + m11 * m11); |
Chet Haase | 99ecdc4 | 2011-05-06 12:06:34 -0700 | [diff] [blame] | 1758 | inverseScaleX = (scaleX != 0) ? (inverseScaleX / scaleX) : 0; |
| 1759 | inverseScaleY = (scaleY != 0) ? (inverseScaleY / scaleY) : 0; |
| 1760 | if (inverseScaleX != 1.0f || inverseScaleY != 1.0f) { |
| 1761 | scaled = true; |
| 1762 | } |
| 1763 | } |
Chet Haase | 5b0200b | 2011-04-13 17:58:08 -0700 | [diff] [blame] | 1764 | } |
Chet Haase | 8a5cc92 | 2011-04-26 07:28:09 -0700 | [diff] [blame] | 1765 | |
| 1766 | getAlphaAndMode(paint, &alpha, &mode); |
| 1767 | setupDraw(); |
Romain Guy | 15bc643 | 2011-12-13 13:11:32 -0800 | [diff] [blame] | 1768 | setupDrawNoTexture(); |
Chet Haase | 8a5cc92 | 2011-04-26 07:28:09 -0700 | [diff] [blame] | 1769 | if (isAA) { |
| 1770 | setupDrawAALine(); |
| 1771 | } |
| 1772 | setupDrawColor(paint->getColor(), alpha); |
| 1773 | setupDrawColorFilter(); |
| 1774 | setupDrawShader(); |
Romain Guy | 211370f | 2012-02-01 16:10:55 -0800 | [diff] [blame] | 1775 | setupDrawBlending(isAA, mode); |
Chet Haase | 8a5cc92 | 2011-04-26 07:28:09 -0700 | [diff] [blame] | 1776 | setupDrawProgram(); |
| 1777 | setupDrawModelViewIdentity(true); |
| 1778 | setupDrawColorUniforms(); |
| 1779 | setupDrawColorFilterUniforms(); |
| 1780 | setupDrawShaderIdentityUniforms(); |
| 1781 | |
| 1782 | if (isHairLine) { |
| 1783 | // Set a real stroke width to be used in quad construction |
Chet Haase | 99ecdc4 | 2011-05-06 12:06:34 -0700 | [diff] [blame] | 1784 | halfStrokeWidth = isAA? 1 : .5; |
| 1785 | } else if (isAA && !scaled) { |
Chet Haase | 5b0200b | 2011-04-13 17:58:08 -0700 | [diff] [blame] | 1786 | // Expand boundary to enable AA calculations on the quad border |
Chet Haase | 99ecdc4 | 2011-05-06 12:06:34 -0700 | [diff] [blame] | 1787 | halfStrokeWidth += .5f; |
Chet Haase | 5b0200b | 2011-04-13 17:58:08 -0700 | [diff] [blame] | 1788 | } |
| 1789 | Vertex lines[verticesCount]; |
| 1790 | Vertex* vertices = &lines[0]; |
Chet Haase | 99585ad | 2011-05-02 15:00:16 -0700 | [diff] [blame] | 1791 | AAVertex wLines[verticesCount]; |
| 1792 | AAVertex* aaVertices = &wLines[0]; |
Romain Guy | 211370f | 2012-02-01 16:10:55 -0800 | [diff] [blame] | 1793 | if (CC_UNLIKELY(!isAA)) { |
Chet Haase | 5b0200b | 2011-04-13 17:58:08 -0700 | [diff] [blame] | 1794 | setupDrawVertices(vertices); |
| 1795 | } else { |
Chet Haase | 99585ad | 2011-05-02 15:00:16 -0700 | [diff] [blame] | 1796 | void* widthCoords = ((GLbyte*) aaVertices) + gVertexAAWidthOffset; |
| 1797 | void* lengthCoords = ((GLbyte*) aaVertices) + gVertexAALengthOffset; |
Chet Haase | 99ecdc4 | 2011-05-06 12:06:34 -0700 | [diff] [blame] | 1798 | // innerProportion is the ratio of the inner (non-AA) part of the line to the total |
Chet Haase | 5b0200b | 2011-04-13 17:58:08 -0700 | [diff] [blame] | 1799 | // AA stroke width (the base stroke width expanded by a half pixel on either side). |
| 1800 | // This value is used in the fragment shader to determine how to fill fragments. |
Chet Haase | 99ecdc4 | 2011-05-06 12:06:34 -0700 | [diff] [blame] | 1801 | // We will need to calculate the actual width proportion on each segment for |
| 1802 | // scaled non-hairlines, since the boundary proportion may differ per-axis when scaled. |
| 1803 | float boundaryWidthProportion = 1 / (2 * halfStrokeWidth); |
| 1804 | setupDrawAALine((void*) aaVertices, widthCoords, lengthCoords, boundaryWidthProportion); |
Chet Haase | 5b0200b | 2011-04-13 17:58:08 -0700 | [diff] [blame] | 1805 | } |
| 1806 | |
Chet Haase | 99ecdc4 | 2011-05-06 12:06:34 -0700 | [diff] [blame] | 1807 | AAVertex* prevAAVertex = NULL; |
| 1808 | Vertex* prevVertex = NULL; |
Romain Guy | 740bf2b | 2011-04-26 15:33:10 -0700 | [diff] [blame] | 1809 | |
Chet Haase | 99585ad | 2011-05-02 15:00:16 -0700 | [diff] [blame] | 1810 | int boundaryLengthSlot = -1; |
| 1811 | int inverseBoundaryLengthSlot = -1; |
Chet Haase | 99ecdc4 | 2011-05-06 12:06:34 -0700 | [diff] [blame] | 1812 | int boundaryWidthSlot = -1; |
| 1813 | int inverseBoundaryWidthSlot = -1; |
Chet Haase | 5b0200b | 2011-04-13 17:58:08 -0700 | [diff] [blame] | 1814 | for (int i = 0; i < count; i += 4) { |
| 1815 | // a = start point, b = end point |
| 1816 | vec2 a(points[i], points[i + 1]); |
| 1817 | vec2 b(points[i + 2], points[i + 3]); |
Chet Haase | 99585ad | 2011-05-02 15:00:16 -0700 | [diff] [blame] | 1818 | float length = 0; |
Chet Haase | 99ecdc4 | 2011-05-06 12:06:34 -0700 | [diff] [blame] | 1819 | float boundaryLengthProportion = 0; |
| 1820 | float boundaryWidthProportion = 0; |
Chet Haase | 5b0200b | 2011-04-13 17:58:08 -0700 | [diff] [blame] | 1821 | |
Chet Haase | 5b0200b | 2011-04-13 17:58:08 -0700 | [diff] [blame] | 1822 | // Find the normal to the line |
Chet Haase | 99ecdc4 | 2011-05-06 12:06:34 -0700 | [diff] [blame] | 1823 | vec2 n = (b - a).copyNormalized() * halfStrokeWidth; |
Chet Haase | 8a5cc92 | 2011-04-26 07:28:09 -0700 | [diff] [blame] | 1824 | if (isHairLine) { |
Chet Haase | 8a5cc92 | 2011-04-26 07:28:09 -0700 | [diff] [blame] | 1825 | if (isAA) { |
| 1826 | float wideningFactor; |
| 1827 | if (fabs(n.x) >= fabs(n.y)) { |
| 1828 | wideningFactor = fabs(1.0f / n.x); |
| 1829 | } else { |
| 1830 | wideningFactor = fabs(1.0f / n.y); |
| 1831 | } |
| 1832 | n *= wideningFactor; |
Chet Haase | 5b0200b | 2011-04-13 17:58:08 -0700 | [diff] [blame] | 1833 | } |
Chet Haase | 99ecdc4 | 2011-05-06 12:06:34 -0700 | [diff] [blame] | 1834 | if (scaled) { |
| 1835 | n.x *= inverseScaleX; |
| 1836 | n.y *= inverseScaleY; |
| 1837 | } |
| 1838 | } else if (scaled) { |
| 1839 | // Extend n by .5 pixel on each side, post-transform |
| 1840 | vec2 extendedN = n.copyNormalized(); |
| 1841 | extendedN /= 2; |
| 1842 | extendedN.x *= inverseScaleX; |
| 1843 | extendedN.y *= inverseScaleY; |
| 1844 | float extendedNLength = extendedN.length(); |
| 1845 | // We need to set this value on the shader prior to drawing |
| 1846 | boundaryWidthProportion = extendedNLength / (halfStrokeWidth + extendedNLength); |
| 1847 | n += extendedN; |
Chet Haase | 5b0200b | 2011-04-13 17:58:08 -0700 | [diff] [blame] | 1848 | } |
| 1849 | float x = n.x; |
| 1850 | n.x = -n.y; |
| 1851 | n.y = x; |
| 1852 | |
Chet Haase | 99585ad | 2011-05-02 15:00:16 -0700 | [diff] [blame] | 1853 | // aa lines expand the endpoint vertices to encompass the AA boundary |
| 1854 | if (isAA) { |
| 1855 | vec2 abVector = (b - a); |
| 1856 | length = abVector.length(); |
| 1857 | abVector.normalize(); |
Chet Haase | 99ecdc4 | 2011-05-06 12:06:34 -0700 | [diff] [blame] | 1858 | if (scaled) { |
| 1859 | abVector.x *= inverseScaleX; |
| 1860 | abVector.y *= inverseScaleY; |
| 1861 | float abLength = abVector.length(); |
| 1862 | boundaryLengthProportion = abLength / (length + abLength); |
| 1863 | } else { |
| 1864 | boundaryLengthProportion = .5 / (length + 1); |
| 1865 | } |
| 1866 | abVector /= 2; |
Chet Haase | 99585ad | 2011-05-02 15:00:16 -0700 | [diff] [blame] | 1867 | a -= abVector; |
| 1868 | b += abVector; |
| 1869 | } |
| 1870 | |
Chet Haase | 5b0200b | 2011-04-13 17:58:08 -0700 | [diff] [blame] | 1871 | // Four corners of the rectangle defining a thick line |
| 1872 | vec2 p1 = a - n; |
| 1873 | vec2 p2 = a + n; |
| 1874 | vec2 p3 = b + n; |
| 1875 | vec2 p4 = b - n; |
| 1876 | |
Chet Haase | 99585ad | 2011-05-02 15:00:16 -0700 | [diff] [blame] | 1877 | |
Chet Haase | 5b0200b | 2011-04-13 17:58:08 -0700 | [diff] [blame] | 1878 | const float left = fmin(p1.x, fmin(p2.x, fmin(p3.x, p4.x))); |
| 1879 | const float right = fmax(p1.x, fmax(p2.x, fmax(p3.x, p4.x))); |
| 1880 | const float top = fmin(p1.y, fmin(p2.y, fmin(p3.y, p4.y))); |
| 1881 | const float bottom = fmax(p1.y, fmax(p2.y, fmax(p3.y, p4.y))); |
| 1882 | |
| 1883 | if (!quickReject(left, top, right, bottom)) { |
Chet Haase | 5b0200b | 2011-04-13 17:58:08 -0700 | [diff] [blame] | 1884 | if (!isAA) { |
| 1885 | if (prevVertex != NULL) { |
| 1886 | // Issue two repeat vertices to create degenerate triangles to bridge |
| 1887 | // between the previous line and the new one. This is necessary because |
| 1888 | // we are creating a single triangle_strip which will contain |
| 1889 | // potentially discontinuous line segments. |
| 1890 | Vertex::set(vertices++, prevVertex->position[0], prevVertex->position[1]); |
| 1891 | Vertex::set(vertices++, p1.x, p1.y); |
| 1892 | generatedVerticesCount += 2; |
| 1893 | } |
| 1894 | Vertex::set(vertices++, p1.x, p1.y); |
| 1895 | Vertex::set(vertices++, p2.x, p2.y); |
| 1896 | Vertex::set(vertices++, p4.x, p4.y); |
| 1897 | Vertex::set(vertices++, p3.x, p3.y); |
| 1898 | prevVertex = vertices - 1; |
| 1899 | generatedVerticesCount += 4; |
| 1900 | } else { |
Chet Haase | 99ecdc4 | 2011-05-06 12:06:34 -0700 | [diff] [blame] | 1901 | if (!isHairLine && scaled) { |
| 1902 | // Must set width proportions per-segment for scaled non-hairlines to use the |
| 1903 | // correct AA boundary dimensions |
| 1904 | if (boundaryWidthSlot < 0) { |
| 1905 | boundaryWidthSlot = |
| 1906 | mCaches.currentProgram->getUniform("boundaryWidth"); |
| 1907 | inverseBoundaryWidthSlot = |
| 1908 | mCaches.currentProgram->getUniform("inverseBoundaryWidth"); |
| 1909 | } |
| 1910 | glUniform1f(boundaryWidthSlot, boundaryWidthProportion); |
| 1911 | glUniform1f(inverseBoundaryWidthSlot, (1 / boundaryWidthProportion)); |
| 1912 | } |
Chet Haase | 99585ad | 2011-05-02 15:00:16 -0700 | [diff] [blame] | 1913 | if (boundaryLengthSlot < 0) { |
| 1914 | boundaryLengthSlot = mCaches.currentProgram->getUniform("boundaryLength"); |
| 1915 | inverseBoundaryLengthSlot = |
| 1916 | mCaches.currentProgram->getUniform("inverseBoundaryLength"); |
| 1917 | } |
Chet Haase | 99ecdc4 | 2011-05-06 12:06:34 -0700 | [diff] [blame] | 1918 | glUniform1f(boundaryLengthSlot, boundaryLengthProportion); |
| 1919 | glUniform1f(inverseBoundaryLengthSlot, (1 / boundaryLengthProportion)); |
Chet Haase | 99585ad | 2011-05-02 15:00:16 -0700 | [diff] [blame] | 1920 | |
Chet Haase | 5b0200b | 2011-04-13 17:58:08 -0700 | [diff] [blame] | 1921 | if (prevAAVertex != NULL) { |
| 1922 | // Issue two repeat vertices to create degenerate triangles to bridge |
| 1923 | // between the previous line and the new one. This is necessary because |
| 1924 | // we are creating a single triangle_strip which will contain |
| 1925 | // potentially discontinuous line segments. |
Chet Haase | 99585ad | 2011-05-02 15:00:16 -0700 | [diff] [blame] | 1926 | AAVertex::set(aaVertices++,prevAAVertex->position[0], |
| 1927 | prevAAVertex->position[1], prevAAVertex->width, prevAAVertex->length); |
| 1928 | AAVertex::set(aaVertices++, p4.x, p4.y, 1, 1); |
Chet Haase | 5b0200b | 2011-04-13 17:58:08 -0700 | [diff] [blame] | 1929 | generatedVerticesCount += 2; |
| 1930 | } |
Chet Haase | 99585ad | 2011-05-02 15:00:16 -0700 | [diff] [blame] | 1931 | AAVertex::set(aaVertices++, p4.x, p4.y, 1, 1); |
| 1932 | AAVertex::set(aaVertices++, p1.x, p1.y, 1, 0); |
| 1933 | AAVertex::set(aaVertices++, p3.x, p3.y, 0, 1); |
| 1934 | AAVertex::set(aaVertices++, p2.x, p2.y, 0, 0); |
Chet Haase | 5b0200b | 2011-04-13 17:58:08 -0700 | [diff] [blame] | 1935 | prevAAVertex = aaVertices - 1; |
| 1936 | generatedVerticesCount += 4; |
| 1937 | } |
Chet Haase | 99585ad | 2011-05-02 15:00:16 -0700 | [diff] [blame] | 1938 | dirtyLayer(a.x == b.x ? left - 1 : left, a.y == b.y ? top - 1 : top, |
| 1939 | a.x == b.x ? right: right, a.y == b.y ? bottom: bottom, |
| 1940 | *mSnapshot->transform); |
Chet Haase | 5b0200b | 2011-04-13 17:58:08 -0700 | [diff] [blame] | 1941 | } |
| 1942 | } |
| 1943 | if (generatedVerticesCount > 0) { |
| 1944 | glDrawArrays(GL_TRIANGLE_STRIP, 0, generatedVerticesCount); |
| 1945 | } |
| 1946 | } |
| 1947 | |
Romain Guy | ed6fcb0 | 2011-03-21 13:11:28 -0700 | [diff] [blame] | 1948 | void OpenGLRenderer::drawPoints(float* points, int count, SkPaint* paint) { |
| 1949 | if (mSnapshot->isIgnored()) return; |
| 1950 | |
| 1951 | // TODO: The paint's cap style defines whether the points are square or circular |
| 1952 | // TODO: Handle AA for round points |
| 1953 | |
Chet Haase | 5b0200b | 2011-04-13 17:58:08 -0700 | [diff] [blame] | 1954 | // A stroke width of 0 has a special meaning in Skia: |
Romain Guy | ed6fcb0 | 2011-03-21 13:11:28 -0700 | [diff] [blame] | 1955 | // it draws an unscaled 1px point |
Chet Haase | 8a5cc92 | 2011-04-26 07:28:09 -0700 | [diff] [blame] | 1956 | float strokeWidth = paint->getStrokeWidth(); |
Romain Guy | ed6fcb0 | 2011-03-21 13:11:28 -0700 | [diff] [blame] | 1957 | const bool isHairLine = paint->getStrokeWidth() == 0.0f; |
Chet Haase | 8a5cc92 | 2011-04-26 07:28:09 -0700 | [diff] [blame] | 1958 | if (isHairLine) { |
| 1959 | // Now that we know it's hairline, we can set the effective width, to be used later |
| 1960 | strokeWidth = 1.0f; |
| 1961 | } |
| 1962 | const float halfWidth = strokeWidth / 2; |
Romain Guy | ed6fcb0 | 2011-03-21 13:11:28 -0700 | [diff] [blame] | 1963 | int alpha; |
| 1964 | SkXfermode::Mode mode; |
| 1965 | getAlphaAndMode(paint, &alpha, &mode); |
| 1966 | |
| 1967 | int verticesCount = count >> 1; |
| 1968 | int generatedVerticesCount = 0; |
| 1969 | |
| 1970 | TextureVertex pointsData[verticesCount]; |
| 1971 | TextureVertex* vertex = &pointsData[0]; |
| 1972 | |
| 1973 | setupDraw(); |
Romain Guy | 15bc643 | 2011-12-13 13:11:32 -0800 | [diff] [blame] | 1974 | setupDrawNoTexture(); |
Chet Haase | 8a5cc92 | 2011-04-26 07:28:09 -0700 | [diff] [blame] | 1975 | setupDrawPoint(strokeWidth); |
Romain Guy | ed6fcb0 | 2011-03-21 13:11:28 -0700 | [diff] [blame] | 1976 | setupDrawColor(paint->getColor(), alpha); |
| 1977 | setupDrawColorFilter(); |
| 1978 | setupDrawShader(); |
| 1979 | setupDrawBlending(mode); |
| 1980 | setupDrawProgram(); |
Chet Haase | 8a5cc92 | 2011-04-26 07:28:09 -0700 | [diff] [blame] | 1981 | setupDrawModelViewIdentity(true); |
Romain Guy | ed6fcb0 | 2011-03-21 13:11:28 -0700 | [diff] [blame] | 1982 | setupDrawColorUniforms(); |
| 1983 | setupDrawColorFilterUniforms(); |
| 1984 | setupDrawPointUniforms(); |
| 1985 | setupDrawShaderIdentityUniforms(); |
| 1986 | setupDrawMesh(vertex); |
| 1987 | |
| 1988 | for (int i = 0; i < count; i += 2) { |
| 1989 | TextureVertex::set(vertex++, points[i], points[i + 1], 0.0f, 0.0f); |
| 1990 | generatedVerticesCount++; |
Chet Haase | 8a5cc92 | 2011-04-26 07:28:09 -0700 | [diff] [blame] | 1991 | float left = points[i] - halfWidth; |
| 1992 | float right = points[i] + halfWidth; |
| 1993 | float top = points[i + 1] - halfWidth; |
| 1994 | float bottom = points [i + 1] + halfWidth; |
| 1995 | dirtyLayer(left, top, right, bottom, *mSnapshot->transform); |
Romain Guy | ed6fcb0 | 2011-03-21 13:11:28 -0700 | [diff] [blame] | 1996 | } |
| 1997 | |
| 1998 | glDrawArrays(GL_POINTS, 0, generatedVerticesCount); |
| 1999 | } |
| 2000 | |
Romain Guy | 85bf02f | 2010-06-22 13:11:24 -0700 | [diff] [blame] | 2001 | void OpenGLRenderer::drawColor(int color, SkXfermode::Mode mode) { |
Romain Guy | e45362c | 2010-11-03 19:58:32 -0700 | [diff] [blame] | 2002 | // No need to check against the clip, we fill the clip region |
Romain Guy | af636eb | 2010-12-09 17:47:21 -0800 | [diff] [blame] | 2003 | if (mSnapshot->isIgnored()) return; |
Romain Guy | e45362c | 2010-11-03 19:58:32 -0700 | [diff] [blame] | 2004 | |
Romain Guy | ae88e5e | 2010-10-22 17:49:18 -0700 | [diff] [blame] | 2005 | Rect& clip(*mSnapshot->clipRect); |
| 2006 | clip.snapToPixelBoundaries(); |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 2007 | |
Romain Guy | 3d58c03 | 2010-07-14 16:34:53 -0700 | [diff] [blame] | 2008 | drawColorRect(clip.left, clip.top, clip.right, clip.bottom, color, mode, true); |
Romain Guy | c7d5349 | 2010-06-25 13:41:57 -0700 | [diff] [blame] | 2009 | } |
Romain Guy | 9d5316e | 2010-06-24 19:30:36 -0700 | [diff] [blame] | 2010 | |
Romain Guy | c1cd9ba3 | 2011-01-23 14:18:41 -0800 | [diff] [blame] | 2011 | void OpenGLRenderer::drawShape(float left, float top, const PathTexture* texture, SkPaint* paint) { |
Romain Guy | 01d58e4 | 2011-01-19 21:54:02 -0800 | [diff] [blame] | 2012 | if (!texture) return; |
| 2013 | const AutoTexture autoCleanup(texture); |
| 2014 | |
| 2015 | const float x = left + texture->left - texture->offset; |
| 2016 | const float y = top + texture->top - texture->offset; |
| 2017 | |
| 2018 | drawPathTexture(texture, x, y, paint); |
| 2019 | } |
| 2020 | |
Romain Guy | c1cd9ba3 | 2011-01-23 14:18:41 -0800 | [diff] [blame] | 2021 | void OpenGLRenderer::drawRoundRect(float left, float top, float right, float bottom, |
| 2022 | float rx, float ry, SkPaint* paint) { |
| 2023 | if (mSnapshot->isIgnored()) return; |
| 2024 | |
Romain Guy | a1d3c91 | 2011-12-13 14:55:06 -0800 | [diff] [blame] | 2025 | mCaches.activeTexture(0); |
Romain Guy | c1cd9ba3 | 2011-01-23 14:18:41 -0800 | [diff] [blame] | 2026 | const PathTexture* texture = mCaches.roundRectShapeCache.getRoundRect( |
| 2027 | right - left, bottom - top, rx, ry, paint); |
| 2028 | drawShape(left, top, texture, paint); |
| 2029 | } |
| 2030 | |
Romain Guy | 01d58e4 | 2011-01-19 21:54:02 -0800 | [diff] [blame] | 2031 | void OpenGLRenderer::drawCircle(float x, float y, float radius, SkPaint* paint) { |
| 2032 | if (mSnapshot->isIgnored()) return; |
| 2033 | |
Romain Guy | a1d3c91 | 2011-12-13 14:55:06 -0800 | [diff] [blame] | 2034 | mCaches.activeTexture(0); |
Romain Guy | 01d58e4 | 2011-01-19 21:54:02 -0800 | [diff] [blame] | 2035 | const PathTexture* texture = mCaches.circleShapeCache.getCircle(radius, paint); |
Romain Guy | c1cd9ba3 | 2011-01-23 14:18:41 -0800 | [diff] [blame] | 2036 | drawShape(x - radius, y - radius, texture, paint); |
| 2037 | } |
Romain Guy | 01d58e4 | 2011-01-19 21:54:02 -0800 | [diff] [blame] | 2038 | |
Romain Guy | c1cd9ba3 | 2011-01-23 14:18:41 -0800 | [diff] [blame] | 2039 | void OpenGLRenderer::drawOval(float left, float top, float right, float bottom, SkPaint* paint) { |
| 2040 | if (mSnapshot->isIgnored()) return; |
Romain Guy | 01d58e4 | 2011-01-19 21:54:02 -0800 | [diff] [blame] | 2041 | |
Romain Guy | a1d3c91 | 2011-12-13 14:55:06 -0800 | [diff] [blame] | 2042 | mCaches.activeTexture(0); |
Romain Guy | c1cd9ba3 | 2011-01-23 14:18:41 -0800 | [diff] [blame] | 2043 | const PathTexture* texture = mCaches.ovalShapeCache.getOval(right - left, bottom - top, paint); |
| 2044 | drawShape(left, top, texture, paint); |
| 2045 | } |
| 2046 | |
Romain Guy | 8b2f526 | 2011-01-23 16:15:02 -0800 | [diff] [blame] | 2047 | void OpenGLRenderer::drawArc(float left, float top, float right, float bottom, |
| 2048 | float startAngle, float sweepAngle, bool useCenter, SkPaint* paint) { |
| 2049 | if (mSnapshot->isIgnored()) return; |
| 2050 | |
| 2051 | if (fabs(sweepAngle) >= 360.0f) { |
| 2052 | drawOval(left, top, right, bottom, paint); |
| 2053 | return; |
| 2054 | } |
| 2055 | |
Romain Guy | a1d3c91 | 2011-12-13 14:55:06 -0800 | [diff] [blame] | 2056 | mCaches.activeTexture(0); |
Romain Guy | 8b2f526 | 2011-01-23 16:15:02 -0800 | [diff] [blame] | 2057 | const PathTexture* texture = mCaches.arcShapeCache.getArc(right - left, bottom - top, |
| 2058 | startAngle, sweepAngle, useCenter, paint); |
| 2059 | drawShape(left, top, texture, paint); |
| 2060 | } |
| 2061 | |
Romain Guy | c1cd9ba3 | 2011-01-23 14:18:41 -0800 | [diff] [blame] | 2062 | void OpenGLRenderer::drawRectAsShape(float left, float top, float right, float bottom, |
| 2063 | SkPaint* paint) { |
| 2064 | if (mSnapshot->isIgnored()) return; |
| 2065 | |
Romain Guy | a1d3c91 | 2011-12-13 14:55:06 -0800 | [diff] [blame] | 2066 | mCaches.activeTexture(0); |
Romain Guy | c1cd9ba3 | 2011-01-23 14:18:41 -0800 | [diff] [blame] | 2067 | const PathTexture* texture = mCaches.rectShapeCache.getRect(right - left, bottom - top, paint); |
| 2068 | drawShape(left, top, texture, paint); |
Romain Guy | 01d58e4 | 2011-01-19 21:54:02 -0800 | [diff] [blame] | 2069 | } |
| 2070 | |
Chet Haase | 5c13d89 | 2010-10-08 08:37:55 -0700 | [diff] [blame] | 2071 | void OpenGLRenderer::drawRect(float left, float top, float right, float bottom, SkPaint* p) { |
Romain Guy | c1cd9ba3 | 2011-01-23 14:18:41 -0800 | [diff] [blame] | 2072 | if (p->getStyle() != SkPaint::kFill_Style) { |
| 2073 | drawRectAsShape(left, top, right, bottom, p); |
| 2074 | return; |
| 2075 | } |
| 2076 | |
Romain Guy | 6926c72 | 2010-07-12 20:20:03 -0700 | [diff] [blame] | 2077 | if (quickReject(left, top, right, bottom)) { |
| 2078 | return; |
| 2079 | } |
| 2080 | |
Romain Guy | 026c5e16 | 2010-06-28 17:12:22 -0700 | [diff] [blame] | 2081 | SkXfermode::Mode mode; |
Romain Guy | 746b740 | 2010-10-26 16:27:31 -0700 | [diff] [blame] | 2082 | if (!mCaches.extensions.hasFramebufferFetch()) { |
Romain Guy | a5aed0d | 2010-09-09 14:42:43 -0700 | [diff] [blame] | 2083 | const bool isMode = SkXfermode::IsMode(p->getXfermode(), &mode); |
| 2084 | if (!isMode) { |
| 2085 | // Assume SRC_OVER |
| 2086 | mode = SkXfermode::kSrcOver_Mode; |
| 2087 | } |
| 2088 | } else { |
| 2089 | mode = getXfermode(p->getXfermode()); |
Romain Guy | 026c5e16 | 2010-06-28 17:12:22 -0700 | [diff] [blame] | 2090 | } |
| 2091 | |
Romain Guy | 026c5e16 | 2010-06-28 17:12:22 -0700 | [diff] [blame] | 2092 | int color = p->getColor(); |
Romain Guy | 181d0a6 | 2011-06-09 18:52:38 -0700 | [diff] [blame] | 2093 | if (p->isAntiAlias() && !mSnapshot->transform->isSimple()) { |
Chet Haase | 858aa93 | 2011-05-12 09:06:00 -0700 | [diff] [blame] | 2094 | drawAARect(left, top, right, bottom, color, mode); |
| 2095 | } else { |
| 2096 | drawColorRect(left, top, right, bottom, color, mode); |
| 2097 | } |
Romain Guy | c7d5349 | 2010-06-25 13:41:57 -0700 | [diff] [blame] | 2098 | } |
Romain Guy | 9d5316e | 2010-06-24 19:30:36 -0700 | [diff] [blame] | 2099 | |
Romain Guy | eb9a536 | 2012-01-17 17:39:26 -0800 | [diff] [blame] | 2100 | void OpenGLRenderer::drawPosText(const char* text, int bytesCount, int count, |
| 2101 | const float* positions, SkPaint* paint) { |
Romain Guy | 671d6cf | 2012-01-18 12:39:17 -0800 | [diff] [blame] | 2102 | if (text == NULL || count == 0 || mSnapshot->isIgnored() || |
| 2103 | (paint->getAlpha() == 0 && paint->getXfermode() == NULL)) { |
Romain Guy | eb9a536 | 2012-01-17 17:39:26 -0800 | [diff] [blame] | 2104 | return; |
| 2105 | } |
Romain Guy | eb9a536 | 2012-01-17 17:39:26 -0800 | [diff] [blame] | 2106 | |
Romain Guy | 671d6cf | 2012-01-18 12:39:17 -0800 | [diff] [blame] | 2107 | // NOTE: Skia does not support perspective transform on drawPosText yet |
| 2108 | if (!mSnapshot->transform->isSimple()) { |
| 2109 | return; |
| 2110 | } |
| 2111 | |
| 2112 | float x = 0.0f; |
| 2113 | float y = 0.0f; |
| 2114 | const bool pureTranslate = mSnapshot->transform->isPureTranslate(); |
| 2115 | if (pureTranslate) { |
| 2116 | x = (int) floorf(x + mSnapshot->transform->getTranslateX() + 0.5f); |
| 2117 | y = (int) floorf(y + mSnapshot->transform->getTranslateY() + 0.5f); |
| 2118 | } |
| 2119 | |
| 2120 | FontRenderer& fontRenderer = mCaches.fontRenderer.getFontRenderer(paint); |
| 2121 | fontRenderer.setFont(paint, SkTypeface::UniqueID(paint->getTypeface()), |
| 2122 | paint->getTextSize()); |
| 2123 | |
| 2124 | int alpha; |
| 2125 | SkXfermode::Mode mode; |
| 2126 | getAlphaAndMode(paint, &alpha, &mode); |
| 2127 | |
| 2128 | // Pick the appropriate texture filtering |
| 2129 | bool linearFilter = mSnapshot->transform->changesBounds(); |
| 2130 | if (pureTranslate && !linearFilter) { |
| 2131 | linearFilter = fabs(y - (int) y) > 0.0f || fabs(x - (int) x) > 0.0f; |
| 2132 | } |
| 2133 | |
| 2134 | mCaches.activeTexture(0); |
| 2135 | setupDraw(); |
| 2136 | setupDrawDirtyRegionsDisabled(); |
| 2137 | setupDrawWithTexture(true); |
| 2138 | setupDrawAlpha8Color(paint->getColor(), alpha); |
| 2139 | setupDrawColorFilter(); |
| 2140 | setupDrawShader(); |
| 2141 | setupDrawBlending(true, mode); |
| 2142 | setupDrawProgram(); |
| 2143 | setupDrawModelView(x, y, x, y, pureTranslate, true); |
| 2144 | setupDrawTexture(fontRenderer.getTexture(linearFilter)); |
| 2145 | setupDrawPureColorUniforms(); |
| 2146 | setupDrawColorFilterUniforms(); |
| 2147 | setupDrawShaderUniforms(pureTranslate); |
| 2148 | |
| 2149 | const Rect* clip = pureTranslate ? mSnapshot->clipRect : &mSnapshot->getLocalClip(); |
| 2150 | Rect bounds(FLT_MAX / 2.0f, FLT_MAX / 2.0f, FLT_MIN / 2.0f, FLT_MIN / 2.0f); |
| 2151 | |
| 2152 | #if RENDER_LAYERS_AS_REGIONS |
Romain Guy | 211370f | 2012-02-01 16:10:55 -0800 | [diff] [blame] | 2153 | const bool hasActiveLayer = hasLayer(); |
Romain Guy | 671d6cf | 2012-01-18 12:39:17 -0800 | [diff] [blame] | 2154 | #else |
Romain Guy | 211370f | 2012-02-01 16:10:55 -0800 | [diff] [blame] | 2155 | const bool hasActiveLayer = false; |
Romain Guy | 671d6cf | 2012-01-18 12:39:17 -0800 | [diff] [blame] | 2156 | #endif |
| 2157 | |
| 2158 | if (fontRenderer.renderPosText(paint, clip, text, 0, bytesCount, count, x, y, |
| 2159 | positions, hasActiveLayer ? &bounds : NULL)) { |
| 2160 | #if RENDER_LAYERS_AS_REGIONS |
| 2161 | if (hasActiveLayer) { |
| 2162 | if (!pureTranslate) { |
| 2163 | mSnapshot->transform->mapRect(bounds); |
| 2164 | } |
| 2165 | dirtyLayerUnchecked(bounds, getRegion()); |
| 2166 | } |
| 2167 | #endif |
| 2168 | } |
Romain Guy | eb9a536 | 2012-01-17 17:39:26 -0800 | [diff] [blame] | 2169 | } |
| 2170 | |
Romain Guy | e8e62a4 | 2010-07-23 18:55:21 -0700 | [diff] [blame] | 2171 | void OpenGLRenderer::drawText(const char* text, int bytesCount, int count, |
Romain Guy | cac5fd3 | 2011-12-01 20:08:50 -0800 | [diff] [blame] | 2172 | float x, float y, SkPaint* paint, float length) { |
Romain Guy | 671d6cf | 2012-01-18 12:39:17 -0800 | [diff] [blame] | 2173 | if (text == NULL || count == 0 || mSnapshot->isIgnored() || |
| 2174 | (paint->getAlpha() == 0 && paint->getXfermode() == NULL)) { |
Romain Guy | e8e62a4 | 2010-07-23 18:55:21 -0700 | [diff] [blame] | 2175 | return; |
| 2176 | } |
| 2177 | |
Chet Haase | a1cff50 | 2012-02-21 13:43:44 -0800 | [diff] [blame] | 2178 | if (length < 0.0f) length = paint->measureText(text, bytesCount); |
Romain Guy | e8e62a4 | 2010-07-23 18:55:21 -0700 | [diff] [blame] | 2179 | switch (paint->getTextAlign()) { |
| 2180 | case SkPaint::kCenter_Align: |
Romain Guy | e8e62a4 | 2010-07-23 18:55:21 -0700 | [diff] [blame] | 2181 | x -= length / 2.0f; |
| 2182 | break; |
| 2183 | case SkPaint::kRight_Align: |
Romain Guy | e8e62a4 | 2010-07-23 18:55:21 -0700 | [diff] [blame] | 2184 | x -= length; |
| 2185 | break; |
| 2186 | default: |
| 2187 | break; |
| 2188 | } |
| 2189 | |
Romain Guy | cac5fd3 | 2011-12-01 20:08:50 -0800 | [diff] [blame] | 2190 | SkPaint::FontMetrics metrics; |
| 2191 | paint->getFontMetrics(&metrics, 0.0f); |
Romain Guy | 33f6beb | 2012-02-16 19:24:51 -0800 | [diff] [blame] | 2192 | if (quickReject(x, y + metrics.fTop, x + length, y + metrics.fBottom)) { |
Romain Guy | cac5fd3 | 2011-12-01 20:08:50 -0800 | [diff] [blame] | 2193 | return; |
| 2194 | } |
| 2195 | |
Romain Guy | 3a3fa1b | 2010-12-06 18:47:50 -0800 | [diff] [blame] | 2196 | const float oldX = x; |
| 2197 | const float oldY = y; |
Romain Guy | 6620c6d | 2010-12-06 18:07:02 -0800 | [diff] [blame] | 2198 | const bool pureTranslate = mSnapshot->transform->isPureTranslate(); |
Romain Guy | 211370f | 2012-02-01 16:10:55 -0800 | [diff] [blame] | 2199 | if (CC_LIKELY(pureTranslate)) { |
Romain Guy | 6620c6d | 2010-12-06 18:07:02 -0800 | [diff] [blame] | 2200 | x = (int) floorf(x + mSnapshot->transform->getTranslateX() + 0.5f); |
| 2201 | y = (int) floorf(y + mSnapshot->transform->getTranslateY() + 0.5f); |
| 2202 | } |
| 2203 | |
Fabrice Di Meglio | ef9bb3c | 2011-10-17 11:06:46 -0700 | [diff] [blame] | 2204 | #if DEBUG_GLYPHS |
Steve Block | 5baa3a6 | 2011-12-20 16:23:08 +0000 | [diff] [blame] | 2205 | ALOGD("OpenGLRenderer drawText() with FontID=%d", SkTypeface::UniqueID(paint->getTypeface())); |
Fabrice Di Meglio | ef9bb3c | 2011-10-17 11:06:46 -0700 | [diff] [blame] | 2206 | #endif |
Romain Guy | eb9a536 | 2012-01-17 17:39:26 -0800 | [diff] [blame] | 2207 | |
| 2208 | FontRenderer& fontRenderer = mCaches.fontRenderer.getFontRenderer(paint); |
Romain Guy | b45c0c9 | 2010-08-26 20:35:23 -0700 | [diff] [blame] | 2209 | fontRenderer.setFont(paint, SkTypeface::UniqueID(paint->getTypeface()), |
Romain Guy | fb8b763 | 2010-08-23 21:05:08 -0700 | [diff] [blame] | 2210 | paint->getTextSize()); |
Romain Guy | e2d345e | 2010-09-24 18:39:22 -0700 | [diff] [blame] | 2211 | |
Romain Guy | 8656819 | 2010-12-14 15:55:39 -0800 | [diff] [blame] | 2212 | int alpha; |
| 2213 | SkXfermode::Mode mode; |
| 2214 | getAlphaAndMode(paint, &alpha, &mode); |
Romain Guy | 9d13fe25 | 2010-10-15 16:06:03 -0700 | [diff] [blame] | 2215 | |
Romain Guy | 211370f | 2012-02-01 16:10:55 -0800 | [diff] [blame] | 2216 | if (CC_UNLIKELY(mHasShadow)) { |
Romain Guy | 2d4fd36 | 2011-12-13 22:00:19 -0800 | [diff] [blame] | 2217 | mCaches.activeTexture(0); |
| 2218 | |
Romain Guy | b45c0c9 | 2010-08-26 20:35:23 -0700 | [diff] [blame] | 2219 | mCaches.dropShadowCache.setFontRenderer(fontRenderer); |
Romain Guy | 67ffc36 | 2011-06-03 18:50:11 -0700 | [diff] [blame] | 2220 | const ShadowTexture* shadow = mCaches.dropShadowCache.get( |
| 2221 | paint, text, bytesCount, count, mShadowRadius); |
Romain Guy | 1e45aae | 2010-08-13 19:39:53 -0700 | [diff] [blame] | 2222 | const AutoTexture autoCleanup(shadow); |
Romain Guy | 0a41749 | 2010-08-16 20:26:20 -0700 | [diff] [blame] | 2223 | |
Romain Guy | 740bf2b | 2011-04-26 15:33:10 -0700 | [diff] [blame] | 2224 | const float sx = oldX - shadow->left + mShadowDx; |
| 2225 | const float sy = oldY - shadow->top + mShadowDy; |
Romain Guy | 0a41749 | 2010-08-16 20:26:20 -0700 | [diff] [blame] | 2226 | |
Romain Guy | 8656819 | 2010-12-14 15:55:39 -0800 | [diff] [blame] | 2227 | const int shadowAlpha = ((mShadowColor >> 24) & 0xFF); |
Romain Guy | 740bf2b | 2011-04-26 15:33:10 -0700 | [diff] [blame] | 2228 | int shadowColor = mShadowColor; |
| 2229 | if (mShader) { |
| 2230 | shadowColor = 0xffffffff; |
| 2231 | } |
Romain Guy | 8656819 | 2010-12-14 15:55:39 -0800 | [diff] [blame] | 2232 | |
Romain Guy | 8656819 | 2010-12-14 15:55:39 -0800 | [diff] [blame] | 2233 | setupDraw(); |
| 2234 | setupDrawWithTexture(true); |
Romain Guy | 740bf2b | 2011-04-26 15:33:10 -0700 | [diff] [blame] | 2235 | setupDrawAlpha8Color(shadowColor, shadowAlpha < 255 ? shadowAlpha : alpha); |
| 2236 | setupDrawColorFilter(); |
| 2237 | setupDrawShader(); |
Romain Guy | 8656819 | 2010-12-14 15:55:39 -0800 | [diff] [blame] | 2238 | setupDrawBlending(true, mode); |
| 2239 | setupDrawProgram(); |
Romain Guy | 740bf2b | 2011-04-26 15:33:10 -0700 | [diff] [blame] | 2240 | setupDrawModelView(sx, sy, sx + shadow->width, sy + shadow->height); |
Romain Guy | 8656819 | 2010-12-14 15:55:39 -0800 | [diff] [blame] | 2241 | setupDrawTexture(shadow->id); |
| 2242 | setupDrawPureColorUniforms(); |
Romain Guy | 740bf2b | 2011-04-26 15:33:10 -0700 | [diff] [blame] | 2243 | setupDrawColorFilterUniforms(); |
| 2244 | setupDrawShaderUniforms(); |
Romain Guy | 8656819 | 2010-12-14 15:55:39 -0800 | [diff] [blame] | 2245 | setupDrawMesh(NULL, (GLvoid*) gMeshTextureOffset); |
| 2246 | |
Romain Guy | 0a41749 | 2010-08-16 20:26:20 -0700 | [diff] [blame] | 2247 | glDrawArrays(GL_TRIANGLE_STRIP, 0, gMeshCount); |
Romain Guy | 1e45aae | 2010-08-13 19:39:53 -0700 | [diff] [blame] | 2248 | } |
| 2249 | |
Romain Guy | 6620c6d | 2010-12-06 18:07:02 -0800 | [diff] [blame] | 2250 | // Pick the appropriate texture filtering |
| 2251 | bool linearFilter = mSnapshot->transform->changesBounds(); |
| 2252 | if (pureTranslate && !linearFilter) { |
| 2253 | linearFilter = fabs(y - (int) y) > 0.0f || fabs(x - (int) x) > 0.0f; |
| 2254 | } |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 2255 | |
Romain Guy | a1d3c91 | 2011-12-13 14:55:06 -0800 | [diff] [blame] | 2256 | mCaches.activeTexture(0); |
Romain Guy | 8656819 | 2010-12-14 15:55:39 -0800 | [diff] [blame] | 2257 | setupDraw(); |
| 2258 | setupDrawDirtyRegionsDisabled(); |
| 2259 | setupDrawWithTexture(true); |
| 2260 | setupDrawAlpha8Color(paint->getColor(), alpha); |
| 2261 | setupDrawColorFilter(); |
| 2262 | setupDrawShader(); |
| 2263 | setupDrawBlending(true, mode); |
| 2264 | setupDrawProgram(); |
| 2265 | setupDrawModelView(x, y, x, y, pureTranslate, true); |
| 2266 | setupDrawTexture(fontRenderer.getTexture(linearFilter)); |
| 2267 | setupDrawPureColorUniforms(); |
| 2268 | setupDrawColorFilterUniforms(); |
| 2269 | setupDrawShaderUniforms(pureTranslate); |
Romain Guy | 06f96e2 | 2010-07-30 19:18:16 -0700 | [diff] [blame] | 2270 | |
Romain Guy | 6620c6d | 2010-12-06 18:07:02 -0800 | [diff] [blame] | 2271 | const Rect* clip = pureTranslate ? mSnapshot->clipRect : &mSnapshot->getLocalClip(); |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 2272 | Rect bounds(FLT_MAX / 2.0f, FLT_MAX / 2.0f, FLT_MIN / 2.0f, FLT_MIN / 2.0f); |
| 2273 | |
| 2274 | #if RENDER_LAYERS_AS_REGIONS |
Romain Guy | 211370f | 2012-02-01 16:10:55 -0800 | [diff] [blame] | 2275 | const bool hasActiveLayer = hasLayer(); |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 2276 | #else |
Romain Guy | 211370f | 2012-02-01 16:10:55 -0800 | [diff] [blame] | 2277 | const bool hasActiveLayer = false; |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 2278 | #endif |
Alex Sakhartchouk | 894df17 | 2011-02-17 16:45:37 -0800 | [diff] [blame] | 2279 | |
Romain Guy | 6620c6d | 2010-12-06 18:07:02 -0800 | [diff] [blame] | 2280 | if (fontRenderer.renderText(paint, clip, text, 0, bytesCount, count, x, y, |
Romain Guy | f219da5 | 2011-01-16 12:54:25 -0800 | [diff] [blame] | 2281 | hasActiveLayer ? &bounds : NULL)) { |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 2282 | #if RENDER_LAYERS_AS_REGIONS |
Romain Guy | f219da5 | 2011-01-16 12:54:25 -0800 | [diff] [blame] | 2283 | if (hasActiveLayer) { |
Romain Guy | 6620c6d | 2010-12-06 18:07:02 -0800 | [diff] [blame] | 2284 | if (!pureTranslate) { |
| 2285 | mSnapshot->transform->mapRect(bounds); |
| 2286 | } |
Romain Guy | f219da5 | 2011-01-16 12:54:25 -0800 | [diff] [blame] | 2287 | dirtyLayerUnchecked(bounds, getRegion()); |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 2288 | } |
| 2289 | #endif |
| 2290 | } |
Romain Guy | 694b519 | 2010-07-21 21:33:20 -0700 | [diff] [blame] | 2291 | |
Romain Guy | 3a3fa1b | 2010-12-06 18:47:50 -0800 | [diff] [blame] | 2292 | drawTextDecorations(text, bytesCount, length, oldX, oldY, paint); |
Romain Guy | 694b519 | 2010-07-21 21:33:20 -0700 | [diff] [blame] | 2293 | } |
| 2294 | |
Romain Guy | 325740f | 2012-02-24 16:48:34 -0800 | [diff] [blame] | 2295 | void OpenGLRenderer::drawTextOnPath(const char* text, int bytesCount, int count, SkPath* path, |
| 2296 | float hOffset, float vOffset, SkPaint* paint) { |
Romain Guy | 03d5852 | 2012-02-24 17:54:07 -0800 | [diff] [blame] | 2297 | if (text == NULL || count == 0 || mSnapshot->isIgnored() || |
| 2298 | (paint->getAlpha() == 0 && paint->getXfermode() == NULL)) { |
| 2299 | return; |
| 2300 | } |
| 2301 | |
Romain Guy | 03d5852 | 2012-02-24 17:54:07 -0800 | [diff] [blame] | 2302 | FontRenderer& fontRenderer = mCaches.fontRenderer.getFontRenderer(paint); |
| 2303 | fontRenderer.setFont(paint, SkTypeface::UniqueID(paint->getTypeface()), |
| 2304 | paint->getTextSize()); |
| 2305 | |
| 2306 | int alpha; |
| 2307 | SkXfermode::Mode mode; |
| 2308 | getAlphaAndMode(paint, &alpha, &mode); |
| 2309 | |
| 2310 | mCaches.activeTexture(0); |
| 2311 | setupDraw(); |
| 2312 | setupDrawDirtyRegionsDisabled(); |
| 2313 | setupDrawWithTexture(true); |
| 2314 | setupDrawAlpha8Color(paint->getColor(), alpha); |
| 2315 | setupDrawColorFilter(); |
| 2316 | setupDrawShader(); |
| 2317 | setupDrawBlending(true, mode); |
| 2318 | setupDrawProgram(); |
Romain Guy | 9777173 | 2012-02-28 18:17:02 -0800 | [diff] [blame] | 2319 | setupDrawModelView(0.0f, 0.0f, 0.0f, 0.0f, false, true); |
Romain Guy | 03d5852 | 2012-02-24 17:54:07 -0800 | [diff] [blame] | 2320 | setupDrawTexture(fontRenderer.getTexture(true)); |
| 2321 | setupDrawPureColorUniforms(); |
| 2322 | setupDrawColorFilterUniforms(); |
Romain Guy | 9777173 | 2012-02-28 18:17:02 -0800 | [diff] [blame] | 2323 | setupDrawShaderUniforms(false); |
Romain Guy | 03d5852 | 2012-02-24 17:54:07 -0800 | [diff] [blame] | 2324 | |
Romain Guy | 9777173 | 2012-02-28 18:17:02 -0800 | [diff] [blame] | 2325 | const Rect* clip = &mSnapshot->getLocalClip(); |
| 2326 | Rect bounds(FLT_MAX / 2.0f, FLT_MAX / 2.0f, FLT_MIN / 2.0f, FLT_MIN / 2.0f); |
Romain Guy | 03d5852 | 2012-02-24 17:54:07 -0800 | [diff] [blame] | 2327 | |
Romain Guy | 9777173 | 2012-02-28 18:17:02 -0800 | [diff] [blame] | 2328 | #if RENDER_LAYERS_AS_REGIONS |
| 2329 | const bool hasActiveLayer = hasLayer(); |
| 2330 | #else |
| 2331 | const bool hasActiveLayer = false; |
| 2332 | #endif |
| 2333 | |
| 2334 | if (fontRenderer.renderTextOnPath(paint, clip, text, 0, bytesCount, count, path, |
| 2335 | hOffset, vOffset, hasActiveLayer ? &bounds : NULL)) { |
| 2336 | #if RENDER_LAYERS_AS_REGIONS |
| 2337 | if (hasActiveLayer) { |
| 2338 | mSnapshot->transform->mapRect(bounds); |
| 2339 | dirtyLayerUnchecked(bounds, getRegion()); |
| 2340 | } |
| 2341 | #endif |
| 2342 | } |
Romain Guy | 325740f | 2012-02-24 16:48:34 -0800 | [diff] [blame] | 2343 | } |
| 2344 | |
Romain Guy | 7fbcc04 | 2010-08-04 15:40:07 -0700 | [diff] [blame] | 2345 | void OpenGLRenderer::drawPath(SkPath* path, SkPaint* paint) { |
Romain Guy | af636eb | 2010-12-09 17:47:21 -0800 | [diff] [blame] | 2346 | if (mSnapshot->isIgnored()) return; |
Romain Guy | dbc26d2 | 2010-10-11 17:58:29 -0700 | [diff] [blame] | 2347 | |
Romain Guy | a1d3c91 | 2011-12-13 14:55:06 -0800 | [diff] [blame] | 2348 | mCaches.activeTexture(0); |
Romain Guy | 7fbcc04 | 2010-08-04 15:40:07 -0700 | [diff] [blame] | 2349 | |
Romain Guy | 33f6beb | 2012-02-16 19:24:51 -0800 | [diff] [blame] | 2350 | // TODO: Perform early clip test before we rasterize the path |
Romain Guy | fb8b763 | 2010-08-23 21:05:08 -0700 | [diff] [blame] | 2351 | const PathTexture* texture = mCaches.pathCache.get(path, paint); |
Romain Guy | 9cccc2b | 2010-08-07 23:46:15 -0700 | [diff] [blame] | 2352 | if (!texture) return; |
Romain Guy | 22158e1 | 2010-08-06 11:18:34 -0700 | [diff] [blame] | 2353 | const AutoTexture autoCleanup(texture); |
Romain Guy | 7fbcc04 | 2010-08-04 15:40:07 -0700 | [diff] [blame] | 2354 | |
Romain Guy | 8b55f37 | 2010-08-18 17:10:07 -0700 | [diff] [blame] | 2355 | const float x = texture->left - texture->offset; |
| 2356 | const float y = texture->top - texture->offset; |
| 2357 | |
Romain Guy | 01d58e4 | 2011-01-19 21:54:02 -0800 | [diff] [blame] | 2358 | drawPathTexture(texture, x, y, paint); |
Romain Guy | 7fbcc04 | 2010-08-04 15:40:07 -0700 | [diff] [blame] | 2359 | } |
| 2360 | |
Romain Guy | ada830f | 2011-01-13 12:13:20 -0800 | [diff] [blame] | 2361 | void OpenGLRenderer::drawLayer(Layer* layer, float x, float y, SkPaint* paint) { |
| 2362 | if (!layer || quickReject(x, y, x + layer->layer.getWidth(), y + layer->layer.getHeight())) { |
Romain Guy | 6c319ca | 2011-01-11 14:29:25 -0800 | [diff] [blame] | 2363 | return; |
| 2364 | } |
| 2365 | |
Romain Guy | 2bf68f0 | 2012-03-02 13:37:47 -0800 | [diff] [blame] | 2366 | if (layer->deferredUpdateScheduled && layer->renderer && layer->displayList) { |
| 2367 | OpenGLRenderer* renderer = layer->renderer; |
| 2368 | Rect& dirty = layer->dirtyRect; |
| 2369 | |
| 2370 | interrupt(); |
| 2371 | renderer->setViewport(layer->layer.getWidth(), layer->layer.getHeight()); |
| 2372 | renderer->prepareDirty(dirty.left, dirty.top, dirty.right, dirty.bottom, !layer->isBlend()); |
| 2373 | renderer->drawDisplayList(layer->displayList, layer->getWidth(), layer->getHeight(), |
| 2374 | dirty, DisplayList::kReplayFlag_ClipChildren); |
| 2375 | renderer->finish(); |
| 2376 | resume(); |
| 2377 | |
| 2378 | dirty.setEmpty(); |
| 2379 | layer->deferredUpdateScheduled = false; |
| 2380 | layer->renderer = NULL; |
| 2381 | layer->displayList = NULL; |
| 2382 | } |
| 2383 | |
Romain Guy | a1d3c91 | 2011-12-13 14:55:06 -0800 | [diff] [blame] | 2384 | mCaches.activeTexture(0); |
Romain Guy | 6c319ca | 2011-01-11 14:29:25 -0800 | [diff] [blame] | 2385 | |
| 2386 | int alpha; |
| 2387 | SkXfermode::Mode mode; |
| 2388 | getAlphaAndMode(paint, &alpha, &mode); |
| 2389 | |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 2390 | layer->setAlpha(alpha, mode); |
Romain Guy | 6c319ca | 2011-01-11 14:29:25 -0800 | [diff] [blame] | 2391 | |
Romain Guy | f219da5 | 2011-01-16 12:54:25 -0800 | [diff] [blame] | 2392 | #if RENDER_LAYERS_AS_REGIONS |
Romain Guy | 211370f | 2012-02-01 16:10:55 -0800 | [diff] [blame] | 2393 | if (CC_LIKELY(!layer->region.isEmpty())) { |
Romain Guy | c88e357 | 2011-01-22 00:32:12 -0800 | [diff] [blame] | 2394 | if (layer->region.isRect()) { |
Romain Guy | 4066767 | 2011-03-18 14:34:03 -0700 | [diff] [blame] | 2395 | composeLayerRect(layer, layer->regionRect); |
Romain Guy | c88e357 | 2011-01-22 00:32:12 -0800 | [diff] [blame] | 2396 | } else if (layer->mesh) { |
Romain Guy | 8168396 | 2011-01-24 20:40:18 -0800 | [diff] [blame] | 2397 | const float a = alpha / 255.0f; |
Romain Guy | c88e357 | 2011-01-22 00:32:12 -0800 | [diff] [blame] | 2398 | const Rect& rect = layer->layer; |
Romain Guy | f219da5 | 2011-01-16 12:54:25 -0800 | [diff] [blame] | 2399 | |
Romain Guy | c88e357 | 2011-01-22 00:32:12 -0800 | [diff] [blame] | 2400 | setupDraw(); |
| 2401 | setupDrawWithTexture(); |
Romain Guy | 8168396 | 2011-01-24 20:40:18 -0800 | [diff] [blame] | 2402 | setupDrawColor(a, a, a, a); |
Romain Guy | c88e357 | 2011-01-22 00:32:12 -0800 | [diff] [blame] | 2403 | setupDrawColorFilter(); |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 2404 | setupDrawBlending(layer->isBlend() || a < 1.0f, layer->getMode(), false); |
Romain Guy | c88e357 | 2011-01-22 00:32:12 -0800 | [diff] [blame] | 2405 | setupDrawProgram(); |
Romain Guy | c88e357 | 2011-01-22 00:32:12 -0800 | [diff] [blame] | 2406 | setupDrawPureColorUniforms(); |
| 2407 | setupDrawColorFilterUniforms(); |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 2408 | setupDrawTexture(layer->getTexture()); |
Romain Guy | 211370f | 2012-02-01 16:10:55 -0800 | [diff] [blame] | 2409 | if (CC_LIKELY(mSnapshot->transform->isPureTranslate())) { |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 2410 | x = (int) floorf(x + mSnapshot->transform->getTranslateX() + 0.5f); |
| 2411 | y = (int) floorf(y + mSnapshot->transform->getTranslateY() + 0.5f); |
| 2412 | |
Romain Guy | d21b6e1 | 2011-11-30 20:21:23 -0800 | [diff] [blame] | 2413 | layer->setFilter(GL_NEAREST); |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 2414 | setupDrawModelViewTranslate(x, y, |
| 2415 | x + layer->layer.getWidth(), y + layer->layer.getHeight(), true); |
| 2416 | } else { |
Romain Guy | d21b6e1 | 2011-11-30 20:21:23 -0800 | [diff] [blame] | 2417 | layer->setFilter(GL_LINEAR); |
Romain Guy | 9ace8f5 | 2011-07-07 20:50:11 -0700 | [diff] [blame] | 2418 | setupDrawModelViewTranslate(x, y, |
| 2419 | x + layer->layer.getWidth(), y + layer->layer.getHeight()); |
| 2420 | } |
Romain Guy | c88e357 | 2011-01-22 00:32:12 -0800 | [diff] [blame] | 2421 | setupDrawMesh(&layer->mesh[0].position[0], &layer->mesh[0].texture[0]); |
Romain Guy | f219da5 | 2011-01-16 12:54:25 -0800 | [diff] [blame] | 2422 | |
Romain Guy | c88e357 | 2011-01-22 00:32:12 -0800 | [diff] [blame] | 2423 | glDrawElements(GL_TRIANGLES, layer->meshElementCount, |
| 2424 | GL_UNSIGNED_SHORT, layer->meshIndices); |
Romain Guy | f219da5 | 2011-01-16 12:54:25 -0800 | [diff] [blame] | 2425 | |
Romain Guy | c88e357 | 2011-01-22 00:32:12 -0800 | [diff] [blame] | 2426 | finishDrawTexture(); |
Romain Guy | 3a3133d | 2011-02-01 22:59:58 -0800 | [diff] [blame] | 2427 | |
| 2428 | #if DEBUG_LAYERS_AS_REGIONS |
| 2429 | drawRegionRects(layer->region); |
| 2430 | #endif |
Romain Guy | c88e357 | 2011-01-22 00:32:12 -0800 | [diff] [blame] | 2431 | } |
Romain Guy | f219da5 | 2011-01-16 12:54:25 -0800 | [diff] [blame] | 2432 | } |
| 2433 | #else |
Romain Guy | ada830f | 2011-01-13 12:13:20 -0800 | [diff] [blame] | 2434 | const Rect r(x, y, x + layer->layer.getWidth(), y + layer->layer.getHeight()); |
| 2435 | composeLayerRect(layer, r); |
Romain Guy | f219da5 | 2011-01-16 12:54:25 -0800 | [diff] [blame] | 2436 | #endif |
Romain Guy | 6c319ca | 2011-01-11 14:29:25 -0800 | [diff] [blame] | 2437 | } |
| 2438 | |
Romain Guy | 6926c72 | 2010-07-12 20:20:03 -0700 | [diff] [blame] | 2439 | /////////////////////////////////////////////////////////////////////////////// |
Romain Guy | d27977d | 2010-07-14 19:18:51 -0700 | [diff] [blame] | 2440 | // Shaders |
| 2441 | /////////////////////////////////////////////////////////////////////////////// |
| 2442 | |
| 2443 | void OpenGLRenderer::resetShader() { |
Romain Guy | 06f96e2 | 2010-07-30 19:18:16 -0700 | [diff] [blame] | 2444 | mShader = NULL; |
Romain Guy | d27977d | 2010-07-14 19:18:51 -0700 | [diff] [blame] | 2445 | } |
| 2446 | |
Romain Guy | 06f96e2 | 2010-07-30 19:18:16 -0700 | [diff] [blame] | 2447 | void OpenGLRenderer::setupShader(SkiaShader* shader) { |
| 2448 | mShader = shader; |
| 2449 | if (mShader) { |
Romain Guy | fb8b763 | 2010-08-23 21:05:08 -0700 | [diff] [blame] | 2450 | mShader->set(&mCaches.textureCache, &mCaches.gradientCache); |
Romain Guy | 06f96e2 | 2010-07-30 19:18:16 -0700 | [diff] [blame] | 2451 | } |
Romain Guy | 7fac2e1 | 2010-07-16 17:10:13 -0700 | [diff] [blame] | 2452 | } |
| 2453 | |
Romain Guy | d27977d | 2010-07-14 19:18:51 -0700 | [diff] [blame] | 2454 | /////////////////////////////////////////////////////////////////////////////// |
Romain Guy | db1938e | 2010-08-02 18:50:22 -0700 | [diff] [blame] | 2455 | // Color filters |
| 2456 | /////////////////////////////////////////////////////////////////////////////// |
| 2457 | |
| 2458 | void OpenGLRenderer::resetColorFilter() { |
| 2459 | mColorFilter = NULL; |
| 2460 | } |
| 2461 | |
| 2462 | void OpenGLRenderer::setupColorFilter(SkiaColorFilter* filter) { |
| 2463 | mColorFilter = filter; |
| 2464 | } |
| 2465 | |
| 2466 | /////////////////////////////////////////////////////////////////////////////// |
Romain Guy | 1e45aae | 2010-08-13 19:39:53 -0700 | [diff] [blame] | 2467 | // Drop shadow |
| 2468 | /////////////////////////////////////////////////////////////////////////////// |
| 2469 | |
| 2470 | void OpenGLRenderer::resetShadow() { |
| 2471 | mHasShadow = false; |
| 2472 | } |
| 2473 | |
| 2474 | void OpenGLRenderer::setupShadow(float radius, float dx, float dy, int color) { |
| 2475 | mHasShadow = true; |
| 2476 | mShadowRadius = radius; |
| 2477 | mShadowDx = dx; |
| 2478 | mShadowDy = dy; |
| 2479 | mShadowColor = color; |
| 2480 | } |
| 2481 | |
| 2482 | /////////////////////////////////////////////////////////////////////////////// |
Romain Guy | 5ff9df6 | 2012-01-23 17:09:05 -0800 | [diff] [blame] | 2483 | // Draw filters |
| 2484 | /////////////////////////////////////////////////////////////////////////////// |
| 2485 | |
| 2486 | void OpenGLRenderer::resetPaintFilter() { |
| 2487 | mHasDrawFilter = false; |
| 2488 | } |
| 2489 | |
| 2490 | void OpenGLRenderer::setupPaintFilter(int clearBits, int setBits) { |
| 2491 | mHasDrawFilter = true; |
| 2492 | mPaintFilterClearBits = clearBits & SkPaint::kAllFlags; |
| 2493 | mPaintFilterSetBits = setBits & SkPaint::kAllFlags; |
| 2494 | } |
| 2495 | |
| 2496 | SkPaint* OpenGLRenderer::filterPaint(SkPaint* paint) { |
Romain Guy | dd7c8e4c | 2012-03-01 12:08:38 -0800 | [diff] [blame] | 2497 | if (CC_LIKELY(!mHasDrawFilter || !paint)) return paint; |
Romain Guy | 5ff9df6 | 2012-01-23 17:09:05 -0800 | [diff] [blame] | 2498 | |
| 2499 | uint32_t flags = paint->getFlags(); |
| 2500 | |
| 2501 | mFilteredPaint = *paint; |
| 2502 | mFilteredPaint.setFlags((flags & ~mPaintFilterClearBits) | mPaintFilterSetBits); |
| 2503 | |
| 2504 | return &mFilteredPaint; |
| 2505 | } |
| 2506 | |
| 2507 | /////////////////////////////////////////////////////////////////////////////// |
Romain Guy | 6926c72 | 2010-07-12 20:20:03 -0700 | [diff] [blame] | 2508 | // Drawing implementation |
| 2509 | /////////////////////////////////////////////////////////////////////////////// |
| 2510 | |
Romain Guy | 01d58e4 | 2011-01-19 21:54:02 -0800 | [diff] [blame] | 2511 | void OpenGLRenderer::drawPathTexture(const PathTexture* texture, |
| 2512 | float x, float y, SkPaint* paint) { |
| 2513 | if (quickReject(x, y, x + texture->width, y + texture->height)) { |
| 2514 | return; |
| 2515 | } |
| 2516 | |
| 2517 | int alpha; |
| 2518 | SkXfermode::Mode mode; |
| 2519 | getAlphaAndMode(paint, &alpha, &mode); |
| 2520 | |
| 2521 | setupDraw(); |
| 2522 | setupDrawWithTexture(true); |
| 2523 | setupDrawAlpha8Color(paint->getColor(), alpha); |
| 2524 | setupDrawColorFilter(); |
| 2525 | setupDrawShader(); |
| 2526 | setupDrawBlending(true, mode); |
| 2527 | setupDrawProgram(); |
| 2528 | setupDrawModelView(x, y, x + texture->width, y + texture->height); |
| 2529 | setupDrawTexture(texture->id); |
| 2530 | setupDrawPureColorUniforms(); |
| 2531 | setupDrawColorFilterUniforms(); |
| 2532 | setupDrawShaderUniforms(); |
| 2533 | setupDrawMesh(NULL, (GLvoid*) gMeshTextureOffset); |
| 2534 | |
| 2535 | glDrawArrays(GL_TRIANGLE_STRIP, 0, gMeshCount); |
| 2536 | |
| 2537 | finishDrawTexture(); |
| 2538 | } |
| 2539 | |
Romain Guy | f607bdc | 2010-09-10 19:20:06 -0700 | [diff] [blame] | 2540 | // Same values used by Skia |
Romain Guy | 0a41749 | 2010-08-16 20:26:20 -0700 | [diff] [blame] | 2541 | #define kStdStrikeThru_Offset (-6.0f / 21.0f) |
| 2542 | #define kStdUnderline_Offset (1.0f / 9.0f) |
| 2543 | #define kStdUnderline_Thickness (1.0f / 18.0f) |
| 2544 | |
| 2545 | void OpenGLRenderer::drawTextDecorations(const char* text, int bytesCount, float length, |
| 2546 | float x, float y, SkPaint* paint) { |
| 2547 | // Handle underline and strike-through |
| 2548 | uint32_t flags = paint->getFlags(); |
| 2549 | if (flags & (SkPaint::kUnderlineText_Flag | SkPaint::kStrikeThruText_Flag)) { |
Romain Guy | 726aeba | 2011-06-01 14:52:00 -0700 | [diff] [blame] | 2550 | SkPaint paintCopy(*paint); |
Romain Guy | 0a41749 | 2010-08-16 20:26:20 -0700 | [diff] [blame] | 2551 | float underlineWidth = length; |
| 2552 | // If length is > 0.0f, we already measured the text for the text alignment |
| 2553 | if (length <= 0.0f) { |
Romain Guy | 726aeba | 2011-06-01 14:52:00 -0700 | [diff] [blame] | 2554 | underlineWidth = paintCopy.measureText(text, bytesCount); |
Romain Guy | 0a41749 | 2010-08-16 20:26:20 -0700 | [diff] [blame] | 2555 | } |
| 2556 | |
| 2557 | float offsetX = 0; |
Romain Guy | 726aeba | 2011-06-01 14:52:00 -0700 | [diff] [blame] | 2558 | switch (paintCopy.getTextAlign()) { |
Romain Guy | 0a41749 | 2010-08-16 20:26:20 -0700 | [diff] [blame] | 2559 | case SkPaint::kCenter_Align: |
| 2560 | offsetX = underlineWidth * 0.5f; |
| 2561 | break; |
| 2562 | case SkPaint::kRight_Align: |
| 2563 | offsetX = underlineWidth; |
| 2564 | break; |
| 2565 | default: |
| 2566 | break; |
| 2567 | } |
| 2568 | |
Romain Guy | 211370f | 2012-02-01 16:10:55 -0800 | [diff] [blame] | 2569 | if (CC_LIKELY(underlineWidth > 0.0f)) { |
Romain Guy | 726aeba | 2011-06-01 14:52:00 -0700 | [diff] [blame] | 2570 | const float textSize = paintCopy.getTextSize(); |
Romain Guy | f683447 | 2011-01-23 13:32:12 -0800 | [diff] [blame] | 2571 | const float strokeWidth = fmax(textSize * kStdUnderline_Thickness, 1.0f); |
Romain Guy | 0a41749 | 2010-08-16 20:26:20 -0700 | [diff] [blame] | 2572 | |
Romain Guy | e20ecbd | 2010-09-22 19:49:04 -0700 | [diff] [blame] | 2573 | const float left = x - offsetX; |
Romain Guy | 0a41749 | 2010-08-16 20:26:20 -0700 | [diff] [blame] | 2574 | float top = 0.0f; |
Romain Guy | e20ecbd | 2010-09-22 19:49:04 -0700 | [diff] [blame] | 2575 | |
Romain Guy | f683447 | 2011-01-23 13:32:12 -0800 | [diff] [blame] | 2576 | int linesCount = 0; |
| 2577 | if (flags & SkPaint::kUnderlineText_Flag) linesCount++; |
| 2578 | if (flags & SkPaint::kStrikeThruText_Flag) linesCount++; |
| 2579 | |
| 2580 | const int pointsCount = 4 * linesCount; |
Romain Guy | e20ecbd | 2010-09-22 19:49:04 -0700 | [diff] [blame] | 2581 | float points[pointsCount]; |
| 2582 | int currentPoint = 0; |
Romain Guy | 0a41749 | 2010-08-16 20:26:20 -0700 | [diff] [blame] | 2583 | |
| 2584 | if (flags & SkPaint::kUnderlineText_Flag) { |
| 2585 | top = y + textSize * kStdUnderline_Offset; |
Romain Guy | e20ecbd | 2010-09-22 19:49:04 -0700 | [diff] [blame] | 2586 | points[currentPoint++] = left; |
| 2587 | points[currentPoint++] = top; |
| 2588 | points[currentPoint++] = left + underlineWidth; |
| 2589 | points[currentPoint++] = top; |
Romain Guy | 0a41749 | 2010-08-16 20:26:20 -0700 | [diff] [blame] | 2590 | } |
| 2591 | |
| 2592 | if (flags & SkPaint::kStrikeThruText_Flag) { |
| 2593 | top = y + textSize * kStdStrikeThru_Offset; |
Romain Guy | e20ecbd | 2010-09-22 19:49:04 -0700 | [diff] [blame] | 2594 | points[currentPoint++] = left; |
| 2595 | points[currentPoint++] = top; |
| 2596 | points[currentPoint++] = left + underlineWidth; |
| 2597 | points[currentPoint++] = top; |
Romain Guy | 0a41749 | 2010-08-16 20:26:20 -0700 | [diff] [blame] | 2598 | } |
Romain Guy | e20ecbd | 2010-09-22 19:49:04 -0700 | [diff] [blame] | 2599 | |
Romain Guy | 726aeba | 2011-06-01 14:52:00 -0700 | [diff] [blame] | 2600 | paintCopy.setStrokeWidth(strokeWidth); |
Romain Guy | e20ecbd | 2010-09-22 19:49:04 -0700 | [diff] [blame] | 2601 | |
Romain Guy | 726aeba | 2011-06-01 14:52:00 -0700 | [diff] [blame] | 2602 | drawLines(&points[0], pointsCount, &paintCopy); |
Romain Guy | 0a41749 | 2010-08-16 20:26:20 -0700 | [diff] [blame] | 2603 | } |
| 2604 | } |
| 2605 | } |
| 2606 | |
Romain Guy | 026c5e16 | 2010-06-28 17:12:22 -0700 | [diff] [blame] | 2607 | void OpenGLRenderer::drawColorRect(float left, float top, float right, float bottom, |
Romain Guy | 1c740bc | 2010-09-13 18:00:09 -0700 | [diff] [blame] | 2608 | int color, SkXfermode::Mode mode, bool ignoreTransform) { |
Romain Guy | d27977d | 2010-07-14 19:18:51 -0700 | [diff] [blame] | 2609 | // If a shader is set, preserve only the alpha |
Romain Guy | 06f96e2 | 2010-07-30 19:18:16 -0700 | [diff] [blame] | 2610 | if (mShader) { |
Romain Guy | d27977d | 2010-07-14 19:18:51 -0700 | [diff] [blame] | 2611 | color |= 0x00ffffff; |
| 2612 | } |
| 2613 | |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 2614 | setupDraw(); |
Romain Guy | 15bc643 | 2011-12-13 13:11:32 -0800 | [diff] [blame] | 2615 | setupDrawNoTexture(); |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 2616 | setupDrawColor(color); |
| 2617 | setupDrawShader(); |
| 2618 | setupDrawColorFilter(); |
| 2619 | setupDrawBlending(mode); |
| 2620 | setupDrawProgram(); |
| 2621 | setupDrawModelView(left, top, right, bottom, ignoreTransform); |
| 2622 | setupDrawColorUniforms(); |
| 2623 | setupDrawShaderUniforms(ignoreTransform); |
| 2624 | setupDrawColorFilterUniforms(); |
| 2625 | setupDrawSimpleMesh(); |
Romain Guy | c0ac193 | 2010-07-19 18:43:02 -0700 | [diff] [blame] | 2626 | |
Romain Guy | c95c8d6 | 2010-09-17 15:31:32 -0700 | [diff] [blame] | 2627 | glDrawArrays(GL_TRIANGLE_STRIP, 0, gMeshCount); |
| 2628 | } |
| 2629 | |
Romain Guy | 82ba814 | 2010-07-09 13:25:56 -0700 | [diff] [blame] | 2630 | void OpenGLRenderer::drawTextureRect(float left, float top, float right, float bottom, |
Romain Guy | 8164c2d | 2010-10-25 18:03:28 -0700 | [diff] [blame] | 2631 | Texture* texture, SkPaint* paint) { |
Romain Guy | 82ba814 | 2010-07-09 13:25:56 -0700 | [diff] [blame] | 2632 | int alpha; |
| 2633 | SkXfermode::Mode mode; |
| 2634 | getAlphaAndMode(paint, &alpha, &mode); |
| 2635 | |
Romain Guy | d21b6e1 | 2011-11-30 20:21:23 -0800 | [diff] [blame] | 2636 | texture->setWrap(GL_CLAMP_TO_EDGE, true); |
Romain Guy | 8164c2d | 2010-10-25 18:03:28 -0700 | [diff] [blame] | 2637 | |
Romain Guy | 211370f | 2012-02-01 16:10:55 -0800 | [diff] [blame] | 2638 | if (CC_LIKELY(mSnapshot->transform->isPureTranslate())) { |
Romain Guy | 6620c6d | 2010-12-06 18:07:02 -0800 | [diff] [blame] | 2639 | const float x = (int) floorf(left + mSnapshot->transform->getTranslateX() + 0.5f); |
| 2640 | const float y = (int) floorf(top + mSnapshot->transform->getTranslateY() + 0.5f); |
| 2641 | |
Romain Guy | d21b6e1 | 2011-11-30 20:21:23 -0800 | [diff] [blame] | 2642 | texture->setFilter(GL_NEAREST, true); |
Romain Guy | 6620c6d | 2010-12-06 18:07:02 -0800 | [diff] [blame] | 2643 | drawTextureMesh(x, y, x + texture->width, y + texture->height, texture->id, |
| 2644 | alpha / 255.0f, mode, texture->blend, (GLvoid*) NULL, |
| 2645 | (GLvoid*) gMeshTextureOffset, GL_TRIANGLE_STRIP, gMeshCount, false, true); |
| 2646 | } else { |
Romain Guy | d21b6e1 | 2011-11-30 20:21:23 -0800 | [diff] [blame] | 2647 | texture->setFilter(FILTER(paint), true); |
Romain Guy | 6620c6d | 2010-12-06 18:07:02 -0800 | [diff] [blame] | 2648 | drawTextureMesh(left, top, right, bottom, texture->id, alpha / 255.0f, mode, |
| 2649 | texture->blend, (GLvoid*) NULL, (GLvoid*) gMeshTextureOffset, |
| 2650 | GL_TRIANGLE_STRIP, gMeshCount); |
| 2651 | } |
Romain Guy | 85bf02f | 2010-06-22 13:11:24 -0700 | [diff] [blame] | 2652 | } |
| 2653 | |
Romain Guy | bd6b79b | 2010-06-26 00:13:53 -0700 | [diff] [blame] | 2654 | void OpenGLRenderer::drawTextureRect(float left, float top, float right, float bottom, |
Romain Guy | a979474 | 2010-07-13 11:37:54 -0700 | [diff] [blame] | 2655 | GLuint texture, float alpha, SkXfermode::Mode mode, bool blend) { |
| 2656 | drawTextureMesh(left, top, right, bottom, texture, alpha, mode, blend, |
Romain Guy | 03750a0 | 2010-10-18 14:06:08 -0700 | [diff] [blame] | 2657 | (GLvoid*) NULL, (GLvoid*) gMeshTextureOffset, GL_TRIANGLE_STRIP, gMeshCount); |
Romain Guy | f7f9355 | 2010-07-08 19:17:03 -0700 | [diff] [blame] | 2658 | } |
| 2659 | |
| 2660 | void OpenGLRenderer::drawTextureMesh(float left, float top, float right, float bottom, |
Romain Guy | a979474 | 2010-07-13 11:37:54 -0700 | [diff] [blame] | 2661 | GLuint texture, float alpha, SkXfermode::Mode mode, bool blend, |
Romain Guy | 6820ac8 | 2010-09-15 18:11:50 -0700 | [diff] [blame] | 2662 | GLvoid* vertices, GLvoid* texCoords, GLenum drawMode, GLsizei elementsCount, |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 2663 | bool swapSrcDst, bool ignoreTransform, GLuint vbo, bool ignoreScale, bool dirty) { |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 2664 | |
Romain Guy | 746b740 | 2010-10-26 16:27:31 -0700 | [diff] [blame] | 2665 | setupDraw(); |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 2666 | setupDrawWithTexture(); |
| 2667 | setupDrawColor(alpha, alpha, alpha, alpha); |
| 2668 | setupDrawColorFilter(); |
| 2669 | setupDrawBlending(blend, mode, swapSrcDst); |
| 2670 | setupDrawProgram(); |
| 2671 | if (!dirty) { |
| 2672 | setupDrawDirtyRegionsDisabled(); |
Romain Guy | db1938e | 2010-08-02 18:50:22 -0700 | [diff] [blame] | 2673 | } |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 2674 | if (!ignoreScale) { |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 2675 | setupDrawModelView(left, top, right, bottom, ignoreTransform); |
Romain Guy | f607bdc | 2010-09-10 19:20:06 -0700 | [diff] [blame] | 2676 | } else { |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 2677 | setupDrawModelViewTranslate(left, top, right, bottom, ignoreTransform); |
Romain Guy | f607bdc | 2010-09-10 19:20:06 -0700 | [diff] [blame] | 2678 | } |
Romain Guy | 8656819 | 2010-12-14 15:55:39 -0800 | [diff] [blame] | 2679 | setupDrawPureColorUniforms(); |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 2680 | setupDrawColorFilterUniforms(); |
| 2681 | setupDrawTexture(texture); |
| 2682 | setupDrawMesh(vertices, texCoords, vbo); |
Romain Guy | db1938e | 2010-08-02 18:50:22 -0700 | [diff] [blame] | 2683 | |
Romain Guy | 6820ac8 | 2010-09-15 18:11:50 -0700 | [diff] [blame] | 2684 | glDrawArrays(drawMode, 0, elementsCount); |
Romain Guy | 70ca14e | 2010-12-13 18:24:33 -0800 | [diff] [blame] | 2685 | |
| 2686 | finishDrawTexture(); |
Romain Guy | 82ba814 | 2010-07-09 13:25:56 -0700 | [diff] [blame] | 2687 | } |
| 2688 | |
Romain Guy | a5aed0d | 2010-09-09 14:42:43 -0700 | [diff] [blame] | 2689 | void OpenGLRenderer::chooseBlending(bool blend, SkXfermode::Mode mode, |
Romain Guy | f607bdc | 2010-09-10 19:20:06 -0700 | [diff] [blame] | 2690 | ProgramDescription& description, bool swapSrcDst) { |
Romain Guy | 82ba814 | 2010-07-09 13:25:56 -0700 | [diff] [blame] | 2691 | blend = blend || mode != SkXfermode::kSrcOver_Mode; |
| 2692 | if (blend) { |
Romain Guy | 82bc7a7 | 2012-01-03 14:13:39 -0800 | [diff] [blame] | 2693 | // These blend modes are not supported by OpenGL directly and have |
| 2694 | // to be implemented using shaders. Since the shader will perform |
| 2695 | // the blending, turn blending off here |
| 2696 | // If the blend mode cannot be implemented using shaders, fall |
| 2697 | // back to the default SrcOver blend mode instead |
Romain Guy | 211370f | 2012-02-01 16:10:55 -0800 | [diff] [blame] | 2698 | if CC_UNLIKELY((mode > SkXfermode::kScreen_Mode)) { |
| 2699 | if (CC_UNLIKELY(mCaches.extensions.hasFramebufferFetch())) { |
Romain Guy | a5aed0d | 2010-09-09 14:42:43 -0700 | [diff] [blame] | 2700 | description.framebufferMode = mode; |
Romain Guy | f607bdc | 2010-09-10 19:20:06 -0700 | [diff] [blame] | 2701 | description.swapSrcDst = swapSrcDst; |
Romain Guy | a5aed0d | 2010-09-09 14:42:43 -0700 | [diff] [blame] | 2702 | |
Romain Guy | 82bc7a7 | 2012-01-03 14:13:39 -0800 | [diff] [blame] | 2703 | if (mCaches.blend) { |
| 2704 | glDisable(GL_BLEND); |
| 2705 | mCaches.blend = false; |
| 2706 | } |
| 2707 | |
| 2708 | return; |
| 2709 | } else { |
| 2710 | mode = SkXfermode::kSrcOver_Mode; |
Romain Guy | a5aed0d | 2010-09-09 14:42:43 -0700 | [diff] [blame] | 2711 | } |
Romain Guy | 82bc7a7 | 2012-01-03 14:13:39 -0800 | [diff] [blame] | 2712 | } |
| 2713 | |
| 2714 | if (!mCaches.blend) { |
| 2715 | glEnable(GL_BLEND); |
| 2716 | } |
| 2717 | |
| 2718 | GLenum sourceMode = swapSrcDst ? gBlendsSwap[mode].src : gBlends[mode].src; |
| 2719 | GLenum destMode = swapSrcDst ? gBlendsSwap[mode].dst : gBlends[mode].dst; |
| 2720 | |
| 2721 | if (sourceMode != mCaches.lastSrcMode || destMode != mCaches.lastDstMode) { |
| 2722 | glBlendFunc(sourceMode, destMode); |
| 2723 | mCaches.lastSrcMode = sourceMode; |
| 2724 | mCaches.lastDstMode = destMode; |
Romain Guy | 82ba814 | 2010-07-09 13:25:56 -0700 | [diff] [blame] | 2725 | } |
Romain Guy | fb8b763 | 2010-08-23 21:05:08 -0700 | [diff] [blame] | 2726 | } else if (mCaches.blend) { |
Romain Guy | 82ba814 | 2010-07-09 13:25:56 -0700 | [diff] [blame] | 2727 | glDisable(GL_BLEND); |
| 2728 | } |
Romain Guy | fb8b763 | 2010-08-23 21:05:08 -0700 | [diff] [blame] | 2729 | mCaches.blend = blend; |
Romain Guy | bd6b79b | 2010-06-26 00:13:53 -0700 | [diff] [blame] | 2730 | } |
| 2731 | |
Romain Guy | 889f8d1 | 2010-07-29 14:37:42 -0700 | [diff] [blame] | 2732 | bool OpenGLRenderer::useProgram(Program* program) { |
Romain Guy | d27977d | 2010-07-14 19:18:51 -0700 | [diff] [blame] | 2733 | if (!program->isInUse()) { |
Romain Guy | fb8b763 | 2010-08-23 21:05:08 -0700 | [diff] [blame] | 2734 | if (mCaches.currentProgram != NULL) mCaches.currentProgram->remove(); |
Romain Guy | d27977d | 2010-07-14 19:18:51 -0700 | [diff] [blame] | 2735 | program->use(); |
Romain Guy | fb8b763 | 2010-08-23 21:05:08 -0700 | [diff] [blame] | 2736 | mCaches.currentProgram = program; |
Romain Guy | 6926c72 | 2010-07-12 20:20:03 -0700 | [diff] [blame] | 2737 | return false; |
Romain Guy | 260e102 | 2010-07-12 14:41:06 -0700 | [diff] [blame] | 2738 | } |
Romain Guy | 6926c72 | 2010-07-12 20:20:03 -0700 | [diff] [blame] | 2739 | return true; |
Romain Guy | 260e102 | 2010-07-12 14:41:06 -0700 | [diff] [blame] | 2740 | } |
| 2741 | |
Romain Guy | 026c5e16 | 2010-06-28 17:12:22 -0700 | [diff] [blame] | 2742 | void OpenGLRenderer::resetDrawTextureTexCoords(float u1, float v1, float u2, float v2) { |
Romain Guy | ac670c0 | 2010-07-27 17:39:27 -0700 | [diff] [blame] | 2743 | TextureVertex* v = &mMeshVertices[0]; |
Romain Guy | 82ba814 | 2010-07-09 13:25:56 -0700 | [diff] [blame] | 2744 | TextureVertex::setUV(v++, u1, v1); |
| 2745 | TextureVertex::setUV(v++, u2, v1); |
| 2746 | TextureVertex::setUV(v++, u1, v2); |
| 2747 | TextureVertex::setUV(v++, u2, v2); |
Romain Guy | 8ba548f | 2010-06-30 19:21:21 -0700 | [diff] [blame] | 2748 | } |
| 2749 | |
Chet Haase | 5c13d89 | 2010-10-08 08:37:55 -0700 | [diff] [blame] | 2750 | void OpenGLRenderer::getAlphaAndMode(SkPaint* paint, int* alpha, SkXfermode::Mode* mode) { |
Romain Guy | 8ba548f | 2010-06-30 19:21:21 -0700 | [diff] [blame] | 2751 | if (paint) { |
Romain Guy | 2ffefd4 | 2011-09-08 15:33:03 -0700 | [diff] [blame] | 2752 | *mode = getXfermode(paint->getXfermode()); |
Romain Guy | 8ba548f | 2010-06-30 19:21:21 -0700 | [diff] [blame] | 2753 | |
| 2754 | // Skia draws using the color's alpha channel if < 255 |
| 2755 | // Otherwise, it uses the paint's alpha |
| 2756 | int color = paint->getColor(); |
| 2757 | *alpha = (color >> 24) & 0xFF; |
| 2758 | if (*alpha == 255) { |
| 2759 | *alpha = paint->getAlpha(); |
| 2760 | } |
| 2761 | } else { |
| 2762 | *mode = SkXfermode::kSrcOver_Mode; |
| 2763 | *alpha = 255; |
| 2764 | } |
Romain Guy | 026c5e16 | 2010-06-28 17:12:22 -0700 | [diff] [blame] | 2765 | } |
| 2766 | |
Romain Guy | a5aed0d | 2010-09-09 14:42:43 -0700 | [diff] [blame] | 2767 | SkXfermode::Mode OpenGLRenderer::getXfermode(SkXfermode* mode) { |
Derek Sollenberger | d39d1af | 2011-05-16 13:09:42 -0400 | [diff] [blame] | 2768 | SkXfermode::Mode resultMode; |
| 2769 | if (!SkXfermode::AsMode(mode, &resultMode)) { |
| 2770 | resultMode = SkXfermode::kSrcOver_Mode; |
Romain Guy | a5aed0d | 2010-09-09 14:42:43 -0700 | [diff] [blame] | 2771 | } |
Derek Sollenberger | d39d1af | 2011-05-16 13:09:42 -0400 | [diff] [blame] | 2772 | return resultMode; |
Romain Guy | a5aed0d | 2010-09-09 14:42:43 -0700 | [diff] [blame] | 2773 | } |
| 2774 | |
Romain Guy | 9d5316e | 2010-06-24 19:30:36 -0700 | [diff] [blame] | 2775 | }; // namespace uirenderer |
Romain Guy | e4d0112 | 2010-06-16 18:44:05 -0700 | [diff] [blame] | 2776 | }; // namespace android |