Outofbandcache

Ok, got this passing testes, which I guess is a step in the right direction.

Before changing unique pointers to rcp, we could only use an image once, as soon as we assigned a new image, the old image would get garbage collected. (this is the actual problem we are trying to solve)

This "solves" the problem and  allows us to add images to a cache in wasm, and then cycle through the cache, swapping out the render image to be displayed for a given fileAsset. We can replace images & fonts on the fly this way.

Problems:
1. overwriting ref & unref in RenderImage, shows that is being reffed and un-reffed constantly (when viewing the attached file with the viewer). Is that expected? doing something similar for Font does not show up the same. I suspect this is related to how we use images when it comes to rendering, just figured i'd check
2. We dont seem to "leak" anything as detectable by our tests, which is good, but our wasm examples show that neither our fonts nor our render images get collected. presumably thats because we would need to manually tell wasm via js that we want to let go of an image?

Also @csmartdalton @umberto-sonnino & @luigi-rosso  it would be great to see what else is concerning.

example file

[just_a_box_with_a_tree.riv.zip](https://github.com/rive-app/rive/files/13042414/just_a_box_with_a_tree.riv.zip)

Diffs=
1506b069c Outofbandcache (#6049)

Co-authored-by: Maxwell Talbot <[email protected]>

.rive_head

@@ -1 +1 @@
-40f9d91ac8063448c357682ea97d5abbfe71ce1f
+1506b069c01a049034052e5de1cbc6a9cf029c2e

cg_renderer/include/cg_factory.hpp

@@ -37,7 +37,7 @@ class CGFactory : public Factory
 
     std::unique_ptr<RenderPaint> makeRenderPaint() override;
 
-    std::unique_ptr<RenderImage> decodeImage(Span<const uint8_t>) override;
+    rcp<RenderImage> decodeImage(Span<const uint8_t>) override;
 };
 
 } // namespace rive

cg_renderer/src/cg_factory.cpp

@@ -518,9 +518,9 @@ std::unique_ptr<RenderPaint> CGFactory::makeRenderPaint()
     return std::make_unique<CGRenderPaint>();
 }
 
-std::unique_ptr<RenderImage> CGFactory::decodeImage(Span<const uint8_t> encoded)
+rcp<RenderImage> CGFactory::decodeImage(Span<const uint8_t> encoded)
 {
-    return std::make_unique<CGRenderImage>(encoded);
+    return make_rcp<CGRenderImage>(encoded);
 }
 
 AutoCF<CGImageRef> CGRenderer::FlipCGImageInY(AutoCF<CGImageRef> image)

include/rive/assets/image_asset.hpp

@@ -10,7 +10,7 @@ namespace rive
 class ImageAsset : public ImageAssetBase
 {
 private:
-    std::unique_ptr<RenderImage> m_RenderImage;
+    rcp<RenderImage> m_RenderImage;
 
 public:
     ImageAsset() {}
@@ -22,7 +22,7 @@ class ImageAsset : public ImageAssetBase
     bool decode(Span<const uint8_t>, Factory*) override;
     std::string fileExtension() const override;
     RenderImage* renderImage() const { return m_RenderImage.get(); }
-    void renderImage(std::unique_ptr<RenderImage> renderImage);
+    void renderImage(rcp<RenderImage> renderImage);
 };
 } // namespace rive
 

include/rive/factory.hpp

@@ -56,7 +56,7 @@ class Factory
 
     virtual std::unique_ptr<RenderPaint> makeRenderPaint() = 0;
 
-    virtual std::unique_ptr<RenderImage> decodeImage(Span<const uint8_t>) = 0;
+    virtual rcp<RenderImage> decodeImage(Span<const uint8_t>) = 0;
 
     virtual rcp<Font> decodeFont(Span<const uint8_t>);
 

include/rive/refcnt.hpp

@@ -123,6 +123,7 @@ template <typename T> class rcp
         return *this;
     }
 
+    // move assignment operator
     rcp<T>& operator=(rcp<T>&& other)
     {
         this->reset(other.release());

include/rive/renderer.hpp

@@ -104,7 +104,7 @@ class RenderPaint
     virtual void invalidateStroke() = 0;
 };
 
-class RenderImage
+class RenderImage : public RefCnt<RenderImage>
 {
 protected:
     int m_Width = 0;

include/utils/no_op_factory.hpp

@@ -35,7 +35,7 @@ class NoOpFactory : public Factory
 
     std::unique_ptr<RenderPaint> makeRenderPaint() override;
 
-    std::unique_ptr<RenderImage> decodeImage(Span<const uint8_t>) override;
+    rcp<RenderImage> decodeImage(Span<const uint8_t>) override;
 };
 } // namespace rive
 #endif

skia/renderer/include/skia_factory.hpp

@@ -37,7 +37,7 @@ class SkiaFactory : public Factory
 
     std::unique_ptr<RenderPaint> makeRenderPaint() override;
 
-    std::unique_ptr<RenderImage> decodeImage(Span<const uint8_t>) override;
+    rcp<RenderImage> decodeImage(Span<const uint8_t>) override;
 
     //
     // New virtual for access the platform's codecs

skia/renderer/src/skia_factory.cpp

@@ -282,7 +282,7 @@ std::unique_ptr<RenderPaint> SkiaFactory::makeRenderPaint()
     return std::make_unique<SkiaRenderPaint>();
 }
 
-std::unique_ptr<RenderImage> SkiaFactory::decodeImage(Span<const uint8_t> encoded)
+rcp<RenderImage> SkiaFactory::decodeImage(Span<const uint8_t> encoded)
 {
     sk_sp<SkData> data = SkData::MakeWithCopy(encoded.data(), encoded.size());
     auto image = SkImage::MakeFromEncoded(data);
@@ -309,5 +309,5 @@ std::unique_ptr<RenderImage> SkiaFactory::decodeImage(Span<const uint8_t> encode
         }
     }
 
