aboutsummaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
Diffstat
-rw-r--r--include/c/sk_canvas.h7
-rw-r--r--include/c/sk_picture.h32
-rw-r--r--include/c/sk_types.h7
-rw-r--r--src/c/sk_surface.cpp105
4 files changed, 143 insertions, 8 deletions
diff --git a/include/c/sk_canvas.h b/include/c/sk_canvas.h
index 559ef959ac..9eb21f3a61 100644
--- a/include/c/sk_canvas.h
+++ b/include/c/sk_canvas.h
@@ -24,14 +24,19 @@ void sk_canvas_scale(sk_canvas_t*, float sx, float sy);
void sk_canvas_rotate_degrees(sk_canvas_t*, float degrees);
void sk_canvas_rotate_radians(sk_canvas_t*, float radians);
void sk_canvas_skew(sk_canvas_t*, float sx, float sy);
+void sk_canvas_concat(sk_canvas_t*, const sk_matrix_t*);
-void sk_canvas_concat_matrix(sk_canvas_t*, const sk_matrix_t*);
+void sk_canvas_clip_rect(sk_canvas_t*, const sk_rect_t*);
+void sk_canvas_clip_path(sk_canvas_t*, const sk_path_t*);
void sk_canvas_draw_paint(sk_canvas_t*, const sk_paint_t*);
void sk_canvas_draw_rect(sk_canvas_t*, const sk_rect_t*, const sk_paint_t*);
void sk_canvas_draw_oval(sk_canvas_t*, const sk_rect_t*, const sk_paint_t*);
void sk_canvas_draw_path(sk_canvas_t*, const sk_path_t*, const sk_paint_t*);
void sk_canvas_draw_image(sk_canvas_t*, const sk_image_t*, float x, float y, const sk_paint_t*);
+void sk_canvas_draw_image_rect(sk_canvas_t*, const sk_image_t*, const sk_rect_t* src,
+ const sk_rect_t* dst, const sk_paint_t*);
+void sk_canvas_draw_picture(sk_canvas_t*, const sk_picture_t*, const sk_matrix_t*, const sk_paint_t*);
SK_C_PLUS_PLUS_END_GUARD
diff --git a/include/c/sk_picture.h b/include/c/sk_picture.h
new file mode 100644
index 0000000000..f062d32e69
--- /dev/null
+++ b/include/c/sk_picture.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// EXPERIMENTAL EXPERIMENTAL EXPERIMENTAL EXPERIMENTAL
+// DO NOT USE -- FOR INTERNAL TESTING ONLY
+
+#ifndef sk_picture_DEFINED
+#define sk_picture_DEFINED
+
+#include "sk_types.h"
+
+SK_C_PLUS_PLUS_BEGIN_GUARD
+
+sk_picture_recorder_t* sk_picture_recorder_new();
+void sk_picture_recorder_delete(sk_picture_recorder_t*);
+
+sk_canvas_t* sk_picture_recorder_begin_recording(sk_picture_recorder_t*, const sk_rect_t*);
+sk_picture_t* sk_picture_recorder_end_recording(sk_picture_recorder_t*);
+
+void sk_picture_ref(sk_picture_t*);
+void sk_picture_unref(sk_picture_t*);
+
+uint32_t sk_picture_get_unique_id(sk_picture_t*);
+sk_rect_t sk_picture_get_bounds(sk_picture_t*);
+
+SK_C_PLUS_PLUS_END_GUARD
+
+#endif
diff --git a/include/c/sk_types.h b/include/c/sk_types.h
index 4c6389689c..f5f4b578fc 100644
--- a/include/c/sk_types.h
+++ b/include/c/sk_types.h
@@ -48,6 +48,11 @@ typedef enum {
UNPREMUL_SK_ALPHATYPE,
} sk_alphatype_t;
+typedef enum {
+ INTERSECT_SK_CLIPTYPE,
+ DIFFERENCE_SK_CLIPTYPE,
+} sk_cliptype_t;
+
sk_colortype_t sk_colortype_get_default_8888();
typedef struct {
@@ -76,6 +81,8 @@ typedef struct {
typedef struct sk_canvas_t sk_canvas_t;
typedef struct sk_image_t sk_image_t;
typedef struct sk_paint_t sk_paint_t;
+typedef struct sk_picture_t sk_picture_t;
+typedef struct sk_picture_recorder_t sk_picture_recorder_t;
typedef struct sk_path_t sk_path_t;
typedef struct sk_shader_t sk_shader_t;
typedef struct sk_surface_t sk_surface_t;
diff --git a/src/c/sk_surface.cpp b/src/c/sk_surface.cpp
index 94e925ada4..0a940022e8 100644
--- a/src/c/sk_surface.cpp
+++ b/src/c/sk_surface.cpp
@@ -16,6 +16,7 @@
#include "SkMatrix.h"
#include "SkPaint.h"
#include "SkPath.h"
+#include "SkPictureRecorder.h"
#include "SkSurface.h"
const struct {
@@ -117,12 +118,16 @@ static bool from_c_path_direction(sk_path_direction_t cdir, SkPath::Direction* d
return false;
}
+static sk_rect_t ToRect(const SkRect& rect) {
+ return reinterpret_cast<const sk_rect_t&>(rect);
+}
+
static const SkRect& AsRect(const sk_rect_t& crect) {
return reinterpret_cast<const SkRect&>(crect);
}
-static SkRect* as_rect(sk_rect_t* crect) {
- return reinterpret_cast<SkRect*>(crect);
+static const SkRect* AsRect(const sk_rect_t* crect) {
+ return reinterpret_cast<const SkRect*>(crect);
}
static const SkPath& AsPath(const sk_path_t& cpath) {
@@ -149,6 +154,10 @@ static SkPaint* AsPaint(sk_paint_t* cpaint) {
return reinterpret_cast<SkPaint*>(cpaint);
}
+static sk_canvas_t* ToCanvas(SkCanvas* canvas) {
+ return reinterpret_cast<sk_canvas_t*>(canvas);
+}
+
static SkCanvas* AsCanvas(sk_canvas_t* ccanvas) {
return reinterpret_cast<SkCanvas*>(ccanvas);
}
@@ -157,6 +166,26 @@ static SkShader* AsShader(sk_shader_t* cshader) {
return reinterpret_cast<SkShader*>(cshader);
}
+static SkPictureRecorder* AsPictureRecorder(sk_picture_recorder_t* crec) {
+ return reinterpret_cast<SkPictureRecorder*>(crec);
+}
+
+static sk_picture_recorder_t* ToPictureRecorder(SkPictureRecorder* rec) {
+ return reinterpret_cast<sk_picture_recorder_t*>(rec);
+}
+
+static const SkPicture* AsPicture(const sk_picture_t* cpic) {
+ return reinterpret_cast<const SkPicture*>(cpic);
+}
+
+static SkPicture* AsPicture(sk_picture_t* cpic) {
+ return reinterpret_cast<SkPicture*>(cpic);
+}
+
+static sk_picture_t* ToPicture(SkPicture* pic) {
+ return reinterpret_cast<sk_picture_t*>(pic);
+}
+
///////////////////////////////////////////////////////////////////////////////////////////
sk_colortype_t sk_colortype_get_default_8888() {
@@ -280,15 +309,17 @@ void sk_path_add_oval(sk_path_t* cpath, const sk_rect_t* crect, sk_path_directio
bool sk_path_get_bounds(const sk_path_t* cpath, sk_rect_t* crect) {
const SkPath& path = AsPath(*cpath);
- SkRect* rect = as_rect(crect);
if (path.isEmpty()) {
- if (rect) {
- rect->setEmpty();
+ if (crect) {
+ *crect = ToRect(SkRect::MakeEmpty());
}
return false;
}
- *rect = path.getBounds();
+
+ if (crect) {
+ *crect = ToRect(path.getBounds());
+ }
return true;
}
@@ -326,13 +357,21 @@ void sk_canvas_skew(sk_canvas_t* ccanvas, float sx, float sy) {
AsCanvas(ccanvas)->skew(sx, sy);
}
-void sk_canvas_concat_matrix(sk_canvas_t* ccanvas, const sk_matrix_t* cmatrix) {
+void sk_canvas_concat(sk_canvas_t* ccanvas, const sk_matrix_t* cmatrix) {
SkASSERT(cmatrix);
SkMatrix matrix;
from_c_matrix(cmatrix, &matrix);
AsCanvas(ccanvas)->concat(matrix);
}
+void sk_canvas_clip_rect(sk_canvas_t* ccanvas, const sk_rect_t* crect) {
+ AsCanvas(ccanvas)->clipRect(AsRect(*crect));
+}
+
+void sk_canvas_clip_path(sk_canvas_t* ccanvas, const sk_path_t* cpath) {
+ AsCanvas(ccanvas)->clipPath(AsPath(*cpath));
+}
+
void sk_canvas_draw_paint(sk_canvas_t* ccanvas, const sk_paint_t* cpaint) {
AsCanvas(ccanvas)->drawPaint(AsPaint(*cpaint));
}
@@ -354,6 +393,23 @@ void sk_canvas_draw_image(sk_canvas_t* ccanvas, const sk_image_t* cimage, float
AsCanvas(ccanvas)->drawImage(AsImage(cimage), x, y, AsPaint(cpaint));
}
+void sk_canvas_draw_image_rect(sk_canvas_t* ccanvas, const sk_image_t* cimage,
+ const sk_rect_t* csrcR, const sk_rect_t* cdstR,
+ const sk_paint_t* cpaint) {
+ AsCanvas(ccanvas)->drawImageRect(AsImage(cimage), AsRect(csrcR), AsRect(*cdstR), AsPaint(cpaint));
+}
+
+void sk_canvas_draw_picture(sk_canvas_t* ccanvas, const sk_picture_t* cpicture,
+ const sk_matrix_t* cmatrix, const sk_paint_t* cpaint) {
+ const SkMatrix* matrixPtr = NULL;
+ SkMatrix matrix;
+ if (cmatrix) {
+ from_c_matrix(cmatrix, &matrix);
+ matrixPtr = &matrix;
+ }
+ AsCanvas(ccanvas)->drawPicture(AsPicture(cpicture), matrixPtr, AsPaint(cpaint));
+}
+
///////////////////////////////////////////////////////////////////////////////////////////
sk_surface_t* sk_surface_new_raster(const sk_imageinfo_t* cinfo) {
@@ -389,6 +445,41 @@ sk_image_t* sk_surface_new_image_snapshot(sk_surface_t* csurf) {
///////////////////////////////////////////////////////////////////////////////////////////
+sk_picture_recorder_t* sk_picture_recorder_new() {
+ return ToPictureRecorder(new SkPictureRecorder);
+}
+
+void sk_picture_recorder_delete(sk_picture_recorder_t* crec) {
+ delete AsPictureRecorder(crec);
+}
+
+sk_canvas_t* sk_picture_recorder_begin_recording(sk_picture_recorder_t* crec,
+ const sk_rect_t* cbounds) {
+ return ToCanvas(AsPictureRecorder(crec)->beginRecording(AsRect(*cbounds)));
+}
+
+sk_picture_t* sk_picture_recorder_end_recording(sk_picture_recorder_t* crec) {
+ return ToPicture(AsPictureRecorder(crec)->endRecording());
+}
+
+void sk_picture_ref(sk_picture_t* cpic) {
+ SkSafeRef(AsPicture(cpic));
+}
+
+void sk_picture_unref(sk_picture_t* cpic) {
+ SkSafeUnref(AsPicture(cpic));
+}
+
+uint32_t sk_picture_get_unique_id(sk_picture_t* cpic) {
+ return AsPicture(cpic)->uniqueID();
+}
+
+sk_rect_t sk_picture_get_bounds(sk_picture_t* cpic) {
+ return ToRect(AsPicture(cpic)->cullRect());
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
#include "../../include/effects/SkGradientShader.h"
#include "sk_shader.h"
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-09 06:01:21 +0000