CanvasState.cpp revision 69e5adffb19135d51bde8e458f4907d7265f3e23
1/* 2 * Copyright (C) 2014 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 17#define LOG_TAG "OpenGLRenderer" 18 19#include <SkCanvas.h> 20 21#include "StatefulBaseRenderer.h" 22 23#include "utils/MathUtils.h" 24 25namespace android { 26namespace uirenderer { 27 28StatefulBaseRenderer::StatefulBaseRenderer() 29 : mDirtyClip(false) 30 , mWidth(-1) 31 , mHeight(-1) 32 , mSaveCount(1) 33 , mFirstSnapshot(new Snapshot) 34 , mSnapshot(mFirstSnapshot) { 35} 36 37void StatefulBaseRenderer::initializeSaveStack(float clipLeft, float clipTop, 38 float clipRight, float clipBottom, const Vector3& lightCenter) { 39 mSnapshot = new Snapshot(mFirstSnapshot, 40 SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag); 41 mSnapshot->setClip(clipLeft, clipTop, clipRight, clipBottom); 42 mSnapshot->fbo = getTargetFbo(); 43 mSnapshot->setRelativeLightCenter(lightCenter); 44 mSaveCount = 1; 45} 46 47void StatefulBaseRenderer::setViewport(int width, int height) { 48 mWidth = width; 49 mHeight = height; 50 mFirstSnapshot->initializeViewport(width, height); 51 onViewportInitialized(); 52} 53 54/////////////////////////////////////////////////////////////////////////////// 55// Save (layer) 56/////////////////////////////////////////////////////////////////////////////// 57 58/** 59 * Non-virtual implementation of save, guaranteed to save without side-effects 60 * 61 * The approach here and in restoreSnapshot(), allows subclasses to directly manipulate the save 62 * stack, and ensures restoreToCount() doesn't call back into subclass overrides. 63 */ 64int StatefulBaseRenderer::saveSnapshot(int flags) { 65 mSnapshot = new Snapshot(mSnapshot, flags); 66 return mSaveCount++; 67} 68 69int StatefulBaseRenderer::save(int flags) { 70 return saveSnapshot(flags); 71} 72 73/** 74 * Non-virtual implementation of restore, guaranteed to restore without side-effects. 75 */ 76void StatefulBaseRenderer::restoreSnapshot() { 77 sp<Snapshot> toRemove = mSnapshot; 78 sp<Snapshot> toRestore = mSnapshot->previous; 79 80 mSaveCount--; 81 mSnapshot = toRestore; 82 83 // subclass handles restore implementation 84 onSnapshotRestored(*toRemove, *toRestore); 85} 86 87void StatefulBaseRenderer::restore() { 88 if (mSaveCount > 1) { 89 restoreSnapshot(); 90 } 91} 92 93void StatefulBaseRenderer::restoreToCount(int saveCount) { 94 if (saveCount < 1) saveCount = 1; 95 96 while (mSaveCount > saveCount) { 97 restoreSnapshot(); 98 } 99} 100 101/////////////////////////////////////////////////////////////////////////////// 102// Matrix 103/////////////////////////////////////////////////////////////////////////////// 104 105void StatefulBaseRenderer::getMatrix(Matrix4* matrix) const { 106 matrix->load(*(mSnapshot->transform)); 107} 108 109void StatefulBaseRenderer::getMatrix(SkMatrix* matrix) const { 110 mSnapshot->transform->copyTo(*matrix); 111} 112 113void StatefulBaseRenderer::translate(float dx, float dy, float dz) { 114 mSnapshot->transform->translate(dx, dy, dz); 115} 116 117void StatefulBaseRenderer::rotate(float degrees) { 118 mSnapshot->transform->rotate(degrees, 0.0f, 0.0f, 1.0f); 119} 120 121void StatefulBaseRenderer::scale(float sx, float sy) { 122 mSnapshot->transform->scale(sx, sy, 1.0f); 123} 124 125void StatefulBaseRenderer::skew(float sx, float sy) { 126 mSnapshot->transform->skew(sx, sy); 127} 128 129void StatefulBaseRenderer::setMatrix(const SkMatrix& matrix) { 130 mSnapshot->transform->load(matrix); 131} 132 133void StatefulBaseRenderer::setMatrix(const Matrix4& matrix) { 134 mSnapshot->transform->load(matrix); 135} 136 137void StatefulBaseRenderer::concatMatrix(const SkMatrix& matrix) { 138 mat4 transform(matrix); 139 mSnapshot->transform->multiply(transform); 140} 141 142void StatefulBaseRenderer::concatMatrix(const Matrix4& matrix) { 143 mSnapshot->transform->multiply(matrix); 144} 145 146/////////////////////////////////////////////////////////////////////////////// 147// Clip 148/////////////////////////////////////////////////////////////////////////////// 149 150bool StatefulBaseRenderer::clipRect(float left, float top, float right, float bottom, SkRegion::Op op) { 151 if (CC_LIKELY(currentTransform()->rectToRect())) { 152 mDirtyClip |= mSnapshot->clip(left, top, right, bottom, op); 153 return !mSnapshot->clipRect->isEmpty(); 154 } 155 156 SkPath path; 157 path.addRect(left, top, right, bottom); 158 159 return StatefulBaseRenderer::clipPath(&path, op); 160} 161 162bool StatefulBaseRenderer::clipPath(const SkPath* path, SkRegion::Op op) { 163 SkMatrix transform; 164 currentTransform()->copyTo(transform); 165 166 SkPath transformed; 167 path->transform(transform, &transformed); 168 169 SkRegion clip; 170 if (!mSnapshot->previous->clipRegion->isEmpty()) { 171 clip.setRegion(*mSnapshot->previous->clipRegion); 172 } else { 173 if (mSnapshot->previous == firstSnapshot()) { 174 clip.setRect(0, 0, getWidth(), getHeight()); 175 } else { 176 Rect* bounds = mSnapshot->previous->clipRect; 177 clip.setRect(bounds->left, bounds->top, bounds->right, bounds->bottom); 178 } 179 } 180 181 SkRegion region; 182 region.setPath(transformed, clip); 183 184 // region is the transformed input path, masked by the previous clip 185 mDirtyClip |= mSnapshot->clipRegionTransformed(region, op); 186 return !mSnapshot->clipRect->isEmpty(); 187} 188 189bool StatefulBaseRenderer::clipRegion(const SkRegion* region, SkRegion::Op op) { 190 mDirtyClip |= mSnapshot->clipRegionTransformed(*region, op); 191 return !mSnapshot->clipRect->isEmpty(); 192} 193 194void StatefulBaseRenderer::setClippingOutline(LinearAllocator& allocator, const Outline* outline) { 195 Rect bounds; 196 float radius; 197 if (!outline->getAsRoundRect(&bounds, &radius)) return; // only RR supported 198 199 if (!MathUtils::isPositive(radius)) { 200 // TODO: consider storing this rect separately, so that this can't be replaced with clip ops 201 clipRect(bounds.left, bounds.top, bounds.right, bounds.bottom, SkRegion::kIntersect_Op); 202 return; 203 } 204 setClippingRoundRect(allocator, bounds, radius); 205} 206 207void StatefulBaseRenderer::setClippingRoundRect(LinearAllocator& allocator, 208 const Rect& rect, float radius) { 209 mSnapshot->setClippingRoundRect(allocator, rect, radius); 210} 211 212 213/////////////////////////////////////////////////////////////////////////////// 214// Quick Rejection 215/////////////////////////////////////////////////////////////////////////////// 216 217/** 218 * Calculates whether content drawn within the passed bounds would be outside of, or intersect with 219 * the clipRect. Does not modify the scissor. 220 * 221 * @param clipRequired if not null, will be set to true if element intersects clip 222 * (and wasn't rejected) 223 * 224 * @param snapOut if set, the geometry will be treated as having an AA ramp. 225 * See Rect::snapGeometryToPixelBoundaries() 226 */ 227bool StatefulBaseRenderer::calculateQuickRejectForScissor(float left, float top, 228 float right, float bottom, 229 bool* clipRequired, bool* roundRectClipRequired, 230 bool snapOut) const { 231 if (mSnapshot->isIgnored() || bottom <= top || right <= left) { 232 return true; 233 } 234 235 Rect r(left, top, right, bottom); 236 currentTransform()->mapRect(r); 237 r.snapGeometryToPixelBoundaries(snapOut); 238 239 Rect clipRect(*currentClipRect()); 240 clipRect.snapToPixelBoundaries(); 241 242 if (!clipRect.intersects(r)) return true; 243 244 // clip is required if geometry intersects clip rect 245 if (clipRequired) { 246 *clipRequired = !clipRect.contains(r); 247 } 248 249 // round rect clip is required if RR clip exists, and geometry intersects its corners 250 if (roundRectClipRequired) { 251 *roundRectClipRequired = mSnapshot->roundRectClipState != NULL 252 && mSnapshot->roundRectClipState->areaRequiresRoundRectClip(r); 253 } 254 return false; 255} 256 257/** 258 * Returns false if drawing won't be clipped out. 259 * 260 * Makes the decision conservatively, by rounding out the mapped rect before comparing with the 261 * clipRect. To be used when perfect, pixel accuracy is not possible (esp. with tessellation) but 262 * rejection is still desired. 263 * 264 * This function, unlike quickRejectSetupScissor, should be used where precise geometry information 265 * isn't known (esp. when geometry adjusts based on scale). Generally, this will be first pass 266 * rejection where precise rejection isn't important, or precise information isn't available. 267 */ 268bool StatefulBaseRenderer::quickRejectConservative(float left, float top, 269 float right, float bottom) const { 270 if (mSnapshot->isIgnored() || bottom <= top || right <= left) { 271 return true; 272 } 273 274 Rect r(left, top, right, bottom); 275 currentTransform()->mapRect(r); 276 r.roundOut(); // rounded out to be conservative 277 278 Rect clipRect(*currentClipRect()); 279 clipRect.snapToPixelBoundaries(); 280 281 if (!clipRect.intersects(r)) return true; 282 283 return false; 284} 285 286}; // namespace uirenderer 287}; // namespace android 288