#ifndef SkPictureRecorder_DEFINED
#define SkPictureRecorder_DEFINED
-#include "../../src/core/SkMiniRecorder.h"
+#include "../private/SkMiniRecorder.h"
#include "SkBBHFactory.h"
#include "SkPicture.h"
#include "SkRefCnt.h"
#define SkGLContext_DEFINED
#include "GrGLInterface.h"
-#include "../../src/gpu/SkGpuFenceSync.h"
+#include "../private/SkGpuFenceSync.h"
/**
* Create an offscreen opengl context with an RGBA8 / 8bit stencil FBO.
class SK_API SkGLContext : public SkRefCnt {
public:
-
+
~SkGLContext() override;
--- /dev/null
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkFunction_DEFINED
+#define SkFunction_DEFINED
+
+// TODO: document, more pervasive move support in constructors, small-Fn optimization
+
+#include "SkTemplates.h"
+#include "SkTypes.h"
+
+template <typename> class SkFunction;
+
+template <typename R, typename... Args>
+class SkFunction<R(Args...)> {
+public:
+ SkFunction() {}
+
+ template <typename Fn>
+ SkFunction(const Fn& fn) : fFunction(SkNEW_ARGS(LambdaImpl<Fn>, (fn))) {}
+
+ SkFunction(R (*fn)(Args...)) : fFunction(SkNEW_ARGS(FnPtrImpl, (fn))) {}
+
+ SkFunction(const SkFunction& other) { *this = other; }
+ SkFunction& operator=(const SkFunction& other) {
+ if (this != &other) {
+ fFunction.reset(other.fFunction ? other.fFunction->clone() : nullptr);
+ }
+ return *this;
+ }
+
+ R operator()(Args... args) const {
+ SkASSERT(fFunction.get());
+ return fFunction->call(Forward(args)...);
+ }
+
+private:
+ // ~= std::forward. This moves its argument if possible, falling back to a copy if not.
+ template <typename T> static T&& Forward(T& v) { return (T&&)v; }
+
+ struct Interface {
+ virtual ~Interface() {}
+ virtual R call(Args...) const = 0;
+ virtual Interface* clone() const = 0;
+ };
+
+ template <typename Fn>
+ class LambdaImpl final : public Interface {
+ public:
+ LambdaImpl(const Fn& fn) : fFn(fn) {}
+
+ R call(Args... args) const override { return fFn(Forward(args)...); }
+ Interface* clone() const override { return SkNEW_ARGS(LambdaImpl<Fn>, (fFn)); }
+ private:
+ Fn fFn;
+ };
+
+ class FnPtrImpl final : public Interface {
+ public:
+ FnPtrImpl(R (*fn)(Args...)) : fFn(fn) {}
+
+ R call(Args... args) const override { return fFn(Forward(args)...); }
+ Interface* clone() const override { return SkNEW_ARGS(FnPtrImpl, (fFn)); }
+ private:
+ R (*fFn)(Args...);
+ };
+
+ SkAutoTDelete<Interface> fFunction;
+};
+
+#endif//SkFunction_DEFINED
--- /dev/null
+
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef SkGpuFenceSync_DEFINED
+#define SkGpuFenceSync_DEFINED
+
+#include "SkTypes.h"
+
+typedef void* SkPlatformGpuFence;
+
+/*
+ * This class provides an interface to interact with fence syncs. A fence sync is an object that the
+ * client can insert into the GPU command stream, and then at any future time, wait until all
+ * commands that were issued before the fence have completed.
+ */
+class SkGpuFenceSync {
+public:
+ virtual SkPlatformGpuFence SK_WARN_UNUSED_RESULT insertFence() const = 0;
+ virtual bool flushAndWaitFence(SkPlatformGpuFence) const = 0;
+ virtual void deleteFence(SkPlatformGpuFence) const = 0;
+
+ virtual ~SkGpuFenceSync() {}
+};
+
+#endif
--- /dev/null
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkMiniRecorder_DEFINED
+#define SkMiniRecorder_DEFINED
+
+#include "SkRecords.h"
+#include "SkScalar.h"
+#include "SkTypes.h"
+class SkCanvas;
+
+// Records small pictures, but only a limited subset of the canvas API, and may fail.
+class SkMiniRecorder : SkNoncopyable {
+public:
+ SkMiniRecorder();
+ ~SkMiniRecorder();
+
+ // Try to record an op. Returns false on failure.
+ bool drawBitmapRect(const SkBitmap&, const SkRect* src, const SkRect& dst,
+ const SkPaint*, SkCanvas::SrcRectConstraint);
+ bool drawPath(const SkPath&, const SkPaint&);
+ bool drawRect(const SkRect&, const SkPaint&);
+ bool drawTextBlob(const SkTextBlob*, SkScalar x, SkScalar y, const SkPaint&);
+
+ // Detach anything we've recorded as a picture, resetting this SkMiniRecorder.
+ SkPicture* detachAsPicture(const SkRect& cull);
+
+ // Flush anything we've recorded to the canvas, resetting this SkMiniRecorder.
+ // This is logically the same as but rather more efficient than:
+ // SkAutoTUnref<SkPicture> pic(this->detachAsPicture(SkRect::MakeEmpty()));
+ // pic->playback(canvas);
+ void flushAndReset(SkCanvas*);
+
+private:
+ enum class State {
+ kEmpty,
+ kDrawBitmapRectFixedSize,
+ kDrawPath,
+ kDrawRect,
+ kDrawTextBlob,
+ };
+
+ State fState;
+
+ template <size_t A, size_t B>
+ struct Max { static const size_t val = A > B ? A : B; };
+
+ static const size_t kInlineStorage =
+ Max<sizeof(SkRecords::DrawBitmapRectFixedSize),
+ Max<sizeof(SkRecords::DrawPath),
+ Max<sizeof(SkRecords::DrawRect),
+ sizeof(SkRecords::DrawTextBlob)>::val>::val>::val;
+ SkAlignedSStorage<kInlineStorage> fBuffer;
+};
+
+#endif//SkMiniRecorder_DEFINED
--- /dev/null
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkPathPriv_DEFINED
+#define SkPathPriv_DEFINED
+
+#include "SkPath.h"
+
+class SkPathPriv {
+public:
+ enum FirstDirection {
+ kCW_FirstDirection, // == SkPath::kCW_Direction
+ kCCW_FirstDirection, // == SkPath::kCCW_Direction
+ kUnknown_FirstDirection,
+ };
+
+ static FirstDirection AsFirstDirection(SkPath::Direction dir) {
+ // since we agree numerically for the values in Direction, we can just cast.
+ return (FirstDirection)dir;
+ }
+
+ /**
+ * Return the opposite of the specified direction. kUnknown is its own
+ * opposite.
+ */
+ static FirstDirection OppositeFirstDirection(FirstDirection dir) {
+ static const FirstDirection gOppositeDir[] = {
+ kCCW_FirstDirection, kCW_FirstDirection, kUnknown_FirstDirection,
+ };
+ return gOppositeDir[dir];
+ }
+
+ /**
+ * Tries to quickly compute the direction of the first non-degenerate
+ * contour. If it can be computed, return true and set dir to that
+ * direction. If it cannot be (quickly) determined, return false and ignore
+ * the dir parameter. If the direction was determined, it is cached to make
+ * subsequent calls return quickly.
+ */
+ static bool CheapComputeFirstDirection(const SkPath&, FirstDirection* dir);
+
+ /**
+ * Returns true if the path's direction can be computed via
+ * cheapComputDirection() and if that computed direction matches the
+ * specified direction. If dir is kUnknown, returns true if the direction
+ * cannot be computed.
+ */
+ static bool CheapIsFirstDirection(const SkPath& path, FirstDirection dir) {
+ FirstDirection computedDir = kUnknown_FirstDirection;
+ (void)CheapComputeFirstDirection(path, &computedDir);
+ return computedDir == dir;
+ }
+
+ static bool LastVerbIsClose(const SkPath& path) {
+ int count = path.countVerbs();
+ return count >= 1 && path.fPathRef->verbs()[~(count - 1)] == SkPath::Verb::kClose_Verb;
+ }
+};
+
+#endif
--- /dev/null
+/*
+ * 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 SkRecords_DEFINED
+#define SkRecords_DEFINED
+
+#include "SkCanvas.h"
+#include "SkDrawable.h"
+#include "SkMatrix.h"
+#include "SkPathPriv.h"
+#include "SkPicture.h"
+#include "SkRSXform.h"
+#include "SkTextBlob.h"
+
+namespace SkRecords {
+
+// A list of all the types of canvas calls we can record.
+// Each of these is reified into a struct below.
+//
+// (We're using the macro-of-macro trick here to do several different things with the same list.)
+//
+// We leave this SK_RECORD_TYPES macro defined for use by code that wants to operate on SkRecords
+// types polymorphically. (See SkRecord::Record::{visit,mutate} for an example.)
+//
+// Order doesn't technically matter here, but the compiler can generally generate better code if
+// you keep them semantically grouped, especially the Draws. It's also nice to leave NoOp at 0.
+#define SK_RECORD_TYPES(M) \
+ M(NoOp) \
+ M(Restore) \
+ M(Save) \
+ M(SaveLayer) \
+ M(SetMatrix) \
+ M(ClipPath) \
+ M(ClipRRect) \
+ M(ClipRect) \
+ M(ClipRegion) \
+ M(DrawBitmap) \
+ M(DrawBitmapNine) \
+ M(DrawBitmapRect) \
+ M(DrawBitmapRectFast) \
+ M(DrawBitmapRectFixedSize) \
+ M(DrawDrawable) \
+ M(DrawImage) \
+ M(DrawImageRect) \
+ M(DrawImageNine) \
+ M(DrawDRRect) \
+ M(DrawOval) \
+ M(DrawPaint) \
+ M(DrawPath) \
+ M(DrawPatch) \
+ M(DrawPicture) \
+ M(DrawPoints) \
+ M(DrawPosText) \
+ M(DrawPosTextH) \
+ M(DrawText) \
+ M(DrawTextOnPath) \
+ M(DrawRRect) \
+ M(DrawRect) \
+ M(DrawSprite) \
+ M(DrawTextBlob) \
+ M(DrawAtlas) \
+ M(DrawVertices)
+
+// Defines SkRecords::Type, an enum of all record types.
+#define ENUM(T) T##_Type,
+enum Type { SK_RECORD_TYPES(ENUM) };
+#undef ENUM
+
+// Macros to make it easier to define a record for a draw call with 0 args, 1 args, 2 args, etc.
+// These should be clearer when you look at their use below.
+#define RECORD0(T) \
+struct T { \
+ static const Type kType = T##_Type; \
+};
+
+// Instead of requring the exact type A here, we take any type Z which implicitly casts to A.
+// This lets our wrappers like ImmutableBitmap work seamlessly.
+
+#define RECORD1(T, A, a) \
+struct T { \
+ static const Type kType = T##_Type; \
+ T() {} \
+ template <typename Z> \
+ T(const Z& a) : a(a) {} \
+ A a; \
+};
+
+#define RECORD2(T, A, a, B, b) \
+struct T { \
+ static const Type kType = T##_Type; \
+ T() {} \
+ template <typename Z, typename Y> \
+ T(const Z& a, const Y& b) : a(a), b(b) {} \
+ A a; B b; \
+};
+
+#define RECORD3(T, A, a, B, b, C, c) \
+struct T { \
+ static const Type kType = T##_Type; \
+ T() {} \
+ template <typename Z, typename Y, typename X> \
+ T(const Z& a, const Y& b, const X& c) : a(a), b(b), c(c) {} \
+ A a; B b; C c; \
+};
+
+#define RECORD4(T, A, a, B, b, C, c, D, d) \
+struct T { \
+ static const Type kType = T##_Type; \
+ T() {} \
+ template <typename Z, typename Y, typename X, typename W> \
+ T(const Z& a, const Y& b, const X& c, const W& d) : a(a), b(b), c(c), d(d) {} \
+ A a; B b; C c; D d; \
+};
+
+#define RECORD5(T, A, a, B, b, C, c, D, d, E, e) \
+struct T { \
+ static const Type kType = T##_Type; \
+ T() {} \
+ template <typename Z, typename Y, typename X, typename W, typename V> \
+ T(const Z& a, const Y& b, const X& c, const W& d, const V& e) \
+ : a(a), b(b), c(c), d(d), e(e) {} \
+ A a; B b; C c; D d; E e; \
+};
+
+#define RECORD8(T, A, a, B, b, C, c, D, d, E, e, F, f, G, g, H, h) \
+struct T { \
+ static const Type kType = T##_Type; \
+ T() {} \
+ template <typename Z, typename Y, typename X, typename W, \
+ typename V, typename U, typename S, typename R> \
+ T(const Z& a, const Y& b, const X& c, const W& d, \
+ const V& e, const U& f, const S& g, const R& h) \
+ : a(a), b(b), c(c), d(d), e(e), f(f), g(g), h(h) {} \
+ A a; B b; C c; D d; E e; F f; G g; H h; \
+};
+
+#define ACT_AS_PTR(ptr) \
+ operator T*() const { return ptr; } \
+ T* operator->() const { return ptr; }
+
+template <typename T>
+class RefBox : SkNoncopyable {
+public:
+ RefBox() {}
+ RefBox(T* obj) : fObj(SkSafeRef(obj)) {}
+ ~RefBox() { SkSafeUnref(fObj); }
+
+ ACT_AS_PTR(fObj);
+
+private:
+ T* fObj;
+};
+
+// An Optional doesn't own the pointer's memory, but may need to destroy non-POD data.
+template <typename T>
+class Optional : SkNoncopyable {
+public:
+ Optional() : fPtr(nullptr) {}
+ Optional(T* ptr) : fPtr(ptr) {}
+ ~Optional() { if (fPtr) fPtr->~T(); }
+
+ ACT_AS_PTR(fPtr);
+private:
+ T* fPtr;
+};
+
+// Like Optional, but ptr must not be NULL.
+template <typename T>
+class Adopted : SkNoncopyable {
+public:
+ Adopted(T* ptr) : fPtr(ptr) { SkASSERT(fPtr); }
+ Adopted(Adopted* source) {
+ // Transfer ownership from source to this.
+ fPtr = source->fPtr;
+ source->fPtr = NULL;
+ }
+ ~Adopted() { if (fPtr) fPtr->~T(); }
+
+ ACT_AS_PTR(fPtr);
+private:
+ T* fPtr;
+};
+
+// PODArray doesn't own the pointer's memory, and we assume the data is POD.
+template <typename T>
+class PODArray {
+public:
+ PODArray() {}
+ PODArray(T* ptr) : fPtr(ptr) {}
+ // Default copy and assign.
+
+ ACT_AS_PTR(fPtr);
+private:
+ T* fPtr;
+};
+
+#undef ACT_AS_PTR
+
+// Like SkBitmap, but deep copies pixels if they're not immutable.
+// Using this, we guarantee the immutability of all bitmaps we record.
+class ImmutableBitmap : SkNoncopyable {
+public:
+ ImmutableBitmap() {}
+ explicit ImmutableBitmap(const SkBitmap& bitmap) {
+ if (bitmap.isImmutable()) {
+ fBitmap = bitmap;
+ } else {
+ bitmap.copyTo(&fBitmap);
+ }
+ fBitmap.setImmutable();
+ }
+
+ int width() const { return fBitmap.width(); }
+ int height() const { return fBitmap.height(); }
+
+ // While the pixels are immutable, SkBitmap itself is not thread-safe, so return a copy.
+ SkBitmap shallowCopy() const { return fBitmap; }
+private:
+ SkBitmap fBitmap;
+};
+
+// SkPath::getBounds() isn't thread safe unless we precache the bounds in a singlethreaded context.
+// SkPath::cheapComputeDirection() is similar.
+// Recording is a convenient time to cache these, or we can delay it to between record and playback.
+struct PreCachedPath : public SkPath {
+ PreCachedPath() {}
+ explicit PreCachedPath(const SkPath& path) : SkPath(path) {
+ this->updateBoundsCache();
+#if 0 // Disabled to see if we ever really race on this. It costs time, chromium:496982.
+ SkPathPriv::FirstDirection junk;
+ (void)SkPathPriv::CheapComputeFirstDirection(*this, &junk);
+#endif
+ }
+};
+
+// Like SkPath::getBounds(), SkMatrix::getType() isn't thread safe unless we precache it.
+// This may not cover all SkMatrices used by the picture (e.g. some could be hiding in a shader).
+struct TypedMatrix : public SkMatrix {
+ TypedMatrix() {}
+ explicit TypedMatrix(const SkMatrix& matrix) : SkMatrix(matrix) {
+ (void)this->getType();
+ }
+};
+
+RECORD0(NoOp);
+
+RECORD2(Restore, SkIRect, devBounds, TypedMatrix, matrix);
+RECORD0(Save);
+RECORD3(SaveLayer, Optional<SkRect>, bounds, Optional<SkPaint>, paint, SkCanvas::SaveFlags, flags);
+
+RECORD1(SetMatrix, TypedMatrix, matrix);
+
+struct RegionOpAndAA {
+ RegionOpAndAA() {}
+ RegionOpAndAA(SkRegion::Op op, bool aa) : op(op), aa(aa) {}
+ SkRegion::Op op : 31; // This really only needs to be 3, but there's no win today to do so.
+ unsigned aa : 1; // MSVC won't pack an enum with an bool, so we call this an unsigned.
+};
+SK_COMPILE_ASSERT(sizeof(RegionOpAndAA) == 4, RegionOpAndAASize);
+
+RECORD3(ClipPath, SkIRect, devBounds, PreCachedPath, path, RegionOpAndAA, opAA);
+RECORD3(ClipRRect, SkIRect, devBounds, SkRRect, rrect, RegionOpAndAA, opAA);
+RECORD3(ClipRect, SkIRect, devBounds, SkRect, rect, RegionOpAndAA, opAA);
+RECORD3(ClipRegion, SkIRect, devBounds, SkRegion, region, SkRegion::Op, op);
+
+// While not strictly required, if you have an SkPaint, it's fastest to put it first.
+RECORD4(DrawBitmap, Optional<SkPaint>, paint,
+ ImmutableBitmap, bitmap,
+ SkScalar, left,
+ SkScalar, top);
+RECORD4(DrawBitmapNine, Optional<SkPaint>, paint,
+ ImmutableBitmap, bitmap,
+ SkIRect, center,
+ SkRect, dst);
+RECORD4(DrawBitmapRect, Optional<SkPaint>, paint,
+ ImmutableBitmap, bitmap,
+ Optional<SkRect>, src,
+ SkRect, dst);
+RECORD4(DrawBitmapRectFast, Optional<SkPaint>, paint,
+ ImmutableBitmap, bitmap,
+ Optional<SkRect>, src,
+ SkRect, dst);
+RECORD5(DrawBitmapRectFixedSize, SkPaint, paint,
+ ImmutableBitmap, bitmap,
+ SkRect, src,
+ SkRect, dst,
+ SkCanvas::SrcRectConstraint, constraint);
+RECORD3(DrawDRRect, SkPaint, paint, SkRRect, outer, SkRRect, inner);
+RECORD3(DrawDrawable, Optional<SkMatrix>, matrix, SkRect, worstCaseBounds, int32_t, index);
+RECORD4(DrawImage, Optional<SkPaint>, paint,
+ RefBox<const SkImage>, image,
+ SkScalar, left,
+ SkScalar, top);
+RECORD5(DrawImageRect, Optional<SkPaint>, paint,
+ RefBox<const SkImage>, image,
+ Optional<SkRect>, src,
+ SkRect, dst,
+ SkCanvas::SrcRectConstraint, constraint);
+RECORD4(DrawImageNine, Optional<SkPaint>, paint,
+ RefBox<const SkImage>, image,
+ SkIRect, center,
+ SkRect, dst);
+RECORD2(DrawOval, SkPaint, paint, SkRect, oval);
+RECORD1(DrawPaint, SkPaint, paint);
+RECORD2(DrawPath, SkPaint, paint, PreCachedPath, path);
+RECORD3(DrawPicture, Optional<SkPaint>, paint,
+ RefBox<const SkPicture>, picture,
+ TypedMatrix, matrix);
+RECORD4(DrawPoints, SkPaint, paint, SkCanvas::PointMode, mode, unsigned, count, SkPoint*, pts);
+RECORD4(DrawPosText, SkPaint, paint,
+ PODArray<char>, text,
+ size_t, byteLength,
+ PODArray<SkPoint>, pos);
+RECORD5(DrawPosTextH, SkPaint, paint,
+ PODArray<char>, text,
+ unsigned, byteLength,
+ SkScalar, y,
+ PODArray<SkScalar>, xpos);
+RECORD2(DrawRRect, SkPaint, paint, SkRRect, rrect);
+RECORD2(DrawRect, SkPaint, paint, SkRect, rect);
+RECORD4(DrawSprite, Optional<SkPaint>, paint, ImmutableBitmap, bitmap, int, left, int, top);
+RECORD5(DrawText, SkPaint, paint,
+ PODArray<char>, text,
+ size_t, byteLength,
+ SkScalar, x,
+ SkScalar, y);
+RECORD4(DrawTextBlob, SkPaint, paint,
+ RefBox<const SkTextBlob>, blob,
+ SkScalar, x,
+ SkScalar, y);
+RECORD5(DrawTextOnPath, SkPaint, paint,
+ PODArray<char>, text,
+ size_t, byteLength,
+ PreCachedPath, path,
+ TypedMatrix, matrix);
+
+RECORD5(DrawPatch, SkPaint, paint,
+ PODArray<SkPoint>, cubics,
+ PODArray<SkColor>, colors,
+ PODArray<SkPoint>, texCoords,
+ RefBox<SkXfermode>, xmode);
+
+RECORD8(DrawAtlas, Optional<SkPaint>, paint,
+ RefBox<const SkImage>, atlas,
+ PODArray<SkRSXform>, xforms,
+ PODArray<SkRect>, texs,
+ PODArray<SkColor>, colors,
+ int, count,
+ SkXfermode::Mode, mode,
+ Optional<SkRect>, cull);
+
+// This guy is so ugly we just write it manually.
+struct DrawVertices {
+ static const Type kType = DrawVertices_Type;
+
+ DrawVertices(const SkPaint& paint,
+ SkCanvas::VertexMode vmode,
+ int vertexCount,
+ SkPoint* vertices,
+ SkPoint* texs,
+ SkColor* colors,
+ SkXfermode* xmode,
+ uint16_t* indices,
+ int indexCount)
+ : paint(paint)
+ , vmode(vmode)
+ , vertexCount(vertexCount)
+ , vertices(vertices)
+ , texs(texs)
+ , colors(colors)
+ , xmode(SkSafeRef(xmode))
+ , indices(indices)
+ , indexCount(indexCount) {}
+
+ SkPaint paint;
+ SkCanvas::VertexMode vmode;
+ int vertexCount;
+ PODArray<SkPoint> vertices;
+ PODArray<SkPoint> texs;
+ PODArray<SkColor> colors;
+ SkAutoTUnref<SkXfermode> xmode;
+ PODArray<uint16_t> indices;
+ int indexCount;
+};
+
+#undef RECORD0
+#undef RECORD1
+#undef RECORD2
+#undef RECORD3
+#undef RECORD4
+#undef RECORD5
+#undef RECORD8
+
+} // namespace SkRecords
+
+#endif//SkRecords_DEFINED
#ifndef SkOSWindow_Win_DEFINED
#define SkOSWindow_Win_DEFINED
-#include "../../src/core/SkFunction.h"
+#include "../private/SkFunction.h"
#include "../private/SkTHash.h"
#include "SkWindow.h"
+++ /dev/null
-/*
- * Copyright 2015 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef SkFunction_DEFINED
-#define SkFunction_DEFINED
-
-// TODO: document, more pervasive move support in constructors, small-Fn optimization
-
-#include "SkTemplates.h"
-#include "SkTypes.h"
-
-template <typename> class SkFunction;
-
-template <typename R, typename... Args>
-class SkFunction<R(Args...)> {
-public:
- SkFunction() {}
-
- template <typename Fn>
- SkFunction(const Fn& fn) : fFunction(SkNEW_ARGS(LambdaImpl<Fn>, (fn))) {}
-
- SkFunction(R (*fn)(Args...)) : fFunction(SkNEW_ARGS(FnPtrImpl, (fn))) {}
-
- SkFunction(const SkFunction& other) { *this = other; }
- SkFunction& operator=(const SkFunction& other) {
- if (this != &other) {
- fFunction.reset(other.fFunction ? other.fFunction->clone() : nullptr);
- }
- return *this;
- }
-
- R operator()(Args... args) const {
- SkASSERT(fFunction.get());
- return fFunction->call(Forward(args)...);
- }
-
-private:
- // ~= std::forward. This moves its argument if possible, falling back to a copy if not.
- template <typename T> static T&& Forward(T& v) { return (T&&)v; }
-
- struct Interface {
- virtual ~Interface() {}
- virtual R call(Args...) const = 0;
- virtual Interface* clone() const = 0;
- };
-
- template <typename Fn>
- class LambdaImpl final : public Interface {
- public:
- LambdaImpl(const Fn& fn) : fFn(fn) {}
-
- R call(Args... args) const override { return fFn(Forward(args)...); }
- Interface* clone() const override { return SkNEW_ARGS(LambdaImpl<Fn>, (fFn)); }
- private:
- Fn fFn;
- };
-
- class FnPtrImpl final : public Interface {
- public:
- FnPtrImpl(R (*fn)(Args...)) : fFn(fn) {}
-
- R call(Args... args) const override { return fFn(Forward(args)...); }
- Interface* clone() const override { return SkNEW_ARGS(FnPtrImpl, (fFn)); }
- private:
- R (*fFn)(Args...);
- };
-
- SkAutoTDelete<Interface> fFunction;
-};
-
-#endif//SkFunction_DEFINED
+++ /dev/null
-/*
- * Copyright 2015 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef SkMiniRecorder_DEFINED
-#define SkMiniRecorder_DEFINED
-
-#include "SkRecords.h"
-#include "SkScalar.h"
-#include "SkTypes.h"
-class SkCanvas;
-
-// Records small pictures, but only a limited subset of the canvas API, and may fail.
-class SkMiniRecorder : SkNoncopyable {
-public:
- SkMiniRecorder();
- ~SkMiniRecorder();
-
- // Try to record an op. Returns false on failure.
- bool drawBitmapRect(const SkBitmap&, const SkRect* src, const SkRect& dst,
- const SkPaint*, SkCanvas::SrcRectConstraint);
- bool drawPath(const SkPath&, const SkPaint&);
- bool drawRect(const SkRect&, const SkPaint&);
- bool drawTextBlob(const SkTextBlob*, SkScalar x, SkScalar y, const SkPaint&);
-
- // Detach anything we've recorded as a picture, resetting this SkMiniRecorder.
- SkPicture* detachAsPicture(const SkRect& cull);
-
- // Flush anything we've recorded to the canvas, resetting this SkMiniRecorder.
- // This is logically the same as but rather more efficient than:
- // SkAutoTUnref<SkPicture> pic(this->detachAsPicture(SkRect::MakeEmpty()));
- // pic->playback(canvas);
- void flushAndReset(SkCanvas*);
-
-private:
- enum class State {
- kEmpty,
- kDrawBitmapRectFixedSize,
- kDrawPath,
- kDrawRect,
- kDrawTextBlob,
- };
-
- State fState;
-
- template <size_t A, size_t B>
- struct Max { static const size_t val = A > B ? A : B; };
-
- static const size_t kInlineStorage =
- Max<sizeof(SkRecords::DrawBitmapRectFixedSize),
- Max<sizeof(SkRecords::DrawPath),
- Max<sizeof(SkRecords::DrawRect),
- sizeof(SkRecords::DrawTextBlob)>::val>::val>::val;
- SkAlignedSStorage<kInlineStorage> fBuffer;
-};
-
-#endif//SkMiniRecorder_DEFINED
+++ /dev/null
-/*
- * Copyright 2015 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef SkPathPriv_DEFINED
-#define SkPathPriv_DEFINED
-
-#include "SkPath.h"
-
-class SkPathPriv {
-public:
- enum FirstDirection {
- kCW_FirstDirection, // == SkPath::kCW_Direction
- kCCW_FirstDirection, // == SkPath::kCCW_Direction
- kUnknown_FirstDirection,
- };
-
- static FirstDirection AsFirstDirection(SkPath::Direction dir) {
- // since we agree numerically for the values in Direction, we can just cast.
- return (FirstDirection)dir;
- }
-
- /**
- * Return the opposite of the specified direction. kUnknown is its own
- * opposite.
- */
- static FirstDirection OppositeFirstDirection(FirstDirection dir) {
- static const FirstDirection gOppositeDir[] = {
- kCCW_FirstDirection, kCW_FirstDirection, kUnknown_FirstDirection,
- };
- return gOppositeDir[dir];
- }
-
- /**
- * Tries to quickly compute the direction of the first non-degenerate
- * contour. If it can be computed, return true and set dir to that
- * direction. If it cannot be (quickly) determined, return false and ignore
- * the dir parameter. If the direction was determined, it is cached to make
- * subsequent calls return quickly.
- */
- static bool CheapComputeFirstDirection(const SkPath&, FirstDirection* dir);
-
- /**
- * Returns true if the path's direction can be computed via
- * cheapComputDirection() and if that computed direction matches the
- * specified direction. If dir is kUnknown, returns true if the direction
- * cannot be computed.
- */
- static bool CheapIsFirstDirection(const SkPath& path, FirstDirection dir) {
- FirstDirection computedDir = kUnknown_FirstDirection;
- (void)CheapComputeFirstDirection(path, &computedDir);
- return computedDir == dir;
- }
-
- static bool LastVerbIsClose(const SkPath& path) {
- int count = path.countVerbs();
- return count >= 1 && path.fPathRef->verbs()[~(count - 1)] == SkPath::Verb::kClose_Verb;
- }
-};
-
-#endif
+++ /dev/null
-/*
- * 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 SkRecords_DEFINED
-#define SkRecords_DEFINED
-
-#include "SkCanvas.h"
-#include "SkDrawable.h"
-#include "SkMatrix.h"
-#include "SkPathPriv.h"
-#include "SkPicture.h"
-#include "SkRSXform.h"
-#include "SkTextBlob.h"
-
-namespace SkRecords {
-
-// A list of all the types of canvas calls we can record.
-// Each of these is reified into a struct below.
-//
-// (We're using the macro-of-macro trick here to do several different things with the same list.)
-//
-// We leave this SK_RECORD_TYPES macro defined for use by code that wants to operate on SkRecords
-// types polymorphically. (See SkRecord::Record::{visit,mutate} for an example.)
-//
-// Order doesn't technically matter here, but the compiler can generally generate better code if
-// you keep them semantically grouped, especially the Draws. It's also nice to leave NoOp at 0.
-#define SK_RECORD_TYPES(M) \
- M(NoOp) \
- M(Restore) \
- M(Save) \
- M(SaveLayer) \
- M(SetMatrix) \
- M(ClipPath) \
- M(ClipRRect) \
- M(ClipRect) \
- M(ClipRegion) \
- M(DrawBitmap) \
- M(DrawBitmapNine) \
- M(DrawBitmapRect) \
- M(DrawBitmapRectFast) \
- M(DrawBitmapRectFixedSize) \
- M(DrawDrawable) \
- M(DrawImage) \
- M(DrawImageRect) \
- M(DrawImageNine) \
- M(DrawDRRect) \
- M(DrawOval) \
- M(DrawPaint) \
- M(DrawPath) \
- M(DrawPatch) \
- M(DrawPicture) \
- M(DrawPoints) \
- M(DrawPosText) \
- M(DrawPosTextH) \
- M(DrawText) \
- M(DrawTextOnPath) \
- M(DrawRRect) \
- M(DrawRect) \
- M(DrawSprite) \
- M(DrawTextBlob) \
- M(DrawAtlas) \
- M(DrawVertices)
-
-// Defines SkRecords::Type, an enum of all record types.
-#define ENUM(T) T##_Type,
-enum Type { SK_RECORD_TYPES(ENUM) };
-#undef ENUM
-
-// Macros to make it easier to define a record for a draw call with 0 args, 1 args, 2 args, etc.
-// These should be clearer when you look at their use below.
-#define RECORD0(T) \
-struct T { \
- static const Type kType = T##_Type; \
-};
-
-// Instead of requring the exact type A here, we take any type Z which implicitly casts to A.
-// This lets our wrappers like ImmutableBitmap work seamlessly.
-
-#define RECORD1(T, A, a) \
-struct T { \
- static const Type kType = T##_Type; \
- T() {} \
- template <typename Z> \
- T(const Z& a) : a(a) {} \
- A a; \
-};
-
-#define RECORD2(T, A, a, B, b) \
-struct T { \
- static const Type kType = T##_Type; \
- T() {} \
- template <typename Z, typename Y> \
- T(const Z& a, const Y& b) : a(a), b(b) {} \
- A a; B b; \
-};
-
-#define RECORD3(T, A, a, B, b, C, c) \
-struct T { \
- static const Type kType = T##_Type; \
- T() {} \
- template <typename Z, typename Y, typename X> \
- T(const Z& a, const Y& b, const X& c) : a(a), b(b), c(c) {} \
- A a; B b; C c; \
-};
-
-#define RECORD4(T, A, a, B, b, C, c, D, d) \
-struct T { \
- static const Type kType = T##_Type; \
- T() {} \
- template <typename Z, typename Y, typename X, typename W> \
- T(const Z& a, const Y& b, const X& c, const W& d) : a(a), b(b), c(c), d(d) {} \
- A a; B b; C c; D d; \
-};
-
-#define RECORD5(T, A, a, B, b, C, c, D, d, E, e) \
-struct T { \
- static const Type kType = T##_Type; \
- T() {} \
- template <typename Z, typename Y, typename X, typename W, typename V> \
- T(const Z& a, const Y& b, const X& c, const W& d, const V& e) \
- : a(a), b(b), c(c), d(d), e(e) {} \
- A a; B b; C c; D d; E e; \
-};
-
-#define RECORD8(T, A, a, B, b, C, c, D, d, E, e, F, f, G, g, H, h) \
-struct T { \
- static const Type kType = T##_Type; \
- T() {} \
- template <typename Z, typename Y, typename X, typename W, \
- typename V, typename U, typename S, typename R> \
- T(const Z& a, const Y& b, const X& c, const W& d, \
- const V& e, const U& f, const S& g, const R& h) \
- : a(a), b(b), c(c), d(d), e(e), f(f), g(g), h(h) {} \
- A a; B b; C c; D d; E e; F f; G g; H h; \
-};
-
-#define ACT_AS_PTR(ptr) \
- operator T*() const { return ptr; } \
- T* operator->() const { return ptr; }
-
-template <typename T>
-class RefBox : SkNoncopyable {
-public:
- RefBox() {}
- RefBox(T* obj) : fObj(SkSafeRef(obj)) {}
- ~RefBox() { SkSafeUnref(fObj); }
-
- ACT_AS_PTR(fObj);
-
-private:
- T* fObj;
-};
-
-// An Optional doesn't own the pointer's memory, but may need to destroy non-POD data.
-template <typename T>
-class Optional : SkNoncopyable {
-public:
- Optional() : fPtr(nullptr) {}
- Optional(T* ptr) : fPtr(ptr) {}
- ~Optional() { if (fPtr) fPtr->~T(); }
-
- ACT_AS_PTR(fPtr);
-private:
- T* fPtr;
-};
-
-// Like Optional, but ptr must not be NULL.
-template <typename T>
-class Adopted : SkNoncopyable {
-public:
- Adopted(T* ptr) : fPtr(ptr) { SkASSERT(fPtr); }
- Adopted(Adopted* source) {
- // Transfer ownership from source to this.
- fPtr = source->fPtr;
- source->fPtr = NULL;
- }
- ~Adopted() { if (fPtr) fPtr->~T(); }
-
- ACT_AS_PTR(fPtr);
-private:
- T* fPtr;
-};
-
-// PODArray doesn't own the pointer's memory, and we assume the data is POD.
-template <typename T>
-class PODArray {
-public:
- PODArray() {}
- PODArray(T* ptr) : fPtr(ptr) {}
- // Default copy and assign.
-
- ACT_AS_PTR(fPtr);
-private:
- T* fPtr;
-};
-
-#undef ACT_AS_PTR
-
-// Like SkBitmap, but deep copies pixels if they're not immutable.
-// Using this, we guarantee the immutability of all bitmaps we record.
-class ImmutableBitmap : SkNoncopyable {
-public:
- ImmutableBitmap() {}
- explicit ImmutableBitmap(const SkBitmap& bitmap) {
- if (bitmap.isImmutable()) {
- fBitmap = bitmap;
- } else {
- bitmap.copyTo(&fBitmap);
- }
- fBitmap.setImmutable();
- }
-
- int width() const { return fBitmap.width(); }
- int height() const { return fBitmap.height(); }
-
- // While the pixels are immutable, SkBitmap itself is not thread-safe, so return a copy.
- SkBitmap shallowCopy() const { return fBitmap; }
-private:
- SkBitmap fBitmap;
-};
-
-// SkPath::getBounds() isn't thread safe unless we precache the bounds in a singlethreaded context.
-// SkPath::cheapComputeDirection() is similar.
-// Recording is a convenient time to cache these, or we can delay it to between record and playback.
-struct PreCachedPath : public SkPath {
- PreCachedPath() {}
- explicit PreCachedPath(const SkPath& path) : SkPath(path) {
- this->updateBoundsCache();
-#if 0 // Disabled to see if we ever really race on this. It costs time, chromium:496982.
- SkPathPriv::FirstDirection junk;
- (void)SkPathPriv::CheapComputeFirstDirection(*this, &junk);
-#endif
- }
-};
-
-// Like SkPath::getBounds(), SkMatrix::getType() isn't thread safe unless we precache it.
-// This may not cover all SkMatrices used by the picture (e.g. some could be hiding in a shader).
-struct TypedMatrix : public SkMatrix {
- TypedMatrix() {}
- explicit TypedMatrix(const SkMatrix& matrix) : SkMatrix(matrix) {
- (void)this->getType();
- }
-};
-
-RECORD0(NoOp);
-
-RECORD2(Restore, SkIRect, devBounds, TypedMatrix, matrix);
-RECORD0(Save);
-RECORD3(SaveLayer, Optional<SkRect>, bounds, Optional<SkPaint>, paint, SkCanvas::SaveFlags, flags);
-
-RECORD1(SetMatrix, TypedMatrix, matrix);
-
-struct RegionOpAndAA {
- RegionOpAndAA() {}
- RegionOpAndAA(SkRegion::Op op, bool aa) : op(op), aa(aa) {}
- SkRegion::Op op : 31; // This really only needs to be 3, but there's no win today to do so.
- unsigned aa : 1; // MSVC won't pack an enum with an bool, so we call this an unsigned.
-};
-SK_COMPILE_ASSERT(sizeof(RegionOpAndAA) == 4, RegionOpAndAASize);
-
-RECORD3(ClipPath, SkIRect, devBounds, PreCachedPath, path, RegionOpAndAA, opAA);
-RECORD3(ClipRRect, SkIRect, devBounds, SkRRect, rrect, RegionOpAndAA, opAA);
-RECORD3(ClipRect, SkIRect, devBounds, SkRect, rect, RegionOpAndAA, opAA);
-RECORD3(ClipRegion, SkIRect, devBounds, SkRegion, region, SkRegion::Op, op);
-
-// While not strictly required, if you have an SkPaint, it's fastest to put it first.
-RECORD4(DrawBitmap, Optional<SkPaint>, paint,
- ImmutableBitmap, bitmap,
- SkScalar, left,
- SkScalar, top);
-RECORD4(DrawBitmapNine, Optional<SkPaint>, paint,
- ImmutableBitmap, bitmap,
- SkIRect, center,
- SkRect, dst);
-RECORD4(DrawBitmapRect, Optional<SkPaint>, paint,
- ImmutableBitmap, bitmap,
- Optional<SkRect>, src,
- SkRect, dst);
-RECORD4(DrawBitmapRectFast, Optional<SkPaint>, paint,
- ImmutableBitmap, bitmap,
- Optional<SkRect>, src,
- SkRect, dst);
-RECORD5(DrawBitmapRectFixedSize, SkPaint, paint,
- ImmutableBitmap, bitmap,
- SkRect, src,
- SkRect, dst,
- SkCanvas::SrcRectConstraint, constraint);
-RECORD3(DrawDRRect, SkPaint, paint, SkRRect, outer, SkRRect, inner);
-RECORD3(DrawDrawable, Optional<SkMatrix>, matrix, SkRect, worstCaseBounds, int32_t, index);
-RECORD4(DrawImage, Optional<SkPaint>, paint,
- RefBox<const SkImage>, image,
- SkScalar, left,
- SkScalar, top);
-RECORD5(DrawImageRect, Optional<SkPaint>, paint,
- RefBox<const SkImage>, image,
- Optional<SkRect>, src,
- SkRect, dst,
- SkCanvas::SrcRectConstraint, constraint);
-RECORD4(DrawImageNine, Optional<SkPaint>, paint,
- RefBox<const SkImage>, image,
- SkIRect, center,
- SkRect, dst);
-RECORD2(DrawOval, SkPaint, paint, SkRect, oval);
-RECORD1(DrawPaint, SkPaint, paint);
-RECORD2(DrawPath, SkPaint, paint, PreCachedPath, path);
-RECORD3(DrawPicture, Optional<SkPaint>, paint,
- RefBox<const SkPicture>, picture,
- TypedMatrix, matrix);
-RECORD4(DrawPoints, SkPaint, paint, SkCanvas::PointMode, mode, unsigned, count, SkPoint*, pts);
-RECORD4(DrawPosText, SkPaint, paint,
- PODArray<char>, text,
- size_t, byteLength,
- PODArray<SkPoint>, pos);
-RECORD5(DrawPosTextH, SkPaint, paint,
- PODArray<char>, text,
- unsigned, byteLength,
- SkScalar, y,
- PODArray<SkScalar>, xpos);
-RECORD2(DrawRRect, SkPaint, paint, SkRRect, rrect);
-RECORD2(DrawRect, SkPaint, paint, SkRect, rect);
-RECORD4(DrawSprite, Optional<SkPaint>, paint, ImmutableBitmap, bitmap, int, left, int, top);
-RECORD5(DrawText, SkPaint, paint,
- PODArray<char>, text,
- size_t, byteLength,
- SkScalar, x,
- SkScalar, y);
-RECORD4(DrawTextBlob, SkPaint, paint,
- RefBox<const SkTextBlob>, blob,
- SkScalar, x,
- SkScalar, y);
-RECORD5(DrawTextOnPath, SkPaint, paint,
- PODArray<char>, text,
- size_t, byteLength,
- PreCachedPath, path,
- TypedMatrix, matrix);
-
-RECORD5(DrawPatch, SkPaint, paint,
- PODArray<SkPoint>, cubics,
- PODArray<SkColor>, colors,
- PODArray<SkPoint>, texCoords,
- RefBox<SkXfermode>, xmode);
-
-RECORD8(DrawAtlas, Optional<SkPaint>, paint,
- RefBox<const SkImage>, atlas,
- PODArray<SkRSXform>, xforms,
- PODArray<SkRect>, texs,
- PODArray<SkColor>, colors,
- int, count,
- SkXfermode::Mode, mode,
- Optional<SkRect>, cull);
-
-// This guy is so ugly we just write it manually.
-struct DrawVertices {
- static const Type kType = DrawVertices_Type;
-
- DrawVertices(const SkPaint& paint,
- SkCanvas::VertexMode vmode,
- int vertexCount,
- SkPoint* vertices,
- SkPoint* texs,
- SkColor* colors,
- SkXfermode* xmode,
- uint16_t* indices,
- int indexCount)
- : paint(paint)
- , vmode(vmode)
- , vertexCount(vertexCount)
- , vertices(vertices)
- , texs(texs)
- , colors(colors)
- , xmode(SkSafeRef(xmode))
- , indices(indices)
- , indexCount(indexCount) {}
-
- SkPaint paint;
- SkCanvas::VertexMode vmode;
- int vertexCount;
- PODArray<SkPoint> vertices;
- PODArray<SkPoint> texs;
- PODArray<SkColor> colors;
- SkAutoTUnref<SkXfermode> xmode;
- PODArray<uint16_t> indices;
- int indexCount;
-};
-
-#undef RECORD0
-#undef RECORD1
-#undef RECORD2
-#undef RECORD3
-#undef RECORD4
-#undef RECORD5
-#undef RECORD8
-
-} // namespace SkRecords
-
-#endif//SkRecords_DEFINED
+++ /dev/null
-
-/*
- * Copyright 2015 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-#ifndef SkGpuFenceSync_DEFINED
-#define SkGpuFenceSync_DEFINED
-
-#include "SkTypes.h"
-
-typedef void* SkPlatformGpuFence;
-
-/*
- * This class provides an interface to interact with fence syncs. A fence sync is an object that the
- * client can insert into the GPU command stream, and then at any future time, wait until all
- * commands that were issued before the fence have completed.
- */
-class SkGpuFenceSync {
-public:
- virtual SkPlatformGpuFence SK_WARN_UNUSED_RESULT insertFence() const = 0;
- virtual bool flushAndWaitFence(SkPlatformGpuFence) const = 0;
- virtual void deleteFence(SkPlatformGpuFence) const = 0;
-
- virtual ~SkGpuFenceSync() {}
-};
-
-#endif
projects / platform / upstream / libSkiaSharp.git / commitdiff