src/core/SkMatrixClipStateMgr.h

/*
 * Copyright 2014 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
#ifndef SkMatrixClipStateMgr_DEFINED
#define SkMatrixClipStateMgr_DEFINED

#include "SkCanvas.h"
#include "SkMatrix.h"
#include "SkRegion.h"
#include "SkRRect.h"
#include "SkTypes.h"
#include "SkTArray.h"

class SkPictureRecord;
class SkWriter32;

// The SkMatrixClipStateMgr collapses the matrix/clip state of an SkPicture into
// a series of save/restore blocks of consistent matrix clip state, e.g.:
//
//   save
//     clip(s)
//     concat
//     ... draw ops ...
//   restore
//
// SaveLayers simply add another level, e.g.:
//
//   save
//     clip(s)
//     concat
//     ... draw ops ...
//     saveLayer
//       save
//         clip(s)
//         concat
//         ... draw ops ...
//       restore
//     restore
//   restore
//
// As a side effect of this process all saves and saveLayers will become
// kMatrixClip_SaveFlag style saves/saveLayers.

// The SkMatrixClipStateMgr works by intercepting all the save*, restore, clip*,
// and matrix calls sent to SkCanvas in order to track the current matrix/clip
// state. All the other canvas calls get funnelled into a generic "call" entry
// point that signals that a state block is required.
class SkMatrixClipStateMgr {
public:
    static const int32_t kIdentityWideOpenStateID = 0;

    class MatrixClipState {
    public:
        class MatrixInfo {
        public:
            SkMatrix fMatrix;
            // TODO: add an internal dictionary and an ID here
        };

        class ClipInfo : public SkNoncopyable {
        public:
            ClipInfo() {}

            bool clipRect(const SkRect& rect,
                          SkRegion::Op op,
                          bool doAA,
                          const SkMatrix& matrix) {
                ClipOp& newClip = fClips.push_back();
                newClip.fClipType = kRect_ClipType;
                newClip.fGeom.fRRect.setRect(rect);   // storing the clipRect in the RRect
                newClip.fOp = op;
                newClip.fDoAA = doAA;
                newClip.fMatrix = matrix;
                newClip.fOffset = kInvalidJumpOffset;
                return false;
            }

            bool clipRRect(const SkRRect& rrect,
                           SkRegion::Op op,
                           bool doAA,
                           const SkMatrix& matrix) {
                ClipOp& newClip = fClips.push_back();
                newClip.fClipType = kRRect_ClipType;
                newClip.fGeom.fRRect = rrect;
                newClip.fOp = op;
                newClip.fDoAA = doAA;
                newClip.fMatrix = matrix;
                newClip.fOffset = kInvalidJumpOffset;
                return false;
            }

            bool clipPath(SkPictureRecord* picRecord,
                          const SkPath& path,
                          SkRegion::Op op,
                          bool doAA,
                          const SkMatrix& matrix);
            bool clipRegion(SkPictureRecord* picRecord,
                            const SkRegion& region,
                            SkRegion::Op op,
                            const SkMatrix& matrix);
            void writeClip(SkMatrix* curMat,
                           SkPictureRecord* picRecord,
                           bool* overrideFirstOp);
            void fillInSkips(SkWriter32* writer, int32_t restoreOffset);

#ifdef SK_DEBUG
            void checkOffsetNotEqual(int32_t offset) {
                for (int i = 0; i < fClips.count(); ++i) {
                    ClipOp& curClip = fClips[i];
                    SkASSERT(offset != curClip.fOffset);
                }
            }
#endif
        private:
            enum ClipType {
                kRect_ClipType,
                kRRect_ClipType,
                kPath_ClipType,
                kRegion_ClipType
            };

            static const int kInvalidJumpOffset = -1;

            class ClipOp {
            public:
                ClipOp() {}
                ~ClipOp() {
                    if (kRegion_ClipType == fClipType) {
                        SkDELETE(fGeom.fRegion);
                    }
                }

                ClipType     fClipType;

                union {
                    SkRRect         fRRect;        // also stores clipRect
                    int             fPathID;
                    // TODO: add internal dictionary of regions
                    // This parameter forces us to have a dtor and thus use
                    // SkTArray rather then SkTDArray!
                    const SkRegion* fRegion;
                } fGeom;

                bool         fDoAA;
                SkRegion::Op fOp;

                // The CTM in effect when this clip call was issued
                // TODO: add an internal dictionary and replace with ID
                SkMatrix     fMatrix;

                // The offset of this clipOp's "jump-to-offset" location in the skp.
                // -1 means the offset hasn't been written.
                int32_t      fOffset;
            };

            SkTArray<ClipOp> fClips;

            typedef SkNoncopyable INHERITED;
        };

        MatrixClipState(MatrixClipState* prev, int flags)
#ifdef SK_DEBUG
            : fPrev(prev)
#endif
        {
            if (NULL == prev) {
                fLayerID = 0;

                fMatrixInfoStorage.fMatrix.reset();
                fMatrixInfo = &fMatrixInfoStorage;
                fClipInfo = &fClipInfoStorage;  // ctor handles init of fClipInfoStorage

                // The identity/wide-open-clip state is current by default
                fMCStateID = kIdentityWideOpenStateID;
            }
            else {
                fLayerID = prev->fLayerID;

                if (flags & SkCanvas::kMatrix_SaveFlag) {
                    fMatrixInfoStorage = *prev->fMatrixInfo;
                    fMatrixInfo = &fMatrixInfoStorage;
                } else {
                    fMatrixInfo = prev->fMatrixInfo;
                }

                if (flags & SkCanvas::kClip_SaveFlag) {
                    // We don't copy the ClipOps of the previous clip states
                    fClipInfo = &fClipInfoStorage;
                } else {
                    fClipInfo = prev->fClipInfo;
                }

                // Initially a new save/saveLayer represents the same MC state
                // as its predecessor.
                fMCStateID = prev->fMCStateID;
            }

            fIsSaveLayer = false;
        }

        MatrixInfo*  fMatrixInfo;
        MatrixInfo   fMatrixInfoStorage;

        ClipInfo*    fClipInfo;
        ClipInfo     fClipInfoStorage;

        // Tracks the current depth of saveLayers to support the isDrawingToLayer call
        int          fLayerID;
        // Does this MC state represent a saveLayer call?
        bool         fIsSaveLayer;

        // The next two fields are only valid when fIsSaveLayer is set.
        int32_t      fSaveLayerBaseStateID;
        bool         fSaveLayerBracketed;

#ifdef SK_DEBUG
        MatrixClipState* fPrev; // debugging aid
#endif

        int32_t     fMCStateID;
    };

    enum CallType {
        kMatrix_CallType,
        kClip_CallType,
        kOther_CallType
    };

    SkMatrixClipStateMgr();

    void init(SkPictureRecord* picRecord) {
        // Note: we're not taking a ref here. It is expected that the SkMatrixClipStateMgr
        // is owned by the SkPictureRecord object
        fPicRecord = picRecord;
    }

    // TODO: need to override canvas' getSaveCount. Right now we pass the
    // save* and restore calls on to the base SkCanvas in SkPictureRecord but
    // this duplicates effort.
    int getSaveCount() const { return fMatrixClipStack.count(); }

    int save(SkCanvas::SaveFlags flags);

    int saveLayer(const SkRect* bounds, const SkPaint* paint, SkCanvas::SaveFlags flags);

    bool isDrawingToLayer() const {
        return fCurMCState->fLayerID > 0;
    }

    void restore();

    bool translate(SkScalar dx, SkScalar dy) {
        this->call(kMatrix_CallType);
        return fCurMCState->fMatrixInfo->fMatrix.preTranslate(dx, dy);
    }

    bool scale(SkScalar sx, SkScalar sy) {
        this->call(kMatrix_CallType);
        return fCurMCState->fMatrixInfo->fMatrix.preScale(sx, sy);
    }

    bool rotate(SkScalar degrees) {
        this->call(kMatrix_CallType);
        return fCurMCState->fMatrixInfo->fMatrix.preRotate(degrees);
    }

    bool skew(SkScalar sx, SkScalar sy) {
        this->call(kMatrix_CallType);
        return fCurMCState->fMatrixInfo->fMatrix.preSkew(sx, sy);
    }

    bool concat(const SkMatrix& matrix) {
        this->call(kMatrix_CallType);
        return fCurMCState->fMatrixInfo->fMatrix.preConcat(matrix);
    }

    void setMatrix(const SkMatrix& matrix) {
        this->call(kMatrix_CallType);
        fCurMCState->fMatrixInfo->fMatrix = matrix;
    }

    bool clipRect(const SkRect& rect, SkRegion::Op op, bool doAA) {
        this->call(SkMatrixClipStateMgr::kClip_CallType);
        return fCurMCState->fClipInfo->clipRect(rect, op, doAA,
                                                fCurMCState->fMatrixInfo->fMatrix);
    }

    bool clipRRect(const SkRRect& rrect, SkRegion::Op op, bool doAA) {
        this->call(SkMatrixClipStateMgr::kClip_CallType);
        return fCurMCState->fClipInfo->clipRRect(rrect, op, doAA,
                                                 fCurMCState->fMatrixInfo->fMatrix);
    }

    bool clipPath(const SkPath& path, SkRegion::Op op, bool doAA) {
        this->call(SkMatrixClipStateMgr::kClip_CallType);
        return fCurMCState->fClipInfo->clipPath(fPicRecord, path, op, doAA,
                                                fCurMCState->fMatrixInfo->fMatrix);
    }

    bool clipRegion(const SkRegion& region, SkRegion::Op op) {
        this->call(SkMatrixClipStateMgr::kClip_CallType);
        return fCurMCState->fClipInfo->clipRegion(fPicRecord, region, op,
                                                  fCurMCState->fMatrixInfo->fMatrix);
    }

    bool call(CallType callType);

    void fillInSkips(SkWriter32* writer, int32_t restoreOffset) {
        // Since we write out the entire clip stack at each block start we
        // need to update the skips for the entire stack each time too.
        SkDeque::F2BIter iter(fMatrixClipStack);

        for (const MatrixClipState* state = (const MatrixClipState*) iter.next();
             state != NULL;
             state = (const MatrixClipState*) iter.next()) {
            state->fClipInfo->fillInSkips(writer, restoreOffset);
        }
    }

    void finish();

protected:
    SkPictureRecord* fPicRecord;

    uint32_t         fMatrixClipStackStorage[43]; // sized to fit 2 clip states
    SkDeque          fMatrixClipStack;
    MatrixClipState* fCurMCState;

    // The MCStateID of the state currently in effect in the byte stream. 0 if none.
    int32_t          fCurOpenStateID;

    SkDEBUGCODE(void validate();)

    static void WriteDeltaMat(SkPictureRecord* picRecord,
                              const SkMatrix& current,
                              const SkMatrix& desired);
    static int32_t   NewMCStateID();
};

#endif