Home | History | Annotate | Download | only in hwui 
      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 #pragma once
     18 
     19 #include "Snapshot.h"
     20 
     21 #include <SkClipOp.h>
     22 #include <SkMatrix.h>
     23 #include <SkPath.h>
     24 #include <SkRegion.h>
     25 
     26 namespace android {
     27 namespace uirenderer {
     28 
     29 /**
     30  * Abstract base class for any class containing CanvasState.
     31  * Defines three mandatory callbacks.
     32  */
     33 class CanvasStateClient {
     34 public:
     35     CanvasStateClient() {}
     36     virtual ~CanvasStateClient() {}
     37 
     38     /**
     39      * Callback allowing embedder to take actions in the middle of a
     40      * setViewport() call.
     41      */
     42     virtual void onViewportInitialized() = 0;
     43 
     44     /**
     45      * Callback allowing embedder to take actions in the middle of a
     46      * restore() call.  May be called several times sequentially.
     47      */
     48     virtual void onSnapshotRestored(const Snapshot& removed, const Snapshot& restored) = 0;
     49 
     50     /**
     51      * Allows subclasses to control what value is stored in snapshot's
     52      * fbo field in * initializeSaveStack.
     53      */
     54     virtual GLuint getTargetFbo() const = 0;
     55 
     56 };  // class CanvasStateClient
     57 
     58 /**
     59  * Implements Canvas state methods on behalf of Renderers.
     60  *
     61  * Manages the Snapshot stack, implementing matrix, save/restore, and clipping methods in the
     62  * Renderer interface. Drawing and recording classes that include a CanvasState will have
     63  * different use cases:
     64  *
     65  * Drawing code maintaining canvas state (e.g. FrameBuilder) can query attributes (such as
     66  * transform) or hook into changes (e.g. save/restore) with minimal surface area for manipulating
     67  * the stack itself.
     68  *
     69  * Recording code maintaining canvas state (e.g. RecordingCanvas) can both record and pass
     70  * through state operations to CanvasState, so that not only will querying operations work
     71  * (getClip/Matrix), but so that quickRejection can also be used.
     72  */
     73 
     74 class CanvasState {
     75 public:
     76     explicit CanvasState(CanvasStateClient& renderer);
     77     ~CanvasState();
     78 
     79     /**
     80      * Initializes the first snapshot, computing the projection matrix,
     81      * and stores the dimensions of the render target.
     82      */
     83     void initializeRecordingSaveStack(int viewportWidth, int viewportHeight);
     84 
     85     /**
     86      * Initializes the first snapshot, computing the projection matrix,
     87      * and stores the dimensions of the render target.
     88      */
     89     void initializeSaveStack(int viewportWidth, int viewportHeight, float clipLeft, float clipTop,
     90                              float clipRight, float clipBottom, const Vector3& lightCenter);
     91 
     92     bool hasRectToRectTransform() const { return CC_LIKELY(currentTransform()->rectToRect()); }
     93 
     94     // Save (layer)
     95     int getSaveCount() const { return mSaveCount; }
     96     int save(int flags);
     97     void restore();
     98     void restoreToCount(int saveCount);
     99 
    100     // Save/Restore without side-effects
    101     int saveSnapshot(int flags);
    102     void restoreSnapshot();
    103 
    104     // Matrix
    105     void getMatrix(SkMatrix* outMatrix) const;
    106     void translate(float dx, float dy, float dz = 0.0f);
    107     void rotate(float degrees);
    108     void scale(float sx, float sy);
    109     void skew(float sx, float sy);
    110 
    111     void setMatrix(const SkMatrix& matrix);
    112     void setMatrix(const Matrix4& matrix);  // internal only convenience method
    113     void concatMatrix(const SkMatrix& matrix);
    114     void concatMatrix(const Matrix4& matrix);  // internal only convenience method
    115 
    116     // Clip
    117     const Rect& getLocalClipBounds() const { return mSnapshot->getLocalClip(); }
    118     const Rect& getRenderTargetClipBounds() const { return mSnapshot->getRenderTargetClip(); }
    119 
    120     bool quickRejectConservative(float left, float top, float right, float bottom) const;
    121 
    122     bool clipRect(float left, float top, float right, float bottom, SkClipOp op);
    123     bool clipPath(const SkPath* path, SkClipOp op);
    124 
    125     /**
    126      * Sets a "clipping outline", which is independent from the regular clip.
    127      * Currently only supports rectangles or rounded rectangles; passing in a
    128      * more complicated outline fails silently. Replaces any previous clipping
    129      * outline.
    130      */
    131     void setClippingOutline(LinearAllocator& allocator, const Outline* outline);
    132     void setClippingRoundRect(LinearAllocator& allocator, const Rect& rect, float radius,
    133                               bool highPriority = true) {
    134         mSnapshot->setClippingRoundRect(allocator, rect, radius, highPriority);
    135     }
    136     void setProjectionPathMask(const SkPath* path) { mSnapshot->setProjectionPathMask(path); }
    137 
    138     /**
    139      * Returns true if drawing in the rectangle (left, top, right, bottom)
    140      * will be clipped out. Is conservative: might return false when subpixel-
    141      * perfect tests would return true.
    142      */
    143     bool calculateQuickRejectForScissor(float left, float top, float right, float bottom,
    144                                         bool* clipRequired, bool* roundRectClipRequired,
    145                                         bool snapOut) const;
    146 
    147     void scaleAlpha(float alpha) { mSnapshot->alpha *= alpha; }
    148 
    149     inline const mat4* currentTransform() const { return currentSnapshot()->transform; }
    150     inline const Rect& currentRenderTargetClip() const {
    151         return currentSnapshot()->getRenderTargetClip();
    152     }
    153     inline int currentFlags() const { return currentSnapshot()->flags; }
    154     const Vector3& currentLightCenter() const {
    155         return currentSnapshot()->getRelativeLightCenter();
    156     }
    157     int getViewportWidth() const { return currentSnapshot()->getViewportWidth(); }
    158     int getViewportHeight() const { return currentSnapshot()->getViewportHeight(); }
    159     int getWidth() const { return mWidth; }
    160     int getHeight() const { return mHeight; }
    161     bool clipIsSimple() const { return currentSnapshot()->clipIsSimple(); }
    162 
    163     inline const Snapshot* currentSnapshot() const { return mSnapshot; }
    164     inline Snapshot* writableSnapshot() { return mSnapshot; }
    165     inline const Snapshot* firstSnapshot() const { return &mFirstSnapshot; }
    166 
    167 private:
    168     Snapshot* allocSnapshot(Snapshot* previous, int savecount);
    169     void freeSnapshot(Snapshot* snapshot);
    170     void freeAllSnapshots();
    171 
    172     /// Dimensions of the drawing surface
    173     int mWidth, mHeight;
    174 
    175     /// Number of saved states
    176     int mSaveCount;
    177 
    178     /// Base state
    179     Snapshot mFirstSnapshot;
    180 
    181     /// Host providing callbacks
    182     CanvasStateClient& mCanvas;
    183 
    184     /// Current state
    185     Snapshot* mSnapshot;
    186 
    187     // Pool of allocated snapshots to re-use
    188     // NOTE: The dtors have already been invoked!
    189     Snapshot* mSnapshotPool = nullptr;
    190     int mSnapshotPoolCount = 0;
    191 
    192 };  // class CanvasState
    193 
    194 };  // namespace uirenderer
    195 };  // namespace android
    196