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 #ifndef ANDROID_HWUI_STATEFUL_BASE_RENDERER_H 18 #define ANDROID_HWUI_STATEFUL_BASE_RENDERER_H 19 20 #include <utils/RefBase.h> 21 22 #include "Renderer.h" 23 #include "Snapshot.h" 24 25 namespace android { 26 namespace uirenderer { 27 28 /** 29 * Abstract Renderer subclass, which implements Canvas state methods. 30 * 31 * Manages the Snapshot stack, implementing matrix, save/restore, and clipping methods in the 32 * Renderer interface. Drawing and recording classes that extend StatefulBaseRenderer will have 33 * different use cases: 34 * 35 * Drawing subclasses (i.e. OpenGLRenderer) can query attributes (such as transform) or hook into 36 * changes (e.g. save/restore) with minimal surface area for manipulating the stack itself. 37 * 38 * Recording subclasses (i.e. DisplayListRenderer) can both record and pass through state operations 39 * to StatefulBaseRenderer, so that not only will querying operations work (getClip/Matrix), but so 40 * that quickRejection can also be used. 41 */ 42 class StatefulBaseRenderer : public Renderer { 43 public: 44 StatefulBaseRenderer(); 45 46 virtual status_t prepare(bool opaque) { 47 return prepareDirty(0.0f, 0.0f, mWidth, mHeight, opaque); 48 } 49 50 /** 51 * Initialize the first snapshot, computing the projection matrix, and stores the dimensions of 52 * the render target. 53 */ 54 virtual void setViewport(int width, int height); 55 void initializeSaveStack(float clipLeft, float clipTop, float clipRight, float clipBottom, 56 const Vector3& lightCenter); 57 58 // getters 59 bool hasRectToRectTransform() const { 60 return CC_LIKELY(currentTransform()->rectToRect()); 61 } 62 63 // Save (layer) 64 virtual int getSaveCount() const { return mSaveCount; } 65 virtual int save(int flags); 66 virtual void restore(); 67 virtual void restoreToCount(int saveCount); 68 //virtual int saveLayer(float left, float top, float right, float bottom, 69 // int alpha, SkXfermode::Mode mode, int flags); 70 71 // Matrix 72 virtual void getMatrix(SkMatrix* outMatrix) const; 73 virtual void translate(float dx, float dy, float dz = 0.0f); 74 virtual void rotate(float degrees); 75 virtual void scale(float sx, float sy); 76 virtual void skew(float sx, float sy); 77 78 virtual void setMatrix(const SkMatrix& matrix); 79 void setMatrix(const Matrix4& matrix); // internal only convenience method 80 virtual void concatMatrix(const SkMatrix& matrix); 81 void concatMatrix(const Matrix4& matrix); // internal only convenience method 82 83 // Clip 84 virtual const Rect& getLocalClipBounds() const { return mSnapshot->getLocalClip(); } 85 86 virtual bool quickRejectConservative(float left, float top, float right, float bottom) const; 87 88 virtual bool clipRect(float left, float top, float right, float bottom, SkRegion::Op op); 89 virtual bool clipPath(const SkPath* path, SkRegion::Op op); 90 virtual bool clipRegion(const SkRegion* region, SkRegion::Op op); 91 92 /** 93 * Does not support different clipping Ops (that is, every call to setClippingOutline is 94 * effectively using SkRegion::kReplaceOp) 95 * 96 * The clipping outline is independent from the regular clip. 97 */ 98 void setClippingOutline(LinearAllocator& allocator, const Outline* outline); 99 void setClippingRoundRect(LinearAllocator& allocator, 100 const Rect& rect, float radius, bool highPriority = true); 101 102 inline const mat4* currentTransform() const { 103 return mSnapshot->transform; 104 } 105 106 protected: 107 const Rect& getRenderTargetClipBounds() const { return mSnapshot->getRenderTargetClip(); } 108 109 int getWidth() { return mWidth; } 110 int getHeight() { return mHeight; } 111 112 // Save 113 int saveSnapshot(int flags); 114 void restoreSnapshot(); 115 116 // allows subclasses to control what value is stored in snapshot's fbo field in 117 // initializeSaveStack 118 virtual GLuint getTargetFbo() const { 119 return -1; 120 } 121 122 // Clip 123 bool calculateQuickRejectForScissor(float left, float top, float right, float bottom, 124 bool* clipRequired, bool* roundRectClipRequired, bool snapOut) const; 125 126 /** 127 * Called just after a restore has occurred. The 'removed' snapshot popped from the stack, 128 * 'restored' snapshot has become the top/current. 129 * 130 * Subclasses can override this method to handle layer restoration 131 */ 132 virtual void onSnapshotRestored(const Snapshot& removed, const Snapshot& restored) {}; 133 134 virtual void onViewportInitialized() {}; 135 136 inline const Rect* currentClipRect() const { 137 return mSnapshot->clipRect; 138 } 139 140 inline const Snapshot* currentSnapshot() const { 141 return mSnapshot != NULL ? mSnapshot.get() : mFirstSnapshot.get(); 142 } 143 144 inline const Snapshot* firstSnapshot() const { 145 return mFirstSnapshot.get(); 146 } 147 148 // indicites that the clip has been changed since the last time it was consumed 149 bool mDirtyClip; 150 151 private: 152 // Dimensions of the drawing surface 153 int mWidth, mHeight; 154 155 // Number of saved states 156 int mSaveCount; 157 158 // Base state 159 sp<Snapshot> mFirstSnapshot; 160 161 protected: 162 // Current state 163 // TODO: should become private, once hooks needed by OpenGLRenderer are added 164 sp<Snapshot> mSnapshot; 165 }; // class StatefulBaseRenderer 166 167 }; // namespace uirenderer 168 }; // namespace android 169 170 #endif // ANDROID_HWUI_STATEFUL_BASE_RENDERER_H 171
