make sure we call the sprite load callback

src/map/tile_parser.cpp

@@ -84,7 +84,8 @@ std::unique_ptr<Bucket> TileParser::createBucket(const BucketDescription& bucket
     if (bucket_desc.type == BucketType::Raster) {
         if (raster_data.length()) {
             tile.raster = std::make_shared<Raster>();
-            tile.raster->load(raster_data);
+            tile.raster->setData(raster_data);
+            tile.raster->load();
         }
         return createRasterBucket(bucket_desc);
     } else {

src/renderer/painter.cpp

@@ -542,7 +542,7 @@ void Painter::renderPoint(PointBucket& bucket, const std::string& layer_name, co
 #endif
     pointShader->setPointTopLeft({{ imagePos.tl.x, imagePos.tl.y }});
     pointShader->setPointBottomRight({{ imagePos.br.x, imagePos.br.y }});
-    if (*sprite->raster) {
+    if (sprite->raster->isLoaded()) {
         sprite->raster->bind(map.getState().isChanging());
     }
     glDepthRange(strata, 1.0f);

src/style/sprite.cpp

@@ -40,9 +40,8 @@ void Sprite::load(const std::string& base_url) {
 
    platform::request_http(base_url + suffix + ".png", [sprite](platform::Response *res) {
        if (res->code == 200) {
-            // TODO: move raster loading to other thread
-            // TODO: call complete handler
-            sprite->raster->load(res->body);
+            sprite->raster->setData(res->body);
+            sprite->asyncParseImage();
        } else {
            fprintf(stderr, "failed to load sprite image\n");
        }
@@ -51,7 +50,7 @@ void Sprite::load(const std::string& base_url) {
 
 void Sprite::complete(std::shared_ptr<Sprite> &sprite) {
    std::lock_guard<std::mutex> lock(sprite->mtx);
-   if (*sprite->raster && sprite->pos.size()) {
+   if (sprite->raster && sprite->raster->isLoaded() && sprite->pos.size()) {
        sprite->loaded = true;
        sprite->map.update();
        fprintf(stderr, "sprite loaded\n");
@@ -63,11 +62,16 @@ bool Sprite::isLoaded() const {
     return loaded;
 }
 
+void Sprite::asyncParseImage() {
+    new uv::work<std::shared_ptr<Sprite>>(map.getLoop(), parseImage, complete, shared_from_this());
+}
+
 void Sprite::asyncParseJSON() {
-   new uv::work<std::shared_ptr<Sprite>>(map.getLoop(),
-                     parseJSON,
-                     complete,
-                     shared_from_this());
+    new uv::work<std::shared_ptr<Sprite>>(map.getLoop(), parseJSON, complete, shared_from_this());
+}
+
+void Sprite::parseImage(std::shared_ptr<Sprite> &sprite) {
+  sprite->raster->load();
 }
 
 void Sprite::parseJSON(std::shared_ptr<Sprite> &sprite) {
@@ -101,7 +105,7 @@ void Sprite::parseJSON(std::shared_ptr<Sprite> &sprite) {
 }
 
 ImagePosition Sprite::getPosition(const std::string& name, bool repeating) {
-    if (!*this->raster) return {};
+    if (!this->raster || !this->raster->isLoaded()) return {};
 
     // `repeating` indicates that the image will be used in a repeating pattern
     // repeating pattern images are assumed to have a 1px padding that mirrors the opposite edge

src/util/raster.cpp

@@ -7,6 +7,7 @@
 #include <llmr/platform/platform.hpp>
 #include <llmr/platform/gl.hpp>
 #include <llmr/util/time.hpp>
+#include <llmr/util/uv.hpp>
 
 #include <png.h>
 
@@ -20,20 +21,22 @@ Raster::~Raster() {
     }
 }
 
-Raster::operator bool() const {
+bool Raster::isLoaded() const {
     std::lock_guard<std::mutex> lock(mtx);
     return loaded;
 }
 
-void Raster::load(const std::string& data) {
-    std::shared_ptr<Raster> raster = shared_from_this();
+void Raster::load() {
+    loadImage(data);
 
-    raster->loadImage(data);
-
-    std::lock_guard<std::mutex> lock(raster->mtx);
-    if (raster->img) {
-        raster->loaded = true;
+    {
+        std::lock_guard<std::mutex> lock(mtx);
+        if (img) {
+            loaded = true;
+        }
     }
+
+    data.clear();
 }
 
 struct Buffer {