Move externs into Factory
diff --git a/include/rive/artboard.hpp b/include/rive/artboard.hpp
index 1e483d4..3dcf69c 100644
--- a/include/rive/artboard.hpp
+++ b/include/rive/artboard.hpp
@@ -17,6 +17,7 @@
namespace rive {
class File;
class Drawable;
+ class Factory;
class Node;
class DrawTarget;
class ArtboardImporter;
@@ -42,6 +43,7 @@
unsigned int m_DirtDepth = 0;
std::unique_ptr<CommandPath> m_BackgroundPath;
std::unique_ptr<CommandPath> m_ClipPath;
+ Factory* m_Factory = nullptr;
Drawable* m_FirstDrawable = nullptr;
bool m_IsInstance = false;
bool m_FrameOrigin = true;
@@ -51,8 +53,11 @@
void sortDependencies();
void sortDrawOrder();
+ Artboard* getArtboard() override { return this; }
+
#ifdef TESTING
public:
+ Artboard(Factory* factory) : m_Factory(factory) {}
#endif
void addObject(Core* object);
void addAnimation(LinearAnimation* object);
@@ -62,15 +67,19 @@
void testing_only_enque_message(const Message&);
public:
+ Artboard() {}
~Artboard();
StatusCode initialize();
Core* resolve(uint32_t id) const override;
+
/// Find the id of a component in the artboard the object in the artboard. The artboard
/// itself has id 0 so we use that as a flag for not found.
uint32_t idOf(Core* object) const;
+ Factory* factory() const { return m_Factory; }
+
// EXPERIMENTAL -- for internal testing only for now.
// DO NOT RELY ON THIS as it may change/disappear in the future.
Core* hitTest(HitInfo*, const Mat2D* = nullptr);
@@ -161,6 +170,8 @@
class ArtboardInstance : public Artboard {
public:
+ ArtboardInstance() {}
+
std::unique_ptr<LinearAnimationInstance> animationAt(size_t index);
std::unique_ptr<LinearAnimationInstance> animationNamed(std::string name);
diff --git a/include/rive/assets/file_asset.hpp b/include/rive/assets/file_asset.hpp
index e2bff1d..01ef88e 100644
--- a/include/rive/assets/file_asset.hpp
+++ b/include/rive/assets/file_asset.hpp
@@ -1,12 +1,14 @@
#ifndef _RIVE_FILE_ASSET_HPP_
#define _RIVE_FILE_ASSET_HPP_
#include "rive/generated/assets/file_asset_base.hpp"
+#include "rive/span.hpp"
#include <string>
namespace rive {
+ class Factory;
class FileAsset : public FileAssetBase {
public:
- virtual bool decode(const uint8_t* bytes, std::size_t size) = 0;
+ virtual bool decode(Span<const uint8_t>, Factory*) = 0;
virtual std::string fileExtension() = 0;
StatusCode import(ImportStack& importStack) override;
diff --git a/include/rive/assets/image_asset.hpp b/include/rive/assets/image_asset.hpp
index 76718b9..9386fcf 100644
--- a/include/rive/assets/image_asset.hpp
+++ b/include/rive/assets/image_asset.hpp
@@ -2,24 +2,24 @@
#define _RIVE_IMAGE_ASSET_HPP_
#include "rive/generated/assets/image_asset_base.hpp"
+#include "rive/renderer.hpp"
#include <string>
namespace rive {
- class RenderImage;
class ImageAsset : public ImageAssetBase {
private:
- RenderImage* m_RenderImage;
+ std::unique_ptr<RenderImage> m_RenderImage;
public:
- ImageAsset();
+ ImageAsset() {}
~ImageAsset();
#ifdef TESTING
std::size_t decodedByteSize = 0;
#endif
- bool decode(const uint8_t* bytes, std::size_t size) override;
+ bool decode(Span<const uint8_t>, Factory*) override;
std::string fileExtension() override;
- RenderImage* renderImage() const { return m_RenderImage; }
+ RenderImage* renderImage() const { return m_RenderImage.get(); }
};
} // namespace rive
diff --git a/include/rive/core_context.hpp b/include/rive/core_context.hpp
index d8d7a4d..76ed0b2 100644
--- a/include/rive/core_context.hpp
+++ b/include/rive/core_context.hpp
@@ -4,6 +4,7 @@
#include "rive/rive_types.hpp"
namespace rive {
+ class Artboard;
class Core;
class CoreContext {
public:
diff --git a/include/rive/factory.hpp b/include/rive/factory.hpp
new file mode 100644
index 0000000..1960faf
--- /dev/null
+++ b/include/rive/factory.hpp
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2022 Rive
+ */
+
+#ifndef _RIVE_FACTORY_HPP_
+#define _RIVE_FACTORY_HPP_
+
+#include "rive/renderer.hpp"
+#include "rive/refcnt.hpp"
+#include "rive/span.hpp"
+#include "rive/math/aabb.hpp"
+#include "rive/math/mat2d.hpp"
+
+#include <cmath>
+#include <stdio.h>
+#include <cstdint>
+
+namespace rive {
+
+ class Factory {
+ public:
+ Factory() {}
+ virtual ~Factory() {}
+
+ virtual rcp<RenderBuffer> makeBufferU16(Span<const uint16_t>) = 0;
+ virtual rcp<RenderBuffer> makeBufferU32(Span<const uint32_t>) = 0;
+ virtual rcp<RenderBuffer> makeBufferF32(Span<const float>) = 0;
+
+ virtual rcp<RenderShader> makeLinearGradient(float sx, float sy,
+ float ex, float ey,
+ const ColorInt colors[], // [count]
+ const float stops[], // [count]
+ int count,
+ RenderTileMode,
+ const Mat2D* localMatrix = nullptr) = 0;
+
+ virtual rcp<RenderShader> makeRadialGradient(float cx, float cy, float radius,
+ const ColorInt colors[], // [count]
+ const float stops[], // [count]
+ int count,
+ RenderTileMode,
+ const Mat2D* localMatrix = nullptr) = 0;
+
+ // Returns a full-formed RenderPath -- can be treated as immutable
+ virtual std::unique_ptr<RenderPath> makeRenderPath(Span<const Vec2D> points,
+ Span<const uint8_t> verbs,
+ FillRule) = 0;
+
+ virtual std::unique_ptr<RenderPath> makeEmptyRenderPath() = 0;
+
+ virtual std::unique_ptr<RenderPaint> makeRenderPaint() = 0;
+
+ virtual std::unique_ptr<RenderImage> decodeImage(Span<const uint8_t>) = 0;
+ };
+
+} // namespace rive
+#endif
diff --git a/include/rive/file.hpp b/include/rive/file.hpp
index 419634e..c7b4017 100644
--- a/include/rive/file.hpp
+++ b/include/rive/file.hpp
@@ -3,6 +3,7 @@
#include "rive/artboard.hpp"
#include "rive/backboard.hpp"
+#include "rive/factory.hpp"
#include "rive/file_asset_resolver.hpp"
#include <vector>
@@ -12,6 +13,7 @@
namespace rive {
class BinaryReader;
class RuntimeHeader;
+ class Factory;
///
/// Tracks the success/failure result when importing a Rive file.
@@ -44,11 +46,13 @@
/// Rive components and animations.
std::vector<std::unique_ptr<Artboard>> m_Artboards;
+ Factory* m_Factory;
+
/// The helper used to resolve assets when they're not provided in-band
/// with the file.
FileAssetResolver* m_AssetResolver;
- File(FileAssetResolver* assetResolver);
+ File(Factory*, FileAssetResolver*);
public:
~File();
@@ -61,8 +65,9 @@
/// cannot be found in-band.
/// @returns a pointer to the file, or null on failure.
static std::unique_ptr<File> import(Span<const uint8_t> data,
- ImportResult* result = nullptr,
- FileAssetResolver* assetResolver = nullptr);
+ Factory*,
+ ImportResult* result = nullptr,
+ FileAssetResolver* assetResolver = nullptr);
/// @returns the file's backboard. All files have exactly one backboard.
Backboard* backboard() const { return m_Backboard.get(); }
@@ -87,7 +92,7 @@
Artboard* artboard(size_t index) const;
private:
- ImportResult read(BinaryReader& reader, const RuntimeHeader& header);
+ ImportResult read(BinaryReader&, const RuntimeHeader&);
};
} // namespace rive
-#endif
\ No newline at end of file
+#endif
diff --git a/include/rive/importers/file_asset_importer.hpp b/include/rive/importers/file_asset_importer.hpp
index 6ad9d0c..170a440 100644
--- a/include/rive/importers/file_asset_importer.hpp
+++ b/include/rive/importers/file_asset_importer.hpp
@@ -9,14 +9,17 @@
class FileAsset;
class FileAssetContents;
class FileAssetResolver;
+ class Factory;
+
class FileAssetImporter : public ImportStackObject {
private:
bool m_LoadedContents = false;
FileAsset* m_FileAsset;
FileAssetResolver* m_FileAssetResolver;
+ Factory* m_Factory;
public:
- FileAssetImporter(FileAsset* fileAsset, FileAssetResolver* assetResolver);
+ FileAssetImporter(FileAsset*, FileAssetResolver*, Factory*);
void loadContents(const FileAssetContents& contents);
StatusCode resolve() override;
};
diff --git a/include/rive/relative_local_asset_resolver.hpp b/include/rive/relative_local_asset_resolver.hpp
index 63a7edb..5aa3f4c 100644
--- a/include/rive/relative_local_asset_resolver.hpp
+++ b/include/rive/relative_local_asset_resolver.hpp
@@ -8,14 +8,19 @@
namespace rive {
class FileAsset;
+ class Factory;
+
/// An implementation of FileAssetResolver which finds the assets in a local
/// path relative to the original .riv file looking for them.
class RelativeLocalAssetResolver : public FileAssetResolver {
private:
std::string m_Path;
+ Factory* m_Factory;
public:
- RelativeLocalAssetResolver(std::string filename) {
+ RelativeLocalAssetResolver(std::string filename, Factory* factory)
+ : m_Factory(factory)
+ {
std::size_t finalSlash = filename.rfind('/');
if (finalSlash != std::string::npos) {
@@ -32,7 +37,7 @@
fseek(fp, 0, SEEK_SET);
uint8_t* bytes = new uint8_t[length];
if (fread(bytes, 1, length, fp) == length) {
- asset.decode(bytes, length);
+ asset.decode(Span<const uint8_t>(bytes, length), m_Factory);
}
delete[] bytes;
}
diff --git a/include/rive/renderer.hpp b/include/rive/renderer.hpp
index affe81f..5d23576 100644
--- a/include/rive/renderer.hpp
+++ b/include/rive/renderer.hpp
@@ -1,3 +1,7 @@
+/*
+ * Copyright 2022 Rive
+ */
+
#ifndef _RIVE_RENDERER_HPP_
#define _RIVE_RENDERER_HPP_
@@ -8,10 +12,10 @@
#include "rive/span.hpp"
#include "rive/math/aabb.hpp"
#include "rive/math/mat2d.hpp"
-#include "rive/math/raw_path.hpp"
#include "rive/shapes/paint/blend_mode.hpp"
#include "rive/shapes/paint/stroke_cap.hpp"
#include "rive/shapes/paint/stroke_join.hpp"
+
#include <cmath>
#include <stdio.h>
#include <cstdint>
@@ -32,10 +36,6 @@
size_t count() const { return m_Count; }
};
- extern rcp<RenderBuffer> makeBufferU16(Span<const uint16_t>);
- extern rcp<RenderBuffer> makeBufferU32(Span<const uint32_t>);
- extern rcp<RenderBuffer> makeBufferF32(Span<const float>);
-
enum class RenderPaintStyle { stroke, fill };
enum class RenderTileMode {
@@ -55,32 +55,6 @@
*/
class RenderShader : public RefCnt {};
- extern rcp<RenderShader> makeLinearGradient(float sx,
- float sy,
- float ex,
- float ey,
- const ColorInt colors[], // [count]
- const float stops[], // [count]
- int count,
- RenderTileMode,
- const Mat2D* localMatrix = nullptr);
-
- extern rcp<RenderShader> makeRadialGradient(float cx,
- float cy,
- float radius,
- const ColorInt colors[], // [count]
- const float stops[], // [count]
- int count,
- RenderTileMode,
- const Mat2D* localMatrix = nullptr);
-
- extern rcp<RenderShader> makeSweepGradient(float cx,
- float cy,
- const ColorInt colors[], // [count]
- const float stops[], // [count]
- int count,
- const Mat2D* localMatrix = nullptr);
-
class RenderPaint {
public:
virtual void style(RenderPaintStyle style) = 0;
@@ -101,7 +75,6 @@
public:
virtual ~RenderImage() {}
- virtual bool decode(Span<const uint8_t>) = 0;
int width() const { return m_Width; }
int height() const { return m_Height; }
@@ -146,13 +119,5 @@
transform(computeAlignment(fit, alignment, frame, content));
}
};
-
- // Returns a full-formed RenderPath -- can be treated as immutable
- extern RenderPath*
- makeRenderPath(Span<const Vec2D> points, Span<const uint8_t> verbs, FillRule);
-
- extern RenderPath* makeRenderPath();
- extern RenderPaint* makeRenderPaint();
- extern RenderImage* makeRenderImage();
} // namespace rive
#endif
diff --git a/include/rive/shapes/clipping_shape.hpp b/include/rive/shapes/clipping_shape.hpp
index 4d01176..3ed3227 100644
--- a/include/rive/shapes/clipping_shape.hpp
+++ b/include/rive/shapes/clipping_shape.hpp
@@ -1,5 +1,6 @@
#ifndef _RIVE_CLIPPING_SHAPE_HPP_
#define _RIVE_CLIPPING_SHAPE_HPP_
+#include "rive/renderer.hpp"
#include "rive/generated/shapes/clipping_shape_base.hpp"
#include <stdio.h>
#include <vector>
@@ -12,10 +13,9 @@
private:
std::vector<Shape*> m_Shapes;
Node* m_Source = nullptr;
- RenderPath* m_RenderPath = nullptr;
+ std::unique_ptr<RenderPath> m_RenderPath;
public:
- ~ClippingShape();
Node* source() const { return m_Source; }
const std::vector<Shape*>& shapes() const { return m_Shapes; }
StatusCode onAddedClean(CoreContext* context) override;
@@ -23,7 +23,7 @@
void buildDependencies() override;
void update(ComponentDirt value) override;
- RenderPath* renderPath() const { return m_RenderPath; }
+ RenderPath* renderPath() const { return m_RenderPath.get(); }
};
} // namespace rive
diff --git a/include/rive/shapes/metrics_path.hpp b/include/rive/shapes/metrics_path.hpp
index c504c3a..daa694a 100644
--- a/include/rive/shapes/metrics_path.hpp
+++ b/include/rive/shapes/metrics_path.hpp
@@ -80,12 +80,11 @@
class RenderMetricsPath : public MetricsPath {
private:
- RenderPath* m_RenderPath;
+ std::unique_ptr<RenderPath> m_RenderPath;
public:
- RenderMetricsPath();
- ~RenderMetricsPath();
- RenderPath* renderPath() override { return m_RenderPath; }
+ RenderMetricsPath(std::unique_ptr<RenderPath>);
+ RenderPath* renderPath() override { return m_RenderPath.get(); }
void addPath(CommandPath* path, const Mat2D& transform) override;
void fillRule(FillRule value) override;
diff --git a/include/rive/shapes/paint/shape_paint.hpp b/include/rive/shapes/paint/shape_paint.hpp
index ed6b3b7..661adb7 100644
--- a/include/rive/shapes/paint/shape_paint.hpp
+++ b/include/rive/shapes/paint/shape_paint.hpp
@@ -10,11 +10,10 @@
class ShapePaintMutator;
class ShapePaint : public ShapePaintBase {
protected:
- RenderPaint* m_RenderPaint = nullptr;
+ std::unique_ptr<RenderPaint> m_RenderPaint;
ShapePaintMutator* m_PaintMutator = nullptr;
public:
- ~ShapePaint();
StatusCode onAddedClean(CoreContext* context) override;
float renderOpacity() const { return m_PaintMutator->renderOpacity(); }
@@ -31,6 +30,8 @@
virtual void draw(Renderer* renderer, CommandPath* path) = 0;
+ RenderPaint* renderPaint() { return m_RenderPaint.get(); }
+
/// Get the component that represents the ShapePaintMutator for this
/// ShapePaint. It'll be one of SolidColor, LinearGradient, or
/// RadialGradient.
diff --git a/include/rive/shapes/paint/stroke_effect.hpp b/include/rive/shapes/paint/stroke_effect.hpp
index bc40a4c..1db1423 100644
--- a/include/rive/shapes/paint/stroke_effect.hpp
+++ b/include/rive/shapes/paint/stroke_effect.hpp
@@ -1,12 +1,16 @@
#ifndef _RIVE_STROKE_EFFECT_HPP_
#define _RIVE_STROKE_EFFECT_HPP_
+
+#include "rive/rive_types.hpp"
+
namespace rive {
+ class Factory;
class RenderPath;
class MetricsPath;
class StrokeEffect {
public:
- virtual RenderPath* effectPath(MetricsPath* source) = 0;
+ virtual RenderPath* effectPath(MetricsPath* source, Factory*) = 0;
virtual void invalidateEffect() = 0;
};
} // namespace rive
diff --git a/include/rive/shapes/paint/trim_path.hpp b/include/rive/shapes/paint/trim_path.hpp
index 9806228..7289590 100644
--- a/include/rive/shapes/paint/trim_path.hpp
+++ b/include/rive/shapes/paint/trim_path.hpp
@@ -2,19 +2,18 @@
#define _RIVE_TRIM_PATH_HPP_
#include "rive/generated/shapes/paint/trim_path_base.hpp"
#include "rive/shapes/paint/stroke_effect.hpp"
+#include "rive/renderer.hpp"
#include <stdio.h>
namespace rive {
class TrimPath : public TrimPathBase, public StrokeEffect {
private:
- RenderPath* m_TrimmedPath;
+ std::unique_ptr<RenderPath> m_TrimmedPath;
RenderPath* m_RenderPath = nullptr;
public:
- TrimPath();
- ~TrimPath();
StatusCode onAddedClean(CoreContext* context) override;
- RenderPath* effectPath(MetricsPath* source) override;
+ RenderPath* effectPath(MetricsPath* source, Factory*) override;
void invalidateEffect() override;
void startChanged() override;
diff --git a/include/rive/shapes/shape.hpp b/include/rive/shapes/shape.hpp
index a4e6f37..8caf7f8 100644
--- a/include/rive/shapes/shape.hpp
+++ b/include/rive/shapes/shape.hpp
@@ -18,6 +18,8 @@
bool m_WantDifferencePath = false;
+ Artboard* getArtboard() override { return artboard(); }
+
public:
Shape();
void buildDependencies() override;
diff --git a/include/rive/shapes/shape_paint_container.hpp b/include/rive/shapes/shape_paint_container.hpp
index 1f1eede..89abf04 100644
--- a/include/rive/shapes/shape_paint_container.hpp
+++ b/include/rive/shapes/shape_paint_container.hpp
@@ -5,6 +5,7 @@
#include <vector>
namespace rive {
+ class Artboard;
class ShapePaint;
class Component;
@@ -14,6 +15,10 @@
friend class ShapePaint;
protected:
+ // Need this to access our artboard. We are treated as a mixin, either
+ // as a Shape or Artboard, so both of those will override this.
+ virtual Artboard* getArtboard() = 0;
+
PathSpace m_DefaultPathSpace = PathSpace::Neither;
std::vector<ShapePaint*> m_ShapePaints;
void addPaint(ShapePaint* paint);
diff --git a/skia/renderer/include/skia_factory.hpp b/skia/renderer/include/skia_factory.hpp
new file mode 100644
index 0000000..14abfa8
--- /dev/null
+++ b/skia/renderer/include/skia_factory.hpp
@@ -0,0 +1,40 @@
+#ifndef _RIVE_SKIA_FACTORY_HPP_
+#define _RIVE_SKIA_FACTORY_HPP_
+
+#include "rive/factory.hpp"
+
+namespace rive {
+
+class SkiaFactory : public Factory {
+ rcp<RenderBuffer> makeBufferU16(Span<const uint16_t>) override;
+ rcp<RenderBuffer> makeBufferU32(Span<const uint32_t>) override;
+ rcp<RenderBuffer> makeBufferF32(Span<const float>) override;
+
+ rcp<RenderShader> makeLinearGradient(float sx, float sy,
+ float ex, float ey,
+ const ColorInt colors[], // [count]
+ const float stops[], // [count]
+ int count,
+ RenderTileMode,
+ const Mat2D* localMatrix = nullptr) override;
+
+ rcp<RenderShader> makeRadialGradient(float cx, float cy, float radius,
+ const ColorInt colors[], // [count]
+ const float stops[], // [count]
+ int count,
+ RenderTileMode,
+ const Mat2D* localMatrix = nullptr) override;
+
+ std::unique_ptr<RenderPath> makeRenderPath(Span<const Vec2D> points,
+ Span<const uint8_t> verbs,
+ FillRule) override;
+
+ std::unique_ptr<RenderPath> makeEmptyRenderPath() override;
+
+ std::unique_ptr<RenderPaint> makeRenderPaint() override;
+
+ std::unique_ptr<RenderImage> decodeImage(Span<const uint8_t>) override;
+};
+
+} // namespace rive
+#endif
diff --git a/skia/renderer/include/skia_renderer.hpp b/skia/renderer/include/skia_renderer.hpp
index b6ea76b..706e663 100644
--- a/skia/renderer/include/skia_renderer.hpp
+++ b/skia/renderer/include/skia_renderer.hpp
@@ -1,59 +1,11 @@
#ifndef _RIVE_SKIA_RENDERER_HPP_
#define _RIVE_SKIA_RENDERER_HPP_
-#include "SkCanvas.h"
-#include "SkPaint.h"
-#include "SkPath.h"
-#include "SkImage.h"
#include "rive/renderer.hpp"
-#include <vector>
+
+class SkCanvas;
namespace rive {
- class SkiaRenderPath : public RenderPath {
- private:
- SkPath m_Path;
-
- public:
- SkiaRenderPath() {}
- SkiaRenderPath(SkPath&& path) : m_Path(std::move(path)) {}
-
- const SkPath& path() const { return m_Path; }
- void reset() override;
- void addRenderPath(RenderPath* path, const Mat2D& transform) override;
- void fillRule(FillRule value) override;
- void moveTo(float x, float y) override;
- void lineTo(float x, float y) override;
- void cubicTo(float ox, float oy, float ix, float iy, float x, float y) override;
- virtual void close() override;
- };
-
- class SkiaRenderPaint : public RenderPaint {
- private:
- SkPaint m_Paint;
-
- public:
- const SkPaint& paint() const { return m_Paint; }
- SkiaRenderPaint();
- void style(RenderPaintStyle style) override;
- void color(unsigned int value) override;
- void thickness(float value) override;
- void join(StrokeJoin value) override;
- void cap(StrokeCap value) override;
- void blendMode(BlendMode value) override;
- void shader(rcp<RenderShader>) override;
- };
-
- class SkiaRenderImage : public RenderImage {
- private:
- sk_sp<SkImage> m_SkImage;
-
- public:
- sk_sp<SkImage> skImage() const { return m_SkImage; };
- bool decode(Span<const uint8_t>) override;
- rcp<RenderShader>
- makeShader(RenderTileMode tx, RenderTileMode ty, const Mat2D* localMatrix) const override;
- };
-
class SkiaRenderer : public Renderer {
protected:
SkCanvas* m_Canvas;
diff --git a/skia/renderer/include/to_skia.hpp b/skia/renderer/include/to_skia.hpp
index c19bf7e..365b4c0 100644
--- a/skia/renderer/include/to_skia.hpp
+++ b/skia/renderer/include/to_skia.hpp
@@ -4,6 +4,7 @@
#include "SkPaint.h"
#include "rive/math/mat2d.hpp"
#include "rive/math/vec2d.hpp"
+#include "rive/renderer.hpp"
#include "rive/shapes/paint/stroke_cap.hpp"
#include "rive/shapes/paint/stroke_join.hpp"
#include "rive/shapes/paint/blend_mode.hpp"
diff --git a/skia/renderer/src/skia_factory.cpp b/skia/renderer/src/skia_factory.cpp
new file mode 100644
index 0000000..9f6b49b
--- /dev/null
+++ b/skia/renderer/src/skia_factory.cpp
@@ -0,0 +1,339 @@
+#include "skia_factory.hpp"
+
+#include "SkCanvas.h"
+#include "SkData.h"
+#include "SkGradientShader.h"
+#include "SkImage.h"
+#include "SkPaint.h"
+#include "SkPath.h"
+#include "SkVertices.h"
+#include "rive/math/vec2d.hpp"
+#include "rive/shapes/paint/color.hpp"
+#include "to_skia.hpp"
+
+using namespace rive;
+
+class SkiaRenderPath : public RenderPath {
+private:
+ SkPath m_Path;
+
+public:
+ SkiaRenderPath() {}
+ SkiaRenderPath(SkPath&& path) : m_Path(std::move(path)) {}
+
+ const SkPath& path() const { return m_Path; }
+
+ void reset() override;
+ void addRenderPath(RenderPath* path, const Mat2D& transform) override;
+ void fillRule(FillRule value) override;
+ void moveTo(float x, float y) override;
+ void lineTo(float x, float y) override;
+ void cubicTo(float ox, float oy, float ix, float iy, float x, float y) override;
+ virtual void close() override;
+};
+
+class SkiaRenderPaint : public RenderPaint {
+private:
+ SkPaint m_Paint;
+
+public:
+ SkiaRenderPaint();
+
+ const SkPaint& paint() const { return m_Paint; }
+
+ void style(RenderPaintStyle style) override;
+ void color(unsigned int value) override;
+ void thickness(float value) override;
+ void join(StrokeJoin value) override;
+ void cap(StrokeCap value) override;
+ void blendMode(BlendMode value) override;
+ void shader(rcp<RenderShader>) override;
+};
+
+class SkiaRenderImage : public RenderImage {
+private:
+ sk_sp<SkImage> m_SkImage;
+
+public:
+ SkiaRenderImage(sk_sp<SkImage> image);
+
+ sk_sp<SkImage> skImage() const { return m_SkImage; };
+
+ rcp<RenderShader>
+ makeShader(RenderTileMode tx, RenderTileMode ty, const Mat2D* localMatrix) const override;
+};
+
+class SkiaRenderer : public Renderer {
+protected:
+ SkCanvas* m_Canvas;
+
+public:
+ SkiaRenderer(SkCanvas* canvas) : m_Canvas(canvas) {}
+
+ void save() override;
+ void restore() override;
+ void transform(const Mat2D& transform) override;
+ void clipPath(RenderPath* path) override;
+ void drawPath(RenderPath* path, RenderPaint* paint) override;
+ void drawImage(const RenderImage*, BlendMode, float opacity) override;
+ void drawImageMesh(const RenderImage*,
+ rcp<RenderBuffer> vertices_f32,
+ rcp<RenderBuffer> uvCoords_f32,
+ rcp<RenderBuffer> indices_u16,
+ BlendMode,
+ float opacity) override;
+};
+
+class SkiaBuffer : public RenderBuffer {
+ const size_t m_ElemSize;
+ void* m_Buffer;
+
+public:
+ SkiaBuffer(const void* src, size_t count, size_t elemSize) :
+ RenderBuffer(count), m_ElemSize(elemSize) {
+ size_t bytes = count * elemSize;
+ m_Buffer = malloc(bytes);
+ memcpy(m_Buffer, src, bytes);
+ }
+
+ ~SkiaBuffer() { free(m_Buffer); }
+
+ const float* f32s() const {
+ assert(m_ElemSize == sizeof(float));
+ return static_cast<const float*>(m_Buffer);
+ }
+
+ const uint16_t* u16s() const {
+ assert(m_ElemSize == sizeof(uint16_t));
+ return static_cast<const uint16_t*>(m_Buffer);
+ }
+
+ const SkPoint* points() const { return reinterpret_cast<const SkPoint*>(this->f32s()); }
+
+ static const SkiaBuffer* Cast(const RenderBuffer* buffer) {
+ return reinterpret_cast<const SkiaBuffer*>(buffer);
+ }
+};
+
+template <typename T> rcp<RenderBuffer> make_buffer(Span<T> span) {
+ return rcp<RenderBuffer>(new SkiaBuffer(span.data(), span.size(), sizeof(T)));
+}
+
+class SkiaRenderShader : public RenderShader {
+public:
+ SkiaRenderShader(sk_sp<SkShader> sh) : shader(std::move(sh)) {}
+
+ sk_sp<SkShader> shader;
+};
+
+void SkiaRenderPath::fillRule(FillRule value) { m_Path.setFillType(ToSkia::convert(value)); }
+
+void SkiaRenderPath::reset() { m_Path.reset(); }
+void SkiaRenderPath::addRenderPath(RenderPath* path, const Mat2D& transform) {
+ m_Path.addPath(reinterpret_cast<SkiaRenderPath*>(path)->m_Path, ToSkia::convert(transform));
+}
+
+void SkiaRenderPath::moveTo(float x, float y) { m_Path.moveTo(x, y); }
+void SkiaRenderPath::lineTo(float x, float y) { m_Path.lineTo(x, y); }
+void SkiaRenderPath::cubicTo(float ox, float oy, float ix, float iy, float x, float y) {
+ m_Path.cubicTo(ox, oy, ix, iy, x, y);
+}
+void SkiaRenderPath::close() { m_Path.close(); }
+
+SkiaRenderPaint::SkiaRenderPaint() { m_Paint.setAntiAlias(true); }
+
+void SkiaRenderPaint::style(RenderPaintStyle style) {
+ switch (style) {
+ case RenderPaintStyle::fill:
+ m_Paint.setStyle(SkPaint::Style::kFill_Style);
+ break;
+ case RenderPaintStyle::stroke:
+ m_Paint.setStyle(SkPaint::Style::kStroke_Style);
+ break;
+ }
+}
+void SkiaRenderPaint::color(unsigned int value) { m_Paint.setColor(value); }
+void SkiaRenderPaint::thickness(float value) { m_Paint.setStrokeWidth(value); }
+void SkiaRenderPaint::join(StrokeJoin value) { m_Paint.setStrokeJoin(ToSkia::convert(value)); }
+void SkiaRenderPaint::cap(StrokeCap value) { m_Paint.setStrokeCap(ToSkia::convert(value)); }
+
+void SkiaRenderPaint::blendMode(BlendMode value) { m_Paint.setBlendMode(ToSkia::convert(value)); }
+
+void SkiaRenderPaint::shader(rcp<RenderShader> rsh) {
+ SkiaRenderShader* sksh = (SkiaRenderShader*)rsh.get();
+ m_Paint.setShader(sksh ? sksh->shader : nullptr);
+}
+
+void SkiaRenderer::save() { m_Canvas->save(); }
+void SkiaRenderer::restore() { m_Canvas->restore(); }
+void SkiaRenderer::transform(const Mat2D& transform) {
+ m_Canvas->concat(ToSkia::convert(transform));
+}
+void SkiaRenderer::drawPath(RenderPath* path, RenderPaint* paint) {
+ m_Canvas->drawPath(reinterpret_cast<SkiaRenderPath*>(path)->path(),
+ reinterpret_cast<SkiaRenderPaint*>(paint)->paint());
+}
+
+void SkiaRenderer::clipPath(RenderPath* path) {
+ m_Canvas->clipPath(reinterpret_cast<SkiaRenderPath*>(path)->path(), true);
+}
+
+void SkiaRenderer::drawImage(const RenderImage* image, BlendMode blendMode, float opacity) {
+ SkPaint paint;
+ paint.setAlphaf(opacity);
+ paint.setBlendMode(ToSkia::convert(blendMode));
+ auto skiaImage = reinterpret_cast<const SkiaRenderImage*>(image);
+ SkSamplingOptions sampling(SkFilterMode::kLinear);
+ m_Canvas->drawImage(skiaImage->skImage(), 0.0f, 0.0f, sampling, &paint);
+}
+
+#define SKIA_BUG_13047
+
+void SkiaRenderer::drawImageMesh(const RenderImage* image,
+ rcp<RenderBuffer> vertices,
+ rcp<RenderBuffer> uvCoords,
+ rcp<RenderBuffer> indices,
+ BlendMode blendMode,
+ float opacity) {
+ // need our vertices and uvs to agree
+ assert(vertices->count() == uvCoords->count());
+ // vertices and uvs are arrays of floats, so we need their counts to be
+ // even, since we treat them as arrays of points
+ assert((vertices->count() & 1) == 0);
+
+ const int vertexCount = vertices->count() >> 1;
+
+ SkMatrix scaleM;
+
+ const SkPoint* uvs = SkiaBuffer::Cast(uvCoords.get())->points();
+
+#ifdef SKIA_BUG_13047
+ // The local matrix is ignored for drawVertices, so we have to manually scale
+ // the UVs to match Skia's convention...
+ std::vector<SkPoint> scaledUVs(vertexCount);
+ for (int i = 0; i < vertexCount; ++i) {
+ scaledUVs[i] = {uvs[i].fX * image->width(), uvs[i].fY * image->height()};
+ }
+ uvs = scaledUVs.data();
+#else
+ // We do this because our UVs are normalized, but Skia expects them to be
+ // sized to the shader (i.e. 0..width, 0..height).
+ // To accomdate this, we effectively scaling the image down to 0..1 to
+ // match the scale of the UVs.
+ scaleM = SkMatrix::Scale(2.0f / image->width(), 2.0f / image->height());
+#endif
+
+ auto skiaImage = reinterpret_cast<const SkiaRenderImage*>(image)->skImage();
+ const SkSamplingOptions sampling(SkFilterMode::kLinear);
+ auto shader = skiaImage->makeShader(SkTileMode::kClamp, SkTileMode::kClamp, sampling, &scaleM);
+
+ SkPaint paint;
+ paint.setAlphaf(opacity);
+ paint.setBlendMode(ToSkia::convert(blendMode));
+ paint.setShader(shader);
+
+ const SkColor* no_colors = nullptr;
+ auto vertexMode = SkVertices::kTriangles_VertexMode;
+ // clang-format off
+ auto vt = SkVertices::MakeCopy(vertexMode,
+ vertexCount,
+ SkiaBuffer::Cast(vertices.get())->points(),
+ uvs,
+ no_colors,
+ indices->count(),
+ SkiaBuffer::Cast(indices.get())->u16s());
+ // clang-format on
+
+ // The blend mode is ignored if we don't have colors && uvs
+ m_Canvas->drawVertices(vt, SkBlendMode::kModulate, paint);
+}
+
+SkiaRenderImage::SkiaRenderImage(sk_sp<SkImage> image) : m_SkImage(std::move(image)) {
+ m_Width = m_SkImage->width();
+ m_Height = m_SkImage->height();
+}
+
+rcp<RenderShader>
+SkiaRenderImage::makeShader(RenderTileMode tx, RenderTileMode ty, const Mat2D* localMatrix) const {
+ const SkMatrix lm = localMatrix ? ToSkia::convert(*localMatrix) : SkMatrix();
+ const SkSamplingOptions options(SkFilterMode::kLinear);
+ auto sh = m_SkImage->makeShader(ToSkia::convert(tx), ToSkia::convert(ty), options, &lm);
+ return rcp<RenderShader>(new SkiaRenderShader(std::move(sh)));
+}
+
+// Factory
+
+rcp<RenderBuffer> SkiaFactory::makeBufferU16(Span<const uint16_t> data) {
+ return make_buffer(data);
+}
+
+rcp<RenderBuffer> SkiaFactory::makeBufferU32(Span<const uint32_t> data) {
+ return make_buffer(data);
+}
+
+rcp<RenderBuffer> SkiaFactory::makeBufferF32(Span<const float> data) {
+ return make_buffer(data);
+}
+
+rcp<RenderShader> SkiaFactory::makeLinearGradient(float sx, float sy,
+ float ex, float ey,
+ const ColorInt colors[], // [count]
+ const float stops[], // [count]
+ int count,
+ RenderTileMode mode,
+ const Mat2D* localMatrix) {
+ const SkPoint pts[] = {{sx, sy}, {ex, ey}};
+ const SkMatrix lm = localMatrix ? ToSkia::convert(*localMatrix) : SkMatrix();
+ auto sh = SkGradientShader::MakeLinear(
+ pts, (const SkColor*)colors, stops, count, ToSkia::convert(mode), 0, &lm);
+ return rcp<RenderShader>(new SkiaRenderShader(std::move(sh)));
+}
+
+rcp<RenderShader> SkiaFactory::makeRadialGradient(float cx, float cy, float radius,
+ const ColorInt colors[], // [count]
+ const float stops[], // [count]
+ int count,
+ RenderTileMode mode,
+ const Mat2D* localMatrix) {
+ const SkMatrix lm = localMatrix ? ToSkia::convert(*localMatrix) : SkMatrix();
+ auto sh = SkGradientShader::MakeRadial(
+ {cx, cy}, radius, (const SkColor*)colors, stops, count, ToSkia::convert(mode), 0, &lm);
+ return rcp<RenderShader>(new SkiaRenderShader(std::move(sh)));
+}
+
+std::unique_ptr<RenderPath> SkiaFactory::makeRenderPath(Span<const Vec2D> points,
+ Span<const uint8_t> verbs,
+ FillRule fillRule) {
+ const bool isVolatile = false; // ???
+ const SkScalar* conicWeights = nullptr;
+ const int conicWeightCount = 0;
+ return std::make_unique<SkiaRenderPath>(SkPath::Make(reinterpret_cast<const SkPoint*>(points.data()),
+ points.count(),
+ verbs.data(),
+ verbs.count(),
+ conicWeights,
+ conicWeightCount,
+ ToSkia::convert(fillRule),
+ isVolatile));
+}
+
+std::unique_ptr<RenderPath> SkiaFactory::makeEmptyRenderPath() {
+ return std::make_unique<SkiaRenderPath>();
+}
+
+std::unique_ptr<RenderPaint> SkiaFactory::makeRenderPaint() {
+ return std::make_unique<SkiaRenderPaint>();
+}
+
+std::unique_ptr<RenderImage> SkiaFactory::decodeImage(Span<const uint8_t> encoded) {
+ sk_sp<SkData> data = SkData::MakeWithoutCopy(encoded.data(), encoded.size());
+ auto image = SkImage::MakeFromEncoded(data);
+
+ // Our optimized skia buld seems to have broken lazy-image decode.
+ // As a work-around for now, force the image to be decoded.
+ if (image) {
+ image = image->makeRasterImage();
+ }
+
+ return image ? std::make_unique<SkiaRenderImage>(std::move(image)) : nullptr;
+}
diff --git a/skia/renderer/src/skia_renderer.cpp b/skia/renderer/src/skia_renderer.cpp
deleted file mode 100644
index 8628a85..0000000
--- a/skia/renderer/src/skia_renderer.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-#include "skia_renderer.hpp"
-#include "SkData.h"
-#include "SkGradientShader.h"
-#include "SkPath.h"
-#include "SkVertices.h"
-#include "rive/math/vec2d.hpp"
-#include "rive/shapes/paint/color.hpp"
-#include "to_skia.hpp"
-
-using namespace rive;
-
-class SkiaBuffer : public RenderBuffer {
- const size_t m_ElemSize;
- void* m_Buffer;
-
-public:
- SkiaBuffer(const void* src, size_t count, size_t elemSize) :
- RenderBuffer(count), m_ElemSize(elemSize) {
- size_t bytes = count * elemSize;
- m_Buffer = malloc(bytes);
- memcpy(m_Buffer, src, bytes);
- }
-
- ~SkiaBuffer() { free(m_Buffer); }
-
- const float* f32s() const {
- assert(m_ElemSize == sizeof(float));
- return static_cast<const float*>(m_Buffer);
- }
-
- const uint16_t* u16s() const {
- assert(m_ElemSize == sizeof(uint16_t));
- return static_cast<const uint16_t*>(m_Buffer);
- }
-
- const SkPoint* points() const { return reinterpret_cast<const SkPoint*>(this->f32s()); }
-
- static const SkiaBuffer* Cast(const RenderBuffer* buffer) {
- return reinterpret_cast<const SkiaBuffer*>(buffer);
- }
-};
-
-template <typename T> rcp<RenderBuffer> make_buffer(Span<T> span) {
- return rcp<RenderBuffer>(new SkiaBuffer(span.data(), span.size(), sizeof(T)));
-}
-
-class SkiaRenderShader : public RenderShader {
-public:
- SkiaRenderShader(sk_sp<SkShader> sh) : shader(std::move(sh)) {}
-
- sk_sp<SkShader> shader;
-};
-
-void SkiaRenderPath::fillRule(FillRule value) { m_Path.setFillType(ToSkia::convert(value)); }
-
-void SkiaRenderPath::reset() { m_Path.reset(); }
-void SkiaRenderPath::addRenderPath(RenderPath* path, const Mat2D& transform) {
- m_Path.addPath(reinterpret_cast<SkiaRenderPath*>(path)->m_Path, ToSkia::convert(transform));
-}
-
-void SkiaRenderPath::moveTo(float x, float y) { m_Path.moveTo(x, y); }
-void SkiaRenderPath::lineTo(float x, float y) { m_Path.lineTo(x, y); }
-void SkiaRenderPath::cubicTo(float ox, float oy, float ix, float iy, float x, float y) {
- m_Path.cubicTo(ox, oy, ix, iy, x, y);
-}
-void SkiaRenderPath::close() { m_Path.close(); }
-
-SkiaRenderPaint::SkiaRenderPaint() { m_Paint.setAntiAlias(true); }
-
-void SkiaRenderPaint::style(RenderPaintStyle style) {
- switch (style) {
- case RenderPaintStyle::fill:
- m_Paint.setStyle(SkPaint::Style::kFill_Style);
- break;
- case RenderPaintStyle::stroke:
- m_Paint.setStyle(SkPaint::Style::kStroke_Style);
- break;
- }
-}
-void SkiaRenderPaint::color(unsigned int value) { m_Paint.setColor(value); }
-void SkiaRenderPaint::thickness(float value) { m_Paint.setStrokeWidth(value); }
-void SkiaRenderPaint::join(StrokeJoin value) { m_Paint.setStrokeJoin(ToSkia::convert(value)); }
-void SkiaRenderPaint::cap(StrokeCap value) { m_Paint.setStrokeCap(ToSkia::convert(value)); }
-
-void SkiaRenderPaint::blendMode(BlendMode value) { m_Paint.setBlendMode(ToSkia::convert(value)); }
-
-void SkiaRenderPaint::shader(rcp<RenderShader> rsh) {
- SkiaRenderShader* sksh = (SkiaRenderShader*)rsh.get();
- m_Paint.setShader(sksh ? sksh->shader : nullptr);
-}
-
-void SkiaRenderer::save() { m_Canvas->save(); }
-void SkiaRenderer::restore() { m_Canvas->restore(); }
-void SkiaRenderer::transform(const Mat2D& transform) {
- m_Canvas->concat(ToSkia::convert(transform));
-}
-void SkiaRenderer::drawPath(RenderPath* path, RenderPaint* paint) {
- m_Canvas->drawPath(reinterpret_cast<SkiaRenderPath*>(path)->path(),
- reinterpret_cast<SkiaRenderPaint*>(paint)->paint());
-}
-
-void SkiaRenderer::clipPath(RenderPath* path) {
- m_Canvas->clipPath(reinterpret_cast<SkiaRenderPath*>(path)->path(), true);
-}
-
-void SkiaRenderer::drawImage(const RenderImage* image, BlendMode blendMode, float opacity) {
- SkPaint paint;
- paint.setAlphaf(opacity);
- paint.setBlendMode(ToSkia::convert(blendMode));
- auto skiaImage = reinterpret_cast<const SkiaRenderImage*>(image);
- SkSamplingOptions sampling(SkFilterMode::kLinear);
- m_Canvas->drawImage(skiaImage->skImage(), 0.0f, 0.0f, sampling, &paint);
-}
-
-#define SKIA_BUG_13047
-
-void SkiaRenderer::drawImageMesh(const RenderImage* image,
- rcp<RenderBuffer> vertices,
- rcp<RenderBuffer> uvCoords,
- rcp<RenderBuffer> indices,
- BlendMode blendMode,
- float opacity) {
- // need our vertices and uvs to agree
- assert(vertices->count() == uvCoords->count());
- // vertices and uvs are arrays of floats, so we need their counts to be
- // even, since we treat them as arrays of points
- assert((vertices->count() & 1) == 0);
-
- const int vertexCount = vertices->count() >> 1;
-
- SkMatrix scaleM;
-
- const SkPoint* uvs = SkiaBuffer::Cast(uvCoords.get())->points();
-
-#ifdef SKIA_BUG_13047
- // The local matrix is ignored for drawVertices, so we have to manually scale
- // the UVs to match Skia's convention...
- std::vector<SkPoint> scaledUVs(vertexCount);
- for (int i = 0; i < vertexCount; ++i) {
- scaledUVs[i] = {uvs[i].fX * image->width(), uvs[i].fY * image->height()};
- }
- uvs = scaledUVs.data();
-#else
- // We do this because our UVs are normalized, but Skia expects them to be
- // sized to the shader (i.e. 0..width, 0..height).
- // To accomdate this, we effectively scaling the image down to 0..1 to
- // match the scale of the UVs.
- scaleM = SkMatrix::Scale(2.0f / image->width(), 2.0f / image->height());
-#endif
-
- auto skiaImage = reinterpret_cast<const SkiaRenderImage*>(image)->skImage();
- const SkSamplingOptions sampling(SkFilterMode::kLinear);
- auto shader = skiaImage->makeShader(SkTileMode::kClamp, SkTileMode::kClamp, sampling, &scaleM);
-
- SkPaint paint;
- paint.setAlphaf(opacity);
- paint.setBlendMode(ToSkia::convert(blendMode));
- paint.setShader(shader);
-
- const SkColor* no_colors = nullptr;
- auto vertexMode = SkVertices::kTriangles_VertexMode;
- // clang-format off
- auto vt = SkVertices::MakeCopy(vertexMode,
- vertexCount,
- SkiaBuffer::Cast(vertices.get())->points(),
- uvs,
- no_colors,
- indices->count(),
- SkiaBuffer::Cast(indices.get())->u16s());
- // clang-format on
-
- // The blend mode is ignored if we don't have colors && uvs
- m_Canvas->drawVertices(vt, SkBlendMode::kModulate, paint);
-}
-
-bool SkiaRenderImage::decode(Span<const uint8_t> encodedData) {
-
- sk_sp<SkData> data = SkData::MakeWithoutCopy(encodedData.data(), encodedData.size());
- m_SkImage = SkImage::MakeFromEncoded(data);
-
- // Our optimized skia buld seems to have broken lazy-image decode.
- // As a work-around for now, force the image to be decoded.
- if (m_SkImage) {
- m_SkImage = m_SkImage->makeRasterImage();
- }
-
- if (m_SkImage) {
- m_Width = m_SkImage->width();
- m_Height = m_SkImage->height();
- return true;
- }
- return false;
-}
-
-rcp<RenderShader>
-SkiaRenderImage::makeShader(RenderTileMode tx, RenderTileMode ty, const Mat2D* localMatrix) const {
- const SkMatrix lm = localMatrix ? ToSkia::convert(*localMatrix) : SkMatrix();
- const SkSamplingOptions options(SkFilterMode::kLinear);
- auto sh = m_SkImage->makeShader(ToSkia::convert(tx), ToSkia::convert(ty), options, &lm);
- return rcp<RenderShader>(new SkiaRenderShader(std::move(sh)));
-}
-
-namespace rive {
- rcp<RenderBuffer> makeBufferU16(Span<const uint16_t> data) { return make_buffer(data); }
- rcp<RenderBuffer> makeBufferU32(Span<const uint32_t> data) { return make_buffer(data); }
- rcp<RenderBuffer> makeBufferF32(Span<const float> data) { return make_buffer(data); }
-
- RenderPath*
- makeRenderPath(Span<const Vec2D> points, Span<const uint8_t> verbs, FillRule fillrule) {
- return new SkiaRenderPath(SkPath::Make((const SkPoint*)points.data(),
- points.size(),
- verbs.data(),
- verbs.size(),
- nullptr,
- 0, // conics
- ToSkia::convert(fillrule),
- false));
- }
-
- RenderPath* makeRenderPath() { return new SkiaRenderPath(); }
- RenderPaint* makeRenderPaint() { return new SkiaRenderPaint(); }
- RenderImage* makeRenderImage() { return new SkiaRenderImage(); }
-
- rcp<RenderShader> makeLinearGradient(float sx,
- float sy,
- float ex,
- float ey,
- const ColorInt colors[],
- const float stops[],
- int count,
- RenderTileMode mode,
- const Mat2D* localm) {
- const SkPoint pts[] = {{sx, sy}, {ex, ey}};
- const SkMatrix lm = localm ? ToSkia::convert(*localm) : SkMatrix();
- auto sh = SkGradientShader::MakeLinear(
- pts, (const SkColor*)colors, stops, count, ToSkia::convert(mode), 0, &lm);
- return rcp<RenderShader>(new SkiaRenderShader(std::move(sh)));
- }
-
- rcp<RenderShader> makeRadialGradient(float cx,
- float cy,
- float radius,
- const ColorInt colors[],
- const float stops[],
- int count,
- RenderTileMode mode,
- const Mat2D* localm) {
- const SkMatrix lm = localm ? ToSkia::convert(*localm) : SkMatrix();
- auto sh = SkGradientShader::MakeRadial(
- {cx, cy}, radius, (const SkColor*)colors, stops, count, ToSkia::convert(mode), 0, &lm);
- return rcp<RenderShader>(new SkiaRenderShader(std::move(sh)));
- }
-
- rcp<RenderShader> makeSweepGradient(float cx,
- float cy,
- const ColorInt colors[],
- const float stops[],
- int count,
- RenderTileMode mode,
- const Mat2D* localm) {
- const SkMatrix lm = localm ? ToSkia::convert(*localm) : SkMatrix();
- auto sh = SkGradientShader::MakeSweep(cx, cy, (const SkColor*)colors, stops, count, 0, &lm);
- return rcp<RenderShader>(new SkiaRenderShader(std::move(sh)));
- }
-} // namespace rive
diff --git a/skia/viewer/src/main.cpp b/skia/viewer/src/main.cpp
index eb2e6e2..0115a33 100644
--- a/skia/viewer/src/main.cpp
+++ b/skia/viewer/src/main.cpp
@@ -23,6 +23,7 @@
#include "rive/file.hpp"
#include "rive/layout.hpp"
#include "rive/math/aabb.hpp"
+#include "skia_factory.hpp"
#include "skia_renderer.hpp"
#include "imgui/backends/imgui_impl_glfw.h"
@@ -31,6 +32,8 @@
#include <cmath>
#include <stdio.h>
+rive::SkiaFactory skiaFactory;
+
std::string filename;
std::unique_ptr<rive::File> currentFile;
std::unique_ptr<rive::ArtboardInstance> artboardInstance;
@@ -68,7 +71,7 @@
stateMachineIndex = index;
animationIndex = -1;
assert(fileBytes.size() != 0);
- auto file = rive::File::import(rive::toSpan(fileBytes));
+ auto file = rive::File::import(rive::toSpan(fileBytes), &skiaFactory);
if (!file) {
fileBytes.clear();
fprintf(stderr, "failed to import file\n");
@@ -92,7 +95,7 @@
animationIndex = index;
stateMachineIndex = -1;
assert(fileBytes.size() != 0);
- auto file = rive::File::import(rive::toSpan(fileBytes));
+ auto file = rive::File::import(rive::toSpan(fileBytes), &skiaFactory);
if (!file) {
fileBytes.clear();
fprintf(stderr, "failed to import file\n");
diff --git a/src/artboard.cpp b/src/artboard.cpp
index 37a3745..91437b0 100644
--- a/src/artboard.cpp
+++ b/src/artboard.cpp
@@ -521,6 +521,7 @@
std::unique_ptr<ArtboardInstance> artboardClone(new ArtboardInstance);
artboardClone->copy(*this);
+ artboardClone->m_Factory = m_Factory;
artboardClone->m_FrameOrigin = m_FrameOrigin;
std::vector<Core*>& cloneObjects = artboardClone->m_Objects;
diff --git a/src/assets/image_asset.cpp b/src/assets/image_asset.cpp
index 6988c1b..7fe6304 100644
--- a/src/assets/image_asset.cpp
+++ b/src/assets/image_asset.cpp
@@ -1,16 +1,17 @@
#include "rive/assets/image_asset.hpp"
-#include "rive/renderer.hpp"
+#include "rive/artboard.hpp"
+#include "rive/factory.hpp"
using namespace rive;
-ImageAsset::ImageAsset() : m_RenderImage(makeRenderImage()) {}
+ImageAsset::~ImageAsset() {}
-ImageAsset::~ImageAsset() { delete m_RenderImage; }
-bool ImageAsset::decode(const uint8_t* bytes, std::size_t size) {
+bool ImageAsset::decode(Span<const uint8_t> data, Factory* factory) {
#ifdef TESTING
- decodedByteSize = size;
+ decodedByteSize = data.size();
#endif
- return m_RenderImage->decode({bytes, size});
+ m_RenderImage = factory->decodeImage(data);
+ return m_RenderImage != nullptr;
}
std::string ImageAsset::fileExtension() { return "png"; }
diff --git a/src/file.cpp b/src/file.cpp
index 6a17dbb..b59eee0 100644
--- a/src/file.cpp
+++ b/src/file.cpp
@@ -108,12 +108,18 @@
return object;
}
-File::File(FileAssetResolver* assetResolver) : m_AssetResolver(assetResolver) {}
+File::File(Factory* factory, FileAssetResolver* assetResolver)
+ : m_Factory(factory)
+ , m_AssetResolver(assetResolver)
+{
+ assert(factory);
+}
File::~File() {}
std::unique_ptr<File>
-File::import(Span<const uint8_t> bytes, ImportResult* result, FileAssetResolver* assetResolver) {
+File::import(Span<const uint8_t> bytes, Factory* factory,
+ ImportResult* result, FileAssetResolver* assetResolver) {
BinaryReader reader(bytes);
RuntimeHeader header;
if (!RuntimeHeader::read(reader, header)) {
@@ -135,7 +141,7 @@
}
return nullptr;
}
- auto file = std::unique_ptr<File>(new File(assetResolver));
+ auto file = std::unique_ptr<File>(new File(factory, assetResolver));
auto readResult = file->read(reader, header);
if (readResult != ImportResult::success) {
file.reset(nullptr);
@@ -159,9 +165,11 @@
case Backboard::typeKey:
m_Backboard.reset(object->as<Backboard>());
break;
- case Artboard::typeKey:
- m_Artboards.push_back(std::unique_ptr<Artboard>(object->as<Artboard>()));
- break;
+ case Artboard::typeKey: {
+ Artboard* ab = object->as<Artboard>();
+ ab->m_Factory = m_Factory;
+ m_Artboards.push_back(std::unique_ptr<Artboard>(ab));
+ } break;
}
} else {
fprintf(stderr, "Failed to import object of type %d\n", object->coreType());
@@ -226,7 +234,7 @@
stackObject = new StateMachineEventImporter(object->as<StateMachineEvent>());
break;
case ImageAsset::typeKey:
- stackObject = new FileAssetImporter(object->as<FileAsset>(), m_AssetResolver);
+ stackObject = new FileAssetImporter(object->as<FileAsset>(), m_AssetResolver, m_Factory);
stackType = FileAsset::typeKey;
break;
}
diff --git a/src/importers/file_asset_importer.cpp b/src/importers/file_asset_importer.cpp
index 0357271..0d66c3c 100644
--- a/src/importers/file_asset_importer.cpp
+++ b/src/importers/file_asset_importer.cpp
@@ -7,12 +7,15 @@
using namespace rive;
-FileAssetImporter::FileAssetImporter(FileAsset* fileAsset, FileAssetResolver* assetResolver) :
- m_FileAsset(fileAsset), m_FileAssetResolver(assetResolver) {}
+FileAssetImporter::FileAssetImporter(FileAsset* fileAsset, FileAssetResolver* assetResolver, Factory* factory) :
+ m_FileAsset(fileAsset),
+ m_FileAssetResolver(assetResolver),
+ m_Factory(factory)
+{}
void FileAssetImporter::loadContents(const FileAssetContents& contents) {
auto data = contents.bytes();
- if (m_FileAsset->decode(data.begin(), data.size())) {
+ if (m_FileAsset->decode(data, m_Factory)) {
m_LoadedContents = true;
}
}
diff --git a/src/shapes/clipping_shape.cpp b/src/shapes/clipping_shape.cpp
index f9bbc7d..2889b4e 100644
--- a/src/shapes/clipping_shape.cpp
+++ b/src/shapes/clipping_shape.cpp
@@ -1,6 +1,7 @@
#include "rive/shapes/clipping_shape.hpp"
#include "rive/artboard.hpp"
#include "rive/core_context.hpp"
+#include "rive/factory.hpp"
#include "rive/node.hpp"
#include "rive/renderer.hpp"
#include "rive/shapes/path_composer.hpp"
@@ -47,7 +48,7 @@
}
}
- m_RenderPath = rive::makeRenderPath();
+ m_RenderPath = artboard->factory()->makeEmptyRenderPath();
return StatusCode::Ok;
}
@@ -86,5 +87,3 @@
}
}
}
-
-ClippingShape::~ClippingShape() { delete m_RenderPath; }
\ No newline at end of file
diff --git a/src/shapes/mesh.cpp b/src/shapes/mesh.cpp
index 5f24336..fa8234f 100644
--- a/src/shapes/mesh.cpp
+++ b/src/shapes/mesh.cpp
@@ -3,6 +3,8 @@
#include "rive/shapes/vertex.hpp"
#include "rive/shapes/mesh_vertex.hpp"
#include "rive/bones/skin.hpp"
+#include "rive/artboard.hpp"
+#include "rive/factory.hpp"
#include "rive/span.hpp"
#include <limits>
@@ -90,8 +92,10 @@
uv[index++] = vertex->u();
uv[index++] = vertex->v();
}
- m_UVRenderBuffer = makeBufferF32(toSpan(uv));
- m_IndexRenderBuffer = makeBufferU16(toSpan(*m_IndexBuffer));
+
+ auto factory = artboard()->factory();
+ m_UVRenderBuffer = factory->makeBufferF32(toSpan(uv));
+ m_IndexRenderBuffer = factory->makeBufferU16(toSpan(*m_IndexBuffer));
}
void Mesh::update(ComponentDirt value) {
@@ -114,7 +118,9 @@
vertices[index++] = translation[0];
vertices[index++] = translation[1];
}
- m_VertexRenderBuffer = makeBufferF32(toSpan(vertices));
+
+ auto factory = artboard()->factory();
+ m_VertexRenderBuffer = factory->makeBufferF32(toSpan(vertices));
}
if (skin() == nullptr) {
diff --git a/src/shapes/metrics_path.cpp b/src/shapes/metrics_path.cpp
index 6399d6c..3574eef 100644
--- a/src/shapes/metrics_path.cpp
+++ b/src/shapes/metrics_path.cpp
@@ -354,8 +354,9 @@
}
}
-RenderMetricsPath::RenderMetricsPath() : m_RenderPath(makeRenderPath()) {}
-RenderMetricsPath::~RenderMetricsPath() { delete m_RenderPath; }
+RenderMetricsPath::RenderMetricsPath(std::unique_ptr<RenderPath> path)
+ : m_RenderPath(std::move(path))
+{}
void RenderMetricsPath::addPath(CommandPath* path, const Mat2D& transform) {
MetricsPath::addPath(path, transform);
diff --git a/src/shapes/paint/fill.cpp b/src/shapes/paint/fill.cpp
index e39fb78..d451982 100644
--- a/src/shapes/paint/fill.cpp
+++ b/src/shapes/paint/fill.cpp
@@ -16,5 +16,5 @@
}
auto renderPath = path->renderPath();
renderPath->fillRule((FillRule)fillRule());
- renderer->drawPath(renderPath, m_RenderPaint);
+ renderer->drawPath(renderPath, renderPaint());
}
\ No newline at end of file
diff --git a/src/shapes/paint/linear_gradient.cpp b/src/shapes/paint/linear_gradient.cpp
index 0e5b978..24d0c6a 100644
--- a/src/shapes/paint/linear_gradient.cpp
+++ b/src/shapes/paint/linear_gradient.cpp
@@ -1,5 +1,7 @@
#include "rive/shapes/paint/linear_gradient.hpp"
#include "rive/math/vec2d.hpp"
+#include "rive/artboard.hpp"
+#include "rive/factory.hpp"
#include "rive/node.hpp"
#include "rive/renderer.hpp"
#include "rive/shapes/paint/color.hpp"
@@ -92,8 +94,8 @@
void LinearGradient::makeGradient(
Vec2D start, Vec2D end, const ColorInt colors[], const float stops[], size_t count) {
- auto paint = renderPaint();
- paint->shader(makeLinearGradient(
+ auto factory = artboard()->factory();
+ renderPaint()->shader(factory->makeLinearGradient(
start[0], start[1], end[0], end[1], colors, stops, count, RenderTileMode::clamp));
}
diff --git a/src/shapes/paint/radial_gradient.cpp b/src/shapes/paint/radial_gradient.cpp
index d327d4e..6c6b481 100644
--- a/src/shapes/paint/radial_gradient.cpp
+++ b/src/shapes/paint/radial_gradient.cpp
@@ -1,16 +1,17 @@
#include "rive/shapes/paint/radial_gradient.hpp"
-#include "rive/renderer.hpp"
+#include "rive/artboard.hpp"
+#include "rive/factory.hpp"
using namespace rive;
void RadialGradient::makeGradient(
Vec2D start, Vec2D end, const ColorInt colors[], const float stops[], size_t count) {
- auto paint = renderPaint();
- paint->shader(makeRadialGradient(start[0],
- start[1],
- Vec2D::distance(start, end),
- colors,
- stops,
- count,
- RenderTileMode::clamp));
+ auto factory = artboard()->factory();
+ renderPaint()->shader(factory->makeRadialGradient(start[0],
+ start[1],
+ Vec2D::distance(start, end),
+ colors,
+ stops,
+ count,
+ RenderTileMode::clamp));
}
diff --git a/src/shapes/paint/shape_paint.cpp b/src/shapes/paint/shape_paint.cpp
index 174d82a..b1d2890 100644
--- a/src/shapes/paint/shape_paint.cpp
+++ b/src/shapes/paint/shape_paint.cpp
@@ -1,12 +1,11 @@
#include "rive/shapes/paint/shape_paint.hpp"
#include "rive/shapes/shape_paint_container.hpp"
-#include "rive/renderer.hpp"
+#include "rive/artboard.hpp"
+#include "rive/factory.hpp"
using namespace rive;
-ShapePaint::~ShapePaint() { delete m_RenderPaint; }
-
StatusCode ShapePaint::onAddedClean(CoreContext* context) {
auto container = ShapePaintContainer::from(parent());
if (container == nullptr) {
@@ -19,7 +18,10 @@
RenderPaint* ShapePaint::initRenderPaint(ShapePaintMutator* mutator) {
assert(m_RenderPaint == nullptr);
m_PaintMutator = mutator;
- return m_RenderPaint = makeRenderPaint();
+
+ auto factory = mutator->component()->artboard()->factory();
+ m_RenderPaint = factory->makeRenderPaint();
+ return m_RenderPaint.get();
}
void ShapePaint::blendMode(BlendMode value) {
diff --git a/src/shapes/paint/stroke.cpp b/src/shapes/paint/stroke.cpp
index ff48cf7..4588cc4 100644
--- a/src/shapes/paint/stroke.cpp
+++ b/src/shapes/paint/stroke.cpp
@@ -1,3 +1,4 @@
+#include "rive/artboard.hpp"
#include "rive/shapes/paint/stroke.hpp"
#include "rive/shapes/paint/stroke_cap.hpp"
#include "rive/shapes/paint/stroke_effect.hpp"
@@ -27,10 +28,11 @@
if (m_Effect != nullptr) {
/// We're guaranteed to get a metrics path here if we have an effect.
- path = m_Effect->effectPath(reinterpret_cast<MetricsPath*>(path));
+ auto factory = artboard()->factory();
+ path = m_Effect->effectPath(reinterpret_cast<MetricsPath*>(path), factory);
}
- renderer->drawPath(path->renderPath(), m_RenderPaint);
+ renderer->drawPath(path->renderPath(), renderPaint());
}
void Stroke::thicknessChanged() {
diff --git a/src/shapes/paint/trim_path.cpp b/src/shapes/paint/trim_path.cpp
index 3d2e8d8..3087dde 100644
--- a/src/shapes/paint/trim_path.cpp
+++ b/src/shapes/paint/trim_path.cpp
@@ -1,12 +1,10 @@
#include "rive/shapes/paint/trim_path.hpp"
#include "rive/shapes/metrics_path.hpp"
#include "rive/shapes/paint/stroke.hpp"
+#include "rive/factory.hpp"
using namespace rive;
-TrimPath::TrimPath() : m_TrimmedPath(makeRenderPath()) {}
-TrimPath::~TrimPath() { delete m_TrimmedPath; }
-
StatusCode TrimPath::onAddedClean(CoreContext* context) {
if (!parent()->is<Stroke>()) {
return StatusCode::InvalidObject;
@@ -17,7 +15,7 @@
return StatusCode::Ok;
}
-RenderPath* TrimPath::effectPath(MetricsPath* source) {
+RenderPath* TrimPath::effectPath(MetricsPath* source, Factory* factory) {
if (m_RenderPath != nullptr) {
return m_RenderPath;
}
@@ -25,7 +23,12 @@
// Source is always a containing (shape) path.
const std::vector<MetricsPath*>& subPaths = source->paths();
- m_TrimmedPath->reset();
+ if (!m_TrimmedPath) {
+ m_TrimmedPath = factory->makeEmptyRenderPath();
+ } else {
+ m_TrimmedPath->reset();
+ }
+
auto renderOffset = std::fmod(std::fmod(offset(), 1.0f) + 1.0f, 1.0f);
switch (modeValue()) {
case 1: {
@@ -50,7 +53,7 @@
auto pathLength = path->length();
if (startLength < pathLength) {
- path->trim(startLength, endLength, true, m_TrimmedPath);
+ path->trim(startLength, endLength, true, m_TrimmedPath.get());
endLength -= pathLength;
startLength = 0;
} else {
@@ -76,17 +79,17 @@
startLength -= pathLength;
endLength -= pathLength;
}
- path->trim(startLength, endLength, true, m_TrimmedPath);
+ path->trim(startLength, endLength, true, m_TrimmedPath.get());
while (endLength > pathLength) {
startLength = 0;
endLength -= pathLength;
- path->trim(startLength, endLength, true, m_TrimmedPath);
+ path->trim(startLength, endLength, true, m_TrimmedPath.get());
}
}
} break;
}
- m_RenderPath = m_TrimmedPath;
+ m_RenderPath = m_TrimmedPath.get();
return m_RenderPath;
}
diff --git a/src/shapes/shape_paint_container.cpp b/src/shapes/shape_paint_container.cpp
index 044b40d..8dd83da 100644
--- a/src/shapes/shape_paint_container.cpp
+++ b/src/shapes/shape_paint_container.cpp
@@ -1,5 +1,6 @@
#include "rive/shapes/shape_paint_container.hpp"
#include "rive/artboard.hpp"
+#include "rive/factory.hpp"
#include "rive/component.hpp"
#include "rive/renderer.hpp"
#include "rive/shapes/metrics_path.hpp"
@@ -8,6 +9,7 @@
#include "rive/shapes/shape.hpp"
using namespace rive;
+
ShapePaintContainer* ShapePaintContainer::from(Component* component) {
switch (component->coreType()) {
case Artboard::typeKey:
@@ -58,11 +60,12 @@
}
}
+ auto factory = getArtboard()->factory();
if (needForEffects && needForRender) {
- return std::unique_ptr<CommandPath>(new RenderMetricsPath());
+ return std::unique_ptr<CommandPath>(new RenderMetricsPath(factory->makeEmptyRenderPath()));
} else if (needForEffects) {
return std::unique_ptr<CommandPath>(new OnlyMetricsPath());
} else {
- return std::unique_ptr<CommandPath>(rive::makeRenderPath());
+ return std::unique_ptr<CommandPath>(factory->makeEmptyRenderPath());
}
}
diff --git a/test/bound_bones_test.cpp b/test/bound_bones_test.cpp
index 4a92b48..d34b330 100644
--- a/test/bound_bones_test.cpp
+++ b/test/bound_bones_test.cpp
@@ -7,7 +7,7 @@
#include <rive/shapes/points_path.hpp>
#include <rive/shapes/rectangle.hpp>
#include <rive/shapes/shape.hpp>
-#include "no_op_renderer.hpp"
+#include "no_op_factory.hpp"
#include "rive_file_reader.hpp"
#include <catch.hpp>
#include <cstdio>
diff --git a/test/image_asset_test.cpp b/test/image_asset_test.cpp
index a681d9d..e65d25f 100644
--- a/test/image_asset_test.cpp
+++ b/test/image_asset_test.cpp
@@ -5,6 +5,7 @@
#include <rive/shapes/image.hpp>
#include <rive/assets/image_asset.hpp>
#include <rive/relative_local_asset_resolver.hpp>
+#include "no_op_factory.hpp"
#include "no_op_renderer.hpp"
#include "rive_file_reader.hpp"
#include <catch.hpp>
@@ -41,10 +42,12 @@
}
TEST_CASE("out of band image assets loads correctly", "[assets]") {
+ rive::NoOpFactory gEmptyFactory;
+
std::string filename = "../../test/assets/out_of_band/walle.riv";
- rive::RelativeLocalAssetResolver resolver(filename);
+ rive::RelativeLocalAssetResolver resolver(filename, &gEmptyFactory);
- auto file = ReadRiveFile(filename.c_str(), &resolver);
+ auto file = ReadRiveFile(filename.c_str(), &gEmptyFactory, &resolver);
auto node = file->artboard()->find("walle");
REQUIRE(node != nullptr);
diff --git a/test/instancing_test.cpp b/test/instancing_test.cpp
index 85d2e4f..93fe204 100644
--- a/test/instancing_test.cpp
+++ b/test/instancing_test.cpp
@@ -3,6 +3,7 @@
#include <rive/shapes/clipping_shape.hpp>
#include <rive/shapes/rectangle.hpp>
#include <rive/shapes/shape.hpp>
+#include "no_op_factory.hpp"
#include "no_op_renderer.hpp"
#include "rive_file_reader.hpp"
#include <catch.hpp>
diff --git a/test/linear_animation_instance_test.cpp b/test/linear_animation_instance_test.cpp
index f8a5b77..469b4ae 100644
--- a/test/linear_animation_instance_test.cpp
+++ b/test/linear_animation_instance_test.cpp
@@ -1,13 +1,15 @@
#include <rive/animation/loop.hpp>
#include <rive/animation/linear_animation.hpp>
#include <rive/animation/linear_animation_instance.hpp>
+#include "no_op_factory.hpp"
#include <catch.hpp>
#include <cstdio>
TEST_CASE("LinearAnimationInstance oneShot", "[animation]") {
+ rive::NoOpFactory emptyFactory;
// For each of these tests, we cons up a dummy artboard/instance
// just to make the animations happy.
- rive::Artboard ab;
+ rive::Artboard ab(&emptyFactory);
auto abi = ab.instance();
rive::LinearAnimation* linearAnimation = new rive::LinearAnimation();
@@ -38,7 +40,8 @@
}
TEST_CASE("LinearAnimationInstance oneShot <-", "[animation]") {
- rive::Artboard ab;
+ rive::NoOpFactory emptyFactory;
+ rive::Artboard ab(&emptyFactory);
auto abi = ab.instance();
rive::LinearAnimation* linearAnimation = new rive::LinearAnimation();
@@ -85,7 +88,8 @@
}
TEST_CASE("LinearAnimationInstance loop ->", "[animation]") {
- rive::Artboard ab;
+ rive::NoOpFactory emptyFactory;
+ rive::Artboard ab(&emptyFactory);
auto abi = ab.instance();
rive::LinearAnimation* linearAnimation = new rive::LinearAnimation();
@@ -116,7 +120,8 @@
}
TEST_CASE("LinearAnimationInstance loop <-", "[animation]") {
- rive::Artboard ab;
+ rive::NoOpFactory emptyFactory;
+ rive::Artboard ab(&emptyFactory);
auto abi = ab.instance();
rive::LinearAnimation* linearAnimation = new rive::LinearAnimation();
@@ -157,7 +162,8 @@
}
TEST_CASE("LinearAnimationInstance loop <- work area", "[animation]") {
- rive::Artboard ab;
+ rive::NoOpFactory emptyFactory;
+ rive::Artboard ab(&emptyFactory);
auto abi = ab.instance();
rive::LinearAnimation* linearAnimation = new rive::LinearAnimation();
@@ -211,7 +217,8 @@
}
TEST_CASE("LinearAnimationInstance pingpong ->", "[animation]") {
- rive::Artboard ab;
+ rive::NoOpFactory emptyFactory;
+ rive::Artboard ab(&emptyFactory);
auto abi = ab.instance();
rive::LinearAnimation* linearAnimation = new rive::LinearAnimation();
@@ -243,7 +250,8 @@
}
TEST_CASE("LinearAnimationInstance pingpong <-", "[animation]") {
- rive::Artboard ab;
+ rive::NoOpFactory emptyFactory;
+ rive::Artboard ab(&emptyFactory);
auto abi = ab.instance();
rive::LinearAnimation* linearAnimation = new rive::LinearAnimation();
@@ -287,7 +295,8 @@
}
TEST_CASE("LinearAnimationInstance override loop", "[animation]") {
- rive::Artboard ab;
+ rive::NoOpFactory emptyFactory;
+ rive::Artboard ab(&emptyFactory);
auto abi = ab.instance();
rive::LinearAnimation* linearAnimation = new rive::LinearAnimation();
diff --git a/test/no_op_factory.cpp b/test/no_op_factory.cpp
new file mode 100644
index 0000000..2f088f2
--- /dev/null
+++ b/test/no_op_factory.cpp
@@ -0,0 +1,43 @@
+#include "no_op_factory.hpp"
+#include "no_op_renderer.hpp"
+
+using namespace rive;
+
+NoOpFactory gNoOpFactory;
+
+rcp<RenderBuffer> NoOpFactory::makeBufferU16(Span<const uint16_t>) { return nullptr; }
+rcp<RenderBuffer> NoOpFactory::makeBufferU32(Span<const uint32_t>) { return nullptr; }
+rcp<RenderBuffer> NoOpFactory::makeBufferF32(Span<const float>) { return nullptr; }
+
+rcp<RenderShader> NoOpFactory::makeLinearGradient(float sx, float sy,
+ float ex, float ey,
+ const ColorInt colors[], // [count]
+ const float stops[], // [count]
+ int count,
+ RenderTileMode,
+ const Mat2D* localMatrix) { return nullptr; }
+
+rcp<RenderShader> NoOpFactory::makeRadialGradient(float cx, float cy, float radius,
+ const ColorInt colors[], // [count]
+ const float stops[], // [count]
+ int count,
+ RenderTileMode,
+ const Mat2D* localMatrix) { return nullptr; }
+
+std::unique_ptr<RenderPath> NoOpFactory::makeRenderPath(Span<const Vec2D> points,
+ Span<const uint8_t> verbs,
+ FillRule) {
+ return std::make_unique<NoOpRenderPath>();
+}
+
+std::unique_ptr<RenderPath> NoOpFactory::makeEmptyRenderPath() {
+ return std::make_unique<NoOpRenderPath>();
+}
+
+std::unique_ptr<RenderPaint> NoOpFactory::makeRenderPaint() {
+ return std::make_unique<NoOpRenderPaint>();
+}
+
+std::unique_ptr<RenderImage> NoOpFactory::decodeImage(Span<const uint8_t>) {
+ return std::make_unique<NoOpRenderImage>();
+}
diff --git a/test/no_op_factory.hpp b/test/no_op_factory.hpp
new file mode 100644
index 0000000..59095be
--- /dev/null
+++ b/test/no_op_factory.hpp
@@ -0,0 +1,43 @@
+#ifndef _RIVE_NOOP_FACTORY_HPP_
+#define _RIVE_NOOP_FACTORY_HPP_
+
+#include <rive/renderer.hpp>
+#include <rive/factory.hpp>
+
+namespace rive {
+
+ class NoOpFactory : public Factory {
+ rcp<RenderBuffer> makeBufferU16(Span<const uint16_t>) override;
+ rcp<RenderBuffer> makeBufferU32(Span<const uint32_t>) override;
+ rcp<RenderBuffer> makeBufferF32(Span<const float>) override;
+
+ rcp<RenderShader> makeLinearGradient(float sx, float sy,
+ float ex, float ey,
+ const ColorInt colors[], // [count]
+ const float stops[], // [count]
+ int count,
+ RenderTileMode,
+ const Mat2D* localMatrix = nullptr) override;
+
+ rcp<RenderShader> makeRadialGradient(float cx, float cy, float radius,
+ const ColorInt colors[], // [count]
+ const float stops[], // [count]
+ int count,
+ RenderTileMode,
+ const Mat2D* localMatrix = nullptr) override;
+
+ std::unique_ptr<RenderPath> makeRenderPath(Span<const Vec2D> points,
+ Span<const uint8_t> verbs,
+ FillRule) override;
+
+ std::unique_ptr<RenderPath> makeEmptyRenderPath() override;
+
+ std::unique_ptr<RenderPaint> makeRenderPaint() override;
+
+ std::unique_ptr<RenderImage> decodeImage(Span<const uint8_t>) override;
+ };
+
+ static NoOpFactory gNoOpFactory;
+
+} // namespace rive
+#endif
diff --git a/test/no_op_renderer.cpp b/test/no_op_renderer.cpp
deleted file mode 100644
index b6ec756..0000000
--- a/test/no_op_renderer.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-#include "no_op_renderer.hpp"
-#include <rive/renderer.hpp>
-
-namespace rive {
- RenderPaint* makeRenderPaint() { return new NoOpRenderPaint(); }
- RenderPath* makeRenderPath() { return new NoOpRenderPath(); }
- RenderImage* makeRenderImage() { return new NoOpRenderImage(); }
-
- rcp<RenderShader> makeLinearGradient(float sx,
- float sy,
- float ex,
- float ey,
- const ColorInt colors[],
- const float stops[],
- int count,
- RenderTileMode,
- const Mat2D* localMatrix) {
- return nullptr;
- }
-
- rcp<RenderShader> makeRadialGradient(float cx,
- float cy,
- float radius,
- const ColorInt colors[],
- const float stops[],
- int count,
- RenderTileMode,
- const Mat2D* localMatrix) {
- return nullptr;
- }
-
- rcp<RenderShader> makeSweepGradient(float cx,
- float cy,
- const ColorInt colors[],
- const float stops[],
- int count,
- const Mat2D* localMatrix) {
- return nullptr;
- }
-
- rcp<RenderBuffer> makeBufferU16(Span<const uint16_t>) { return nullptr; }
- rcp<RenderBuffer> makeBufferU32(Span<const uint32_t>) { return nullptr; }
- rcp<RenderBuffer> makeBufferF32(Span<const float>) { return nullptr; }
-} // namespace rive
diff --git a/test/no_op_renderer.hpp b/test/no_op_renderer.hpp
index 9237c4c..b5e9bb5 100644
--- a/test/no_op_renderer.hpp
+++ b/test/no_op_renderer.hpp
@@ -1,12 +1,13 @@
#ifndef _RIVE_NOOP_RENDERER_HPP_
#define _RIVE_NOOP_RENDERER_HPP_
+
#include <rive/renderer.hpp>
+#include <rive/factory.hpp>
#include <vector>
namespace rive {
class NoOpRenderImage : public RenderImage {
public:
- bool decode(Span<const uint8_t>) override { return true; }
rcp<RenderShader> makeShader(RenderTileMode, RenderTileMode, const Mat2D*) const override {
return nullptr;
}
diff --git a/test/path_test.cpp b/test/path_test.cpp
index 15f9218..fb0e5fb 100644
--- a/test/path_test.cpp
+++ b/test/path_test.cpp
@@ -6,12 +6,14 @@
#include <rive/shapes/path_composer.hpp>
#include <rive/shapes/rectangle.hpp>
#include <rive/shapes/shape.hpp>
+#include "no_op_factory.hpp"
#include "no_op_renderer.hpp"
#include <catch.hpp>
#include <cstdio>
TEST_CASE("rectangle path builds expected commands", "[path]") {
- rive::Artboard* artboard = new rive::Artboard();
+ rive::NoOpFactory emptyFactory;
+ rive::Artboard artboard(&emptyFactory);
rive::Shape* shape = new rive::Shape();
rive::Rectangle* rectangle = new rive::Rectangle();
@@ -21,14 +23,14 @@
rectangle->height(200.0f);
rectangle->cornerRadiusTL(0.0f);
- artboard->addObject(artboard);
- artboard->addObject(shape);
- artboard->addObject(rectangle);
+ artboard.addObject(&artboard);
+ artboard.addObject(shape);
+ artboard.addObject(rectangle);
rectangle->parentId(1);
- REQUIRE(artboard->initialize() == rive::StatusCode::Ok);
+ REQUIRE(artboard.initialize() == rive::StatusCode::Ok);
- artboard->advance(0.0f);
+ artboard.advance(0.0f);
REQUIRE(rectangle->commandPath() != nullptr);
@@ -42,12 +44,11 @@
REQUIRE(path->commands[4].command == rive::NoOpPathCommandType::LineTo);
REQUIRE(path->commands[5].command == rive::NoOpPathCommandType::LineTo);
REQUIRE(path->commands[6].command == rive::NoOpPathCommandType::Close);
-
- delete artboard;
}
TEST_CASE("rounded rectangle path builds expected commands", "[path]") {
- rive::Artboard* artboard = new rive::Artboard();
+ rive::NoOpFactory emptyFactory;
+ rive::Artboard artboard(&emptyFactory);
rive::Shape* shape = new rive::Shape();
rive::Rectangle* rectangle = new rive::Rectangle();
@@ -58,14 +59,14 @@
rectangle->cornerRadiusTL(20.0f);
rectangle->linkCornerRadius(true);
- artboard->addObject(artboard);
- artboard->addObject(shape);
- artboard->addObject(rectangle);
+ artboard.addObject(&artboard);
+ artboard.addObject(shape);
+ artboard.addObject(rectangle);
rectangle->parentId(1);
- artboard->initialize();
+ artboard.initialize();
- artboard->advance(0.0f);
+ artboard.advance(0.0f);
REQUIRE(rectangle->commandPath() != nullptr);
@@ -105,12 +106,11 @@
REQUIRE(path->commands[9].command == rive::NoOpPathCommandType::LineTo);
REQUIRE(path->commands[10].command == rive::NoOpPathCommandType::Close);
-
- delete artboard;
}
TEST_CASE("ellipse path builds expected commands", "[path]") {
- rive::Artboard* artboard = new rive::Artboard();
+ rive::NoOpFactory emptyFactory;
+ rive::Artboard artboard(&emptyFactory);
rive::Ellipse* ellipse = new rive::Ellipse();
rive::Shape* shape = new rive::Shape();
@@ -119,14 +119,14 @@
ellipse->width(100.0f);
ellipse->height(200.0f);
- artboard->addObject(artboard);
- artboard->addObject(shape);
- artboard->addObject(ellipse);
+ artboard.addObject(&artboard);
+ artboard.addObject(shape);
+ artboard.addObject(ellipse);
ellipse->parentId(1);
- artboard->initialize();
+ artboard.initialize();
- artboard->advance(0.0f);
+ artboard.advance(0.0f);
REQUIRE(ellipse->commandPath() != nullptr);
@@ -187,6 +187,4 @@
REQUIRE(path->commands[5].y == -100.0f);
REQUIRE(path->commands[6].command == rive::NoOpPathCommandType::Close);
-
- delete artboard;
}
\ No newline at end of file
diff --git a/test/rive_file_reader.hpp b/test/rive_file_reader.hpp
index cec7a41..4294290 100644
--- a/test/rive_file_reader.hpp
+++ b/test/rive_file_reader.hpp
@@ -3,9 +3,16 @@
#include <rive/file.hpp>
#include "rive_testing.hpp"
+#include "no_op_factory.hpp"
static inline std::unique_ptr<rive::File>
-ReadRiveFile(const char path[], rive::FileAssetResolver* resolver = nullptr) {
+ReadRiveFile(const char path[],
+ rive::Factory* factory = nullptr,
+ rive::FileAssetResolver* resolver = nullptr) {
+ if (!factory) {
+ factory = &rive::gNoOpFactory;
+ }
+
FILE* fp = fopen(path, "rb");
REQUIRE(fp != nullptr);
@@ -17,7 +24,7 @@
fclose(fp);
rive::ImportResult result;
- auto file = rive::File::import(rive::toSpan(bytes), &result, resolver);
+ auto file = rive::File::import(rive::toSpan(bytes), factory, &result, resolver);
REQUIRE(result == rive::ImportResult::success);
REQUIRE(file.get() != nullptr);
REQUIRE(file->artboard() != nullptr);
