'include_dirs': [
'../include/config',
'../include/core',
+ '../include/record',
],
'direct_dependent_settings': {
'include_dirs': [
- '../src/record',
+ '../include/record', # World-public headers.
+ '../src/record', # Skia-public headers.
],
},
'sources': [
- '../src/record/SkRecorder.cpp',
'../src/record/SkRecordCulling.cpp',
'../src/record/SkRecordDraw.cpp',
+ '../src/record/SkRecorder.cpp',
+ '../src/record/SkRecording.cpp',
],
}]
}
'../tests/RecordDrawTest.cpp',
'../tests/RecordTest.cpp',
'../tests/RecorderTest.cpp',
+ '../tests/RecordingTest.cpp',
'../tests/RefCntTest.cpp',
'../tests/RefDictTest.cpp',
'../tests/RegionTest.cpp',
--- /dev/null
+#ifndef SkRecording_DEFINED
+#define SkRecording_DEFINED
+
+#include "SkCanvas.h" // SkCanvas
+#include "SkTypes.h" // SkNoncopyable
+
+// These are intentionally left opaque.
+class SkRecord;
+class SkRecorder;
+
+namespace EXPERIMENTAL {
+
+/** Easy mode interface to SkRecord-based SkCanvas recording.
+ *
+ * SkRecording* recording = SkRecording::Create(1920, 1080);
+ *
+ * SkCanvas* canvas = recording->canvas();
+ * canvas->drawThis();
+ * canvas->clipThat();
+ * ...
+ *
+ * scoped_ptr<const SkPlayback> playback(SkRecording::Delete(recording));
+ * playback->draw(&someCanvas);
+ * playback->draw(&someOtherCanvas);
+ *
+ * SkPlayback is thread safe; SkRecording is not.
+ */
+
+class SkPlayback : SkNoncopyable {
+public:
+ // Remember, if you've got an SkPlayback*, you probably own it. Don't forget to delete it!
+ ~SkPlayback();
+
+ // Draw recorded commands into a canvas.
+ void draw(SkCanvas*) const;
+
+private:
+ explicit SkPlayback(const SkRecord*);
+
+ const SkRecord* fRecord;
+
+ friend class SkRecording;
+};
+
+class SkRecording : SkNoncopyable {
+public:
+ // Result must be returned via SkRecording::Delete.
+ static SkRecording* Create(int width, int height);
+
+ // Caller takes ownership of SkPlayback.
+ static const SkPlayback* Delete(SkRecording*);
+
+ // Draws issued to this canvas will be replayed by SkPlayback::draw().
+ // This pointer is owned by the SkRecording; the caller must not take ownership.
+ SkCanvas* canvas();
+
+private:
+ SkRecording(int width, int height);
+ ~SkRecording();
+
+ SkRecorder* fRecorder;
+ const SkRecord* fRecord;
+};
+
+} // namespace EXPERIMENTAL
+
+#endif//SkRecording_DEFINED
--- /dev/null
+#include "SkRecording.h"
+
+#include "SkRecord.h"
+#include "SkRecorder.h"
+#include "SkRecordDraw.h"
+
+namespace EXPERIMENTAL {
+
+SkPlayback::SkPlayback(const SkRecord* record) : fRecord(record) {}
+
+SkPlayback::~SkPlayback() {
+ SkDELETE(fRecord);
+}
+
+void SkPlayback::draw(SkCanvas* canvas) const {
+ SkASSERT(fRecord != NULL);
+ SkRecordDraw(*fRecord, canvas);
+}
+
+/*static*/ SkRecording* SkRecording::Create(int width, int height) {
+ return SkNEW_ARGS(SkRecording, (width, height));
+}
+
+SkRecording::SkRecording(int width, int height) {
+ SkRecord* record = SkNEW(SkRecord);
+ fRecorder = SkNEW_ARGS(SkRecorder, (SkRecorder::kReadWrite_Mode, record, width, height));
+ fRecord = record;
+}
+
+/*static*/ const SkPlayback* SkRecording::Delete(SkRecording* recording) {
+ const SkRecord* record = recording->fRecord;
+ SkDELETE(recording);
+ return SkNEW_ARGS(SkPlayback, (record));
+}
+
+SkRecording::~SkRecording() {
+ SkDELETE(fRecorder);
+}
+
+SkCanvas* SkRecording::canvas() {
+ return fRecorder;
+}
+
+} // namespace EXPERIMENTAL
--- /dev/null
+#include "Test.h"
+
+#include "SkRecording.h"
+
+// Minimally exercise the public SkRecording API.
+
+DEF_TEST(RecordingTest, r) {
+ EXPERIMENTAL::SkRecording* recording = EXPERIMENTAL::SkRecording::Create(1920, 1080);
+
+ // Some very exciting commands here.
+ recording->canvas()->clipRect(SkRect::MakeWH(320, 240));
+
+ SkAutoTDelete<const EXPERIMENTAL::SkPlayback> playback(
+ EXPERIMENTAL::SkRecording::Delete(recording));
+
+ SkCanvas target;
+ playback->draw(&target);
+}