Snapshot.h revision 678ff81105753656aa4822f4f675ef96dc9d2b83
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 17#ifndef ANDROID_HWUI_SNAPSHOT_H 18#define ANDROID_HWUI_SNAPSHOT_H 19 20#include <GLES2/gl2.h> 21#include <GLES2/gl2ext.h> 22 23#include <utils/LinearAllocator.h> 24#include <utils/RefBase.h> 25#include <ui/Region.h> 26 27#include <SkRegion.h> 28 29#include "ClipArea.h" 30#include "Layer.h" 31#include "Matrix.h" 32#include "Outline.h" 33#include "Rect.h" 34#include "utils/Macros.h" 35 36namespace android { 37namespace uirenderer { 38 39/** 40 * Temporary structure holding information for a single outline clip. 41 * 42 * These structures are treated as immutable once created, and only exist for a single frame, which 43 * is why they may only be allocated with a LinearAllocator. 44 */ 45class RoundRectClipState { 46public: 47 static void* operator new(size_t size) = delete; 48 static void* operator new(size_t size, LinearAllocator& allocator) { 49 return allocator.alloc<RoundRectClipState>(size); 50 } 51 52 bool areaRequiresRoundRectClip(const Rect& rect) const { 53 return rect.intersects(dangerRects[0]) 54 || rect.intersects(dangerRects[1]) 55 || rect.intersects(dangerRects[2]) 56 || rect.intersects(dangerRects[3]); 57 } 58 59 bool highPriority; 60 Matrix4 matrix; 61 Rect dangerRects[4]; 62 Rect innerRect; 63 float radius; 64}; 65 66// TODO: remove for HWUI_NEW_OPS 67class ProjectionPathMask { 68public: 69 static void* operator new(size_t size) = delete; 70 static void* operator new(size_t size, LinearAllocator& allocator) { 71 return allocator.alloc<ProjectionPathMask>(size); 72 } 73 74 const SkPath* projectionMask; 75 Matrix4 projectionMaskTransform; 76}; 77 78/** 79 * A snapshot holds information about the current state of the rendering 80 * surface. A snapshot is usually created whenever the user calls save() 81 * and discarded when the user calls restore(). Once a snapshot is created, 82 * it can hold information for deferred rendering. 83 * 84 * Each snapshot has a link to a previous snapshot, indicating the previous 85 * state of the renderer. 86 */ 87class Snapshot { 88public: 89 90 Snapshot(); 91 Snapshot(Snapshot* s, int saveFlags); 92 93 /** 94 * Various flags set on ::flags. 95 */ 96 enum Flags { 97 /** 98 * Indicates that the clip region was modified. When this 99 * snapshot is restored so must the clip. 100 */ 101 kFlagClipSet = 0x1, 102 /** 103 * Indicates that this snapshot was created when saving 104 * a new layer. 105 */ 106 kFlagIsLayer = 0x2, 107 /** 108 * Indicates that this snapshot is a special type of layer 109 * backed by an FBO. This flag only makes sense when the 110 * flag kFlagIsLayer is also set. 111 * 112 * Viewport has been modified to fit the new Fbo, and must be 113 * restored when this snapshot is restored. 114 */ 115 kFlagIsFboLayer = 0x4, 116 /** 117 * Indicates that this snapshot or an ancestor snapshot is 118 * an FBO layer. 119 */ 120 kFlagFboTarget = 0x8, // TODO: remove for HWUI_NEW_OPS 121 }; 122 123 /** 124 * Modifies the current clip with the new clip rectangle and 125 * the specified operation. The specified rectangle is transformed 126 * by this snapshot's trasnformation. 127 */ 128 void clip(const Rect& localClip, SkRegion::Op op); 129 130 /** 131 * Modifies the current clip with the new clip rectangle and 132 * the specified operation. The specified rectangle is considered 133 * already transformed. 134 */ 135 void clipTransformed(const Rect& r, SkRegion::Op op = SkRegion::kIntersect_Op); 136 137 /** 138 * Modifies the current clip with the specified region and operation. 139 * The specified region is considered already transformed. 140 */ 141 void clipRegionTransformed(const SkRegion& region, SkRegion::Op op); 142 143 /** 144 * Modifies the current clip with the specified path and operation. 145 */ 146 void clipPath(const SkPath& path, SkRegion::Op op); 147 148 /** 149 * Sets the current clip. 150 */ 151 void setClip(float left, float top, float right, float bottom); 152 153 /** 154 * Returns the current clip in local coordinates. The clip rect is 155 * transformed by the inverse transform matrix. 156 */ 157 ANDROID_API const Rect& getLocalClip(); 158 159 /** 160 * Returns the current clip in render target coordinates. 161 */ 162 const Rect& getRenderTargetClip() const { return mClipArea->getClipRect(); } 163 164 /* 165 * Accessor functions so that the clip area can stay private 166 */ 167 bool clipIsEmpty() const { return mClipArea->isEmpty(); } 168 const SkRegion& getClipRegion() const { return mClipArea->getClipRegion(); } 169 bool clipIsSimple() const { return mClipArea->isSimple(); } 170 const ClipArea& getClipArea() const { return *mClipArea; } 171 ClipArea& mutateClipArea() { return *mClipArea; } 172 173 /** 174 * Resets the clip to the specified rect. 175 */ 176 void resetClip(float left, float top, float right, float bottom); 177 178 /** 179 * Resets the current transform to a pure 3D translation. 180 */ 181 void resetTransform(float x, float y, float z); 182 183 void initializeViewport(int width, int height) { 184 mViewportData.initialize(width, height); 185 mClipAreaRoot.setViewportDimensions(width, height); 186 } 187 188 int getViewportWidth() const { return mViewportData.mWidth; } 189 int getViewportHeight() const { return mViewportData.mHeight; } 190 const Matrix4& getOrthoMatrix() const { return mViewportData.mOrthoMatrix; } 191 192 const Vector3& getRelativeLightCenter() const { return mRelativeLightCenter; } 193 void setRelativeLightCenter(const Vector3& lightCenter) { mRelativeLightCenter = lightCenter; } 194 195 /** 196 * Sets (and replaces) the current clipping outline 197 * 198 * If the current round rect clip is high priority, the incoming clip is ignored. 199 */ 200 void setClippingRoundRect(LinearAllocator& allocator, const Rect& bounds, 201 float radius, bool highPriority); 202 203 /** 204 * Sets (and replaces) the current projection mask 205 */ 206 void setProjectionPathMask(LinearAllocator& allocator, const SkPath* path); 207 208 /** 209 * Indicates whether this snapshot should be ignored. A snapshot 210 * is typically ignored if its layer is invisible or empty. 211 */ 212 bool isIgnored() const; 213 214 /** 215 * Indicates whether the current transform has perspective components. 216 */ 217 bool hasPerspectiveTransform() const; 218 219 /** 220 * Fills outTransform with the current, total transform to screen space, 221 * across layer boundaries. 222 */ 223 // TODO: remove for HWUI_NEW_OPS 224 void buildScreenSpaceTransform(Matrix4* outTransform) const; 225 226 /** 227 * Dirty flags. 228 */ 229 int flags; 230 231 /** 232 * Previous snapshot. 233 */ 234 Snapshot* previous; 235 236 /** 237 * A pointer to the currently active layer. 238 * 239 * This snapshot does not own the layer, this pointer must not be freed. 240 */ 241 Layer* layer; 242 243 /** 244 * Target FBO used for rendering. Set to 0 when rendering directly 245 * into the framebuffer. 246 */ 247 GLuint fbo; 248 249 /** 250 * Indicates that this snapshot is invisible and nothing should be drawn 251 * inside it. This flag is set only when the layer clips drawing to its 252 * bounds and is passed to subsequent snapshots. 253 */ 254 bool invisible; 255 256 /** 257 * If set to true, the layer will not be composited. This is similar to 258 * invisible but this flag is not passed to subsequent snapshots. 259 */ 260 bool empty; 261 262 /** 263 * Local transformation. Holds the current translation, scale and 264 * rotation values. 265 * 266 * This is a reference to a matrix owned by this snapshot or another 267 * snapshot. This pointer must not be freed. See ::mTransformRoot. 268 */ 269 mat4* transform; 270 271 /** 272 * The ancestor layer's dirty region. 273 * 274 * This is a reference to a region owned by a layer. This pointer must 275 * not be freed. 276 */ 277 Region* region; 278 279 /** 280 * Current alpha value. This value is 1 by default, but may be set by a DisplayList which 281 * has translucent rendering in a non-overlapping View. This value will be used by 282 * the renderer to set the alpha in the current color being used for ensuing drawing 283 * operations. The value is inherited by child snapshots because the same value should 284 * be applied to descendants of the current DisplayList (for example, a TextView contains 285 * the base alpha value which should be applied to the child DisplayLists used for drawing 286 * the actual text). 287 */ 288 float alpha; 289 290 /** 291 * Current clipping round rect. 292 * 293 * Points to data not owned by the snapshot, and may only be replaced by subsequent RR clips, 294 * never modified. 295 */ 296 const RoundRectClipState* roundRectClipState; 297 298 /** 299 * Current projection masking path - used exclusively to mask projected, tessellated circles. 300 */ 301#if HWUI_NEW_OPS 302 const SkPath* projectionPathMask; 303#else 304 const ProjectionPathMask* projectionPathMask; 305#endif 306 307 void dump() const; 308 309private: 310 struct ViewportData { 311 ViewportData() : mWidth(0), mHeight(0) {} 312 void initialize(int width, int height) { 313 mWidth = width; 314 mHeight = height; 315 mOrthoMatrix.loadOrtho(0, width, height, 0, -1, 1); 316 } 317 318 /* 319 * Width and height of current viewport. 320 * 321 * The viewport is always defined to be (0, 0, width, height). 322 */ 323 int mWidth; 324 int mHeight; 325 /** 326 * Contains the current orthographic, projection matrix. 327 */ 328 mat4 mOrthoMatrix; 329 }; 330 331 mat4 mTransformRoot; 332 333 ClipArea mClipAreaRoot; 334 ClipArea* mClipArea; 335 Rect mLocalClip; 336 337 ViewportData mViewportData; 338 Vector3 mRelativeLightCenter; 339 340}; // class Snapshot 341 342}; // namespace uirenderer 343}; // namespace android 344 345#endif // ANDROID_HWUI_SNAPSHOT_H 346