-    return image ? std::make_unique<SkiaRenderImage>(std::move(image)) : nullptr;
+    return image ? make_rcp<SkiaRenderImage>(std::move(image)) : nullptr;
 }

src/assets/font_asset.cpp

@@ -8,7 +8,7 @@ using namespace rive;
 
 bool FontAsset::decode(Span<const uint8_t> data, Factory* factory)
 {
-    m_font = factory->decodeFont(data);
+    font(factory->decodeFont(data));
     return m_font != nullptr;
 }
 std::string FontAsset::fileExtension() const { return "ttf"; }

src/assets/image_asset.cpp

@@ -11,11 +11,11 @@ bool ImageAsset::decode(Span<const uint8_t> data, Factory* factory)
 #ifdef TESTING
     decodedByteSize = data.size();
 #endif
-    m_RenderImage = factory->decodeImage(data);
+    renderImage(factory->decodeImage(data));
     return m_RenderImage != nullptr;
 }
 
-void ImageAsset::renderImage(std::unique_ptr<RenderImage> renderImage)
+void ImageAsset::renderImage(rcp<RenderImage> renderImage)
 {
     m_RenderImage = std::move(renderImage);
 }

src/shapes/image.cpp

@@ -11,10 +11,15 @@ using namespace rive;
 
 void Image::draw(Renderer* renderer)
 {
-    rive::RenderImage* renderImage;
+
     rive::ImageAsset* asset = this->imageAsset();
-    if (asset == nullptr || renderOpacity() == 0.0f ||
-        (renderImage = asset->renderImage()) == nullptr)
+    if (asset == nullptr || renderOpacity() == 0.0f)
+    {
+        return;
+    }
+
+    rive::RenderImage* renderImage = asset->renderImage();
+    if (renderImage == nullptr)
     {
         return;
     }

utils/no_op_factory.cpp

@@ -80,7 +80,4 @@ std::unique_ptr<RenderPaint> NoOpFactory::makeRenderPaint()
     return rivestd::make_unique<NoOpRenderPaint>();
 }
 
-std::unique_ptr<RenderImage> NoOpFactory::decodeImage(Span<const uint8_t>)
-{
-    return std::unique_ptr<NoOpRenderImage>();
-}
+rcp<RenderImage> NoOpFactory::decodeImage(Span<const uint8_t>) { return nullptr; }

viewer/include/viewer/tess/viewer_sokol_factory.hpp

@@ -6,6 +6,6 @@
 class ViewerSokolFactory : public rive::SokolFactory
 {
 public:
-    std::unique_ptr<rive::RenderImage> decodeImage(rive::Span<const uint8_t>) override;
+    rive::rcp<rive::RenderImage> decodeImage(rive::Span<const uint8_t>) override;
 };
 #endif

viewer/src/sample_tools/sample_atlas_packer.cpp

@@ -27,7 +27,7 @@ class AtlasRenderImage : public RenderImage
 
 class AtlasPackerFactory : public NoOpFactory
 {
-    std::unique_ptr<RenderImage> decodeImage(Span<const uint8_t> bytes) override
+    rcp<RenderImage> decodeImage(Span<const uint8_t> bytes) override
     {
         auto bitmap = Bitmap::decode(bytes.data(), bytes.size());
         if (bitmap)
@@ -40,9 +40,7 @@ class AtlasPackerFactory : public NoOpFactory
                 bitmap->pixelFormat(Bitmap::PixelFormat::RGBA);
             }
 
-            return rivestd::make_unique<AtlasRenderImage>(bitmap->bytes(),
-                                                          bitmap->width(),
-                                                          bitmap->height());
+            return make_rcp<AtlasRenderImage>(bitmap->bytes(), bitmap->width(), bitmap->height());
         }
         return nullptr;
     }

viewer/src/tess/viewer_sokol_factory.cpp

@@ -4,7 +4,7 @@
 #include "rive/tess/sokol/sokol_tess_renderer.hpp"
 #include "sokol_gfx.h"
 
-std::unique_ptr<rive::RenderImage> ViewerSokolFactory::decodeImage(rive::Span<const uint8_t> bytes)
+rive::rcp<rive::RenderImage> ViewerSokolFactory::decodeImage(rive::Span<const uint8_t> bytes)
 {
     auto bitmap = Bitmap::decode(bytes.data(), bytes.size());
     if (bitmap)
@@ -26,10 +26,10 @@ std::unique_ptr<rive::RenderImage> ViewerSokolFactory::decodeImage(rive::Span<co
             new rive::SokolRenderImageResource(bitmap->bytes(), bitmap->width(), bitmap->height()));
 
         static rive::Mat2D identity;
-        return rivestd::make_unique<rive::SokolRenderImage>(imageGpuResource,
-                                                            bitmap->width(),
-                                                            bitmap->height(),
-                                                            identity);
+        return rive::make_rcp<rive::SokolRenderImage>(imageGpuResource,
+                                                      bitmap->width(),
+                                                      bitmap->height(),
+                                                      identity);
     }
     return nullptr;
 }

viewer/src/viewer_content/image_content.cpp

@@ -8,10 +8,10 @@
 
 class ImageContent : public ViewerContent
 {
-    std::unique_ptr<rive::RenderImage> m_image;
+    rive::rcp<rive::RenderImage> m_image;
 
 public:
-    ImageContent(std::unique_ptr<rive::RenderImage> image) : m_image(std::move(image)) {}
+    ImageContent(rive::rcp<rive::RenderImage> image) { m_image = std::move(image); }
 
     void handleDraw(rive::Renderer* renderer, double) override
     {