epoger@google.com | ec3ed6a | 2011-07-28 14:26:00 +0000 | [diff] [blame] | 1 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 2 | /* |
epoger@google.com | ec3ed6a | 2011-07-28 14:26:00 +0000 | [diff] [blame] | 3 | * Copyright 2006 The Android Open Source Project |
| 4 | * |
| 5 | * Use of this source code is governed by a BSD-style license that can be |
| 6 | * found in the LICENSE file. |
| 7 | */ |
| 8 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 9 | |
| 10 | #include "SkNinePatch.h" |
| 11 | #include "SkCanvas.h" |
| 12 | #include "SkShader.h" |
| 13 | |
| 14 | static const uint16_t g3x3Indices[] = { |
| 15 | 0, 5, 1, 0, 4, 5, |
| 16 | 1, 6, 2, 1, 5, 6, |
| 17 | 2, 7, 3, 2, 6, 7, |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 18 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 19 | 4, 9, 5, 4, 8, 9, |
| 20 | 5, 10, 6, 5, 9, 10, |
| 21 | 6, 11, 7, 6, 10, 11, |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 22 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 23 | 8, 13, 9, 8, 12, 13, |
| 24 | 9, 14, 10, 9, 13, 14, |
| 25 | 10, 15, 11, 10, 14, 15 |
| 26 | }; |
| 27 | |
| 28 | static int fillIndices(uint16_t indices[], int xCount, int yCount) { |
| 29 | uint16_t* startIndices = indices; |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 30 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 31 | int n = 0; |
| 32 | for (int y = 0; y < yCount; y++) { |
| 33 | for (int x = 0; x < xCount; x++) { |
| 34 | *indices++ = n; |
| 35 | *indices++ = n + xCount + 2; |
| 36 | *indices++ = n + 1; |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 37 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 38 | *indices++ = n; |
| 39 | *indices++ = n + xCount + 1; |
| 40 | *indices++ = n + xCount + 2; |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 41 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 42 | n += 1; |
| 43 | } |
| 44 | n += 1; |
| 45 | } |
robertphillips@google.com | 8b16931 | 2013-10-15 17:47:36 +0000 | [diff] [blame] | 46 | return static_cast<int>(indices - startIndices); |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 47 | } |
| 48 | |
djsollen@google.com | 60abb07 | 2012-02-15 18:49:15 +0000 | [diff] [blame] | 49 | // Computes the delta between vertices along a single axis |
| 50 | static SkScalar computeVertexDelta(bool isStretchyVertex, |
| 51 | SkScalar currentVertex, |
| 52 | SkScalar prevVertex, |
| 53 | SkScalar stretchFactor) { |
| 54 | // the standard delta between vertices if no stretching is required |
| 55 | SkScalar delta = currentVertex - prevVertex; |
| 56 | |
| 57 | // if the stretch factor is negative or zero we need to shrink the 9-patch |
| 58 | // to fit within the target bounds. This means that we will eliminate all |
| 59 | // stretchy areas and scale the fixed areas to fit within the target bounds. |
| 60 | if (stretchFactor <= 0) { |
| 61 | if (isStretchyVertex) |
| 62 | delta = 0; // collapse stretchable areas |
| 63 | else |
| 64 | delta = SkScalarMul(delta, -stretchFactor); // scale fixed areas |
| 65 | // if the stretch factor is positive then we use the standard delta for |
| 66 | // fixed and scale the stretchable areas to fill the target bounds. |
| 67 | } else if (isStretchyVertex) { |
| 68 | delta = SkScalarMul(delta, stretchFactor); |
| 69 | } |
| 70 | |
| 71 | return delta; |
| 72 | } |
| 73 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 74 | static void fillRow(SkPoint verts[], SkPoint texs[], |
| 75 | const SkScalar vy, const SkScalar ty, |
| 76 | const SkRect& bounds, const int32_t xDivs[], int numXDivs, |
| 77 | const SkScalar stretchX, int width) { |
| 78 | SkScalar vx = bounds.fLeft; |
| 79 | verts->set(vx, vy); verts++; |
| 80 | texs->set(0, ty); texs++; |
djsollen@google.com | 60abb07 | 2012-02-15 18:49:15 +0000 | [diff] [blame] | 81 | |
| 82 | SkScalar prev = 0; |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 83 | for (int x = 0; x < numXDivs; x++) { |
djsollen@google.com | 60abb07 | 2012-02-15 18:49:15 +0000 | [diff] [blame] | 84 | |
| 85 | const SkScalar tx = SkIntToScalar(xDivs[x]); |
| 86 | vx += computeVertexDelta(x & 1, tx, prev, stretchX); |
| 87 | prev = tx; |
| 88 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 89 | verts->set(vx, vy); verts++; |
| 90 | texs->set(tx, ty); texs++; |
| 91 | } |
| 92 | verts->set(bounds.fRight, vy); verts++; |
| 93 | texs->set(SkIntToScalar(width), ty); texs++; |
| 94 | } |
| 95 | |
| 96 | struct Mesh { |
| 97 | const SkPoint* fVerts; |
| 98 | const SkPoint* fTexs; |
| 99 | const SkColor* fColors; |
| 100 | const uint16_t* fIndices; |
| 101 | }; |
| 102 | |
| 103 | void SkNinePatch::DrawMesh(SkCanvas* canvas, const SkRect& bounds, |
| 104 | const SkBitmap& bitmap, |
| 105 | const int32_t xDivs[], int numXDivs, |
| 106 | const int32_t yDivs[], int numYDivs, |
| 107 | const SkPaint* paint) { |
| 108 | if (bounds.isEmpty() || bitmap.width() == 0 || bitmap.height() == 0) { |
| 109 | return; |
| 110 | } |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 111 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 112 | // should try a quick-reject test before calling lockPixels |
| 113 | SkAutoLockPixels alp(bitmap); |
| 114 | // after the lock, it is valid to check |
| 115 | if (!bitmap.readyToDraw()) { |
| 116 | return; |
| 117 | } |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 118 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 119 | // check for degenerate divs (just an optimization, not required) |
| 120 | { |
| 121 | int i; |
| 122 | int zeros = 0; |
| 123 | for (i = 0; i < numYDivs && yDivs[i] == 0; i++) { |
| 124 | zeros += 1; |
| 125 | } |
| 126 | numYDivs -= zeros; |
| 127 | yDivs += zeros; |
| 128 | for (i = numYDivs - 1; i >= 0 && yDivs[i] == bitmap.height(); --i) { |
| 129 | numYDivs -= 1; |
| 130 | } |
| 131 | } |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 132 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 133 | Mesh mesh; |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 134 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 135 | const int numXStretch = (numXDivs + 1) >> 1; |
| 136 | const int numYStretch = (numYDivs + 1) >> 1; |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 137 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 138 | if (numXStretch < 1 && numYStretch < 1) { |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 139 | canvas->drawBitmapRect(bitmap, NULL, bounds, paint); |
| 140 | return; |
| 141 | } |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 142 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 143 | if (false) { |
| 144 | int i; |
| 145 | for (i = 0; i < numXDivs; i++) { |
| 146 | SkDebugf("--- xdivs[%d] %d\n", i, xDivs[i]); |
| 147 | } |
| 148 | for (i = 0; i < numYDivs; i++) { |
| 149 | SkDebugf("--- ydivs[%d] %d\n", i, yDivs[i]); |
| 150 | } |
| 151 | } |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 152 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 153 | SkScalar stretchX = 0, stretchY = 0; |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 154 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 155 | if (numXStretch > 0) { |
| 156 | int stretchSize = 0; |
| 157 | for (int i = 1; i < numXDivs; i += 2) { |
| 158 | stretchSize += xDivs[i] - xDivs[i-1]; |
| 159 | } |
djsollen@google.com | 60abb07 | 2012-02-15 18:49:15 +0000 | [diff] [blame] | 160 | const SkScalar fixed = SkIntToScalar(bitmap.width() - stretchSize); |
| 161 | if (bounds.width() >= fixed) |
| 162 | stretchX = (bounds.width() - fixed) / stretchSize; |
| 163 | else // reuse stretchX, but keep it negative as a signal |
| 164 | stretchX = SkScalarDiv(-bounds.width(), fixed); |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 165 | } |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 166 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 167 | if (numYStretch > 0) { |
| 168 | int stretchSize = 0; |
| 169 | for (int i = 1; i < numYDivs; i += 2) { |
| 170 | stretchSize += yDivs[i] - yDivs[i-1]; |
| 171 | } |
djsollen@google.com | 60abb07 | 2012-02-15 18:49:15 +0000 | [diff] [blame] | 172 | const SkScalar fixed = SkIntToScalar(bitmap.height() - stretchSize); |
| 173 | if (bounds.height() >= fixed) |
| 174 | stretchY = (bounds.height() - fixed) / stretchSize; |
| 175 | else // reuse stretchX, but keep it negative as a signal |
| 176 | stretchY = SkScalarDiv(-bounds.height(), fixed); |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 177 | } |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 178 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 179 | #if 0 |
| 180 | SkDebugf("---- drawasamesh [%d %d] -> [%g %g] <%d %d> (%g %g)\n", |
| 181 | bitmap.width(), bitmap.height(), |
| 182 | SkScalarToFloat(bounds.width()), SkScalarToFloat(bounds.height()), |
| 183 | numXDivs + 1, numYDivs + 1, |
| 184 | SkScalarToFloat(stretchX), SkScalarToFloat(stretchY)); |
| 185 | #endif |
| 186 | |
| 187 | const int vCount = (numXDivs + 2) * (numYDivs + 2); |
| 188 | // number of celss * 2 (tris per cell) * 3 (verts per tri) |
| 189 | const int indexCount = (numXDivs + 1) * (numYDivs + 1) * 2 * 3; |
| 190 | // allocate 2 times, one for verts, one for texs, plus indices |
| 191 | SkAutoMalloc storage(vCount * sizeof(SkPoint) * 2 + |
| 192 | indexCount * sizeof(uint16_t)); |
| 193 | SkPoint* verts = (SkPoint*)storage.get(); |
| 194 | SkPoint* texs = verts + vCount; |
| 195 | uint16_t* indices = (uint16_t*)(texs + vCount); |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 196 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 197 | mesh.fVerts = verts; |
| 198 | mesh.fTexs = texs; |
| 199 | mesh.fColors = NULL; |
| 200 | mesh.fIndices = NULL; |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 201 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 202 | // we use <= for YDivs, since the prebuild indices work for 3x2 and 3x1 too |
| 203 | if (numXDivs == 2 && numYDivs <= 2) { |
| 204 | mesh.fIndices = g3x3Indices; |
| 205 | } else { |
reed@android.com | 9781ca5 | 2009-04-14 14:28:22 +0000 | [diff] [blame] | 206 | SkDEBUGCODE(int n =) fillIndices(indices, numXDivs + 1, numYDivs + 1); |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 207 | SkASSERT(n == indexCount); |
| 208 | mesh.fIndices = indices; |
| 209 | } |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 210 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 211 | SkScalar vy = bounds.fTop; |
| 212 | fillRow(verts, texs, vy, 0, bounds, xDivs, numXDivs, |
| 213 | stretchX, bitmap.width()); |
| 214 | verts += numXDivs + 2; |
| 215 | texs += numXDivs + 2; |
| 216 | for (int y = 0; y < numYDivs; y++) { |
| 217 | const SkScalar ty = SkIntToScalar(yDivs[y]); |
reed@google.com | ade907b | 2011-09-28 12:33:41 +0000 | [diff] [blame] | 218 | if (stretchY >= 0) { |
| 219 | if (y & 1) { |
| 220 | vy += stretchY; |
| 221 | } else { |
| 222 | vy += ty; |
| 223 | } |
| 224 | } else { // shrink fixed sections, and collaps stretchy sections |
| 225 | if (y & 1) { |
| 226 | ;// do nothing |
| 227 | } else { |
| 228 | vy += SkScalarMul(ty, -stretchY); |
| 229 | } |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 230 | } |
| 231 | fillRow(verts, texs, vy, ty, bounds, xDivs, numXDivs, |
| 232 | stretchX, bitmap.width()); |
| 233 | verts += numXDivs + 2; |
| 234 | texs += numXDivs + 2; |
| 235 | } |
| 236 | fillRow(verts, texs, bounds.fBottom, SkIntToScalar(bitmap.height()), |
| 237 | bounds, xDivs, numXDivs, stretchX, bitmap.width()); |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 238 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 239 | SkShader* shader = SkShader::CreateBitmapShader(bitmap, |
| 240 | SkShader::kClamp_TileMode, |
| 241 | SkShader::kClamp_TileMode); |
| 242 | SkPaint p; |
| 243 | if (paint) { |
| 244 | p = *paint; |
| 245 | } |
| 246 | p.setShader(shader)->unref(); |
| 247 | canvas->drawVertices(SkCanvas::kTriangles_VertexMode, vCount, |
| 248 | mesh.fVerts, mesh.fTexs, mesh.fColors, NULL, |
| 249 | mesh.fIndices, indexCount, p); |
| 250 | } |
| 251 | |
| 252 | /////////////////////////////////////////////////////////////////////////////// |
| 253 | |
| 254 | static void drawNineViaRects(SkCanvas* canvas, const SkRect& dst, |
| 255 | const SkBitmap& bitmap, const SkIRect& margins, |
| 256 | const SkPaint* paint) { |
| 257 | const int32_t srcX[4] = { |
| 258 | 0, margins.fLeft, bitmap.width() - margins.fRight, bitmap.width() |
| 259 | }; |
| 260 | const int32_t srcY[4] = { |
| 261 | 0, margins.fTop, bitmap.height() - margins.fBottom, bitmap.height() |
| 262 | }; |
djsollen@google.com | 57f4969 | 2011-02-23 20:46:31 +0000 | [diff] [blame] | 263 | SkScalar dstX[4] = { |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 264 | dst.fLeft, dst.fLeft + SkIntToScalar(margins.fLeft), |
| 265 | dst.fRight - SkIntToScalar(margins.fRight), dst.fRight |
| 266 | }; |
djsollen@google.com | 57f4969 | 2011-02-23 20:46:31 +0000 | [diff] [blame] | 267 | SkScalar dstY[4] = { |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 268 | dst.fTop, dst.fTop + SkIntToScalar(margins.fTop), |
| 269 | dst.fBottom - SkIntToScalar(margins.fBottom), dst.fBottom |
| 270 | }; |
djsollen@google.com | 57f4969 | 2011-02-23 20:46:31 +0000 | [diff] [blame] | 271 | |
| 272 | if (dstX[1] > dstX[2]) { |
| 273 | dstX[1] = dstX[0] + (dstX[3] - dstX[0]) * SkIntToScalar(margins.fLeft) / |
| 274 | (SkIntToScalar(margins.fLeft) + SkIntToScalar(margins.fRight)); |
| 275 | dstX[2] = dstX[1]; |
| 276 | } |
| 277 | |
| 278 | if (dstY[1] > dstY[2]) { |
| 279 | dstY[1] = dstY[0] + (dstY[3] - dstY[0]) * SkIntToScalar(margins.fTop) / |
| 280 | (SkIntToScalar(margins.fTop) + SkIntToScalar(margins.fBottom)); |
| 281 | dstY[2] = dstY[1]; |
| 282 | } |
| 283 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 284 | SkIRect s; |
| 285 | SkRect d; |
| 286 | for (int y = 0; y < 3; y++) { |
| 287 | s.fTop = srcY[y]; |
| 288 | s.fBottom = srcY[y+1]; |
| 289 | d.fTop = dstY[y]; |
| 290 | d.fBottom = dstY[y+1]; |
| 291 | for (int x = 0; x < 3; x++) { |
| 292 | s.fLeft = srcX[x]; |
| 293 | s.fRight = srcX[x+1]; |
| 294 | d.fLeft = dstX[x]; |
| 295 | d.fRight = dstX[x+1]; |
| 296 | canvas->drawBitmapRect(bitmap, &s, d, paint); |
| 297 | } |
| 298 | } |
| 299 | } |
| 300 | |
| 301 | void SkNinePatch::DrawNine(SkCanvas* canvas, const SkRect& bounds, |
| 302 | const SkBitmap& bitmap, const SkIRect& margins, |
| 303 | const SkPaint* paint) { |
| 304 | /** Our vertices code has numerical precision problems if the transformed |
| 305 | coordinates land directly on a 1/2 pixel boundary. To work around that |
| 306 | for now, we only take the vertices case if we are in opengl. Also, |
| 307 | when not in GL, the vertices impl is slower (more math) than calling |
| 308 | the viaRects code. |
| 309 | */ |
reed@google.com | 3048d4f | 2011-05-04 13:50:34 +0000 | [diff] [blame] | 310 | if (false /* is our canvas backed by a gpu?*/) { |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 311 | int32_t xDivs[2]; |
| 312 | int32_t yDivs[2]; |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 313 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 314 | xDivs[0] = margins.fLeft; |
| 315 | xDivs[1] = bitmap.width() - margins.fRight; |
| 316 | yDivs[0] = margins.fTop; |
| 317 | yDivs[1] = bitmap.height() - margins.fBottom; |
djsollen@google.com | 57f4969 | 2011-02-23 20:46:31 +0000 | [diff] [blame] | 318 | |
| 319 | if (xDivs[0] > xDivs[1]) { |
| 320 | xDivs[0] = bitmap.width() * margins.fLeft / |
| 321 | (margins.fLeft + margins.fRight); |
| 322 | xDivs[1] = xDivs[0]; |
| 323 | } |
| 324 | if (yDivs[0] > yDivs[1]) { |
| 325 | yDivs[0] = bitmap.height() * margins.fTop / |
| 326 | (margins.fTop + margins.fBottom); |
| 327 | yDivs[1] = yDivs[0]; |
| 328 | } |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 329 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 330 | SkNinePatch::DrawMesh(canvas, bounds, bitmap, |
| 331 | xDivs, 2, yDivs, 2, paint); |
| 332 | } else { |
| 333 | drawNineViaRects(canvas, bounds, bitmap, margins, paint); |
| 334 | } |
| 335 | } |