[core] add getResource template to gfx::*Resource classes

6 files changed, 66 insertions, 20 deletions

diff --git a/src/mbgl/gfx/attribute.hpp b/src/mbgl/gfx/attribute.hpp
index f5188ccfdb..ecb2b5e1b2 100644
--- a/src/mbgl/gfx/attribute.hpp
+++ b/src/mbgl/gfx/attribute.hpp
@@ -250,7 +250,7 @@ AttributeBinding attributeBinding(const VertexBuffer<detail::VertexType<As...>>&
     return {
         Descriptor::data.attributes[I],
         Descriptor::data.stride,
-        buffer.resource.get(),
+        &buffer.getResource(),
         0,
     };
 }
diff --git a/src/mbgl/gfx/context.hpp b/src/mbgl/gfx/context.hpp
index 06a59fd238..1ce00f04d1 100644
--- a/src/mbgl/gfx/context.hpp
+++ b/src/mbgl/gfx/context.hpp
@@ -51,7 +51,7 @@ public:
     template <class Vertex>
     void updateVertexBuffer(VertexBuffer<Vertex>& buffer, VertexVector<Vertex>&& v) {
         assert(v.elements() == buffer.elements);
-        updateVertexBufferResource(*buffer.resource, v.data(), v.bytes());
+        updateVertexBufferResource(buffer.getResource(), v.data(), v.bytes());
     }
 
     template <class DrawMode>
@@ -63,19 +63,19 @@ public:
     template <class DrawMode>
     void updateIndexBuffer(IndexBuffer& buffer, IndexVector<DrawMode>&& v) {
         assert(v.elements() == buffer.elements);
-        updateIndexBufferResource(*buffer.resource, v.data(), v.bytes());
+        updateIndexBufferResource(buffer.getResource(), v.data(), v.bytes());
     }
 
 protected:
-    virtual std::unique_ptr<const VertexBufferResource>
+    virtual std::unique_ptr<VertexBufferResource>
     createVertexBufferResource(const void* data, std::size_t size, const BufferUsageType) = 0;
     virtual void
-    updateVertexBufferResource(const VertexBufferResource&, const void* data, std::size_t size) = 0;
+    updateVertexBufferResource(VertexBufferResource&, const void* data, std::size_t size) = 0;
 
-    virtual std::unique_ptr<const IndexBufferResource>
+    virtual std::unique_ptr<IndexBufferResource>
     createIndexBufferResource(const void* data, std::size_t size, const BufferUsageType) = 0;
     virtual void
-    updateIndexBufferResource(const IndexBufferResource&, const void* data, std::size_t size) = 0;
+    updateIndexBufferResource(IndexBufferResource&, const void* data, std::size_t size) = 0;
 
 public:
     // Create a texture from an image with data.
@@ -99,28 +99,28 @@ public:
                        const Image& image,
                        TextureChannelDataType type = TextureChannelDataType::UnsignedByte) {
         auto format = image.channels == 4 ? TexturePixelType::RGBA : TexturePixelType::Alpha;
-        updateTextureResource(*texture.resource, image.size, image.data.get(), format, type);
+        updateTextureResource(texture.getResource(), image.size, image.data.get(), format, type);
         texture.size = image.size;
     }
 
     template <typename Image>
     void updateTextureSub(Texture& texture,
-                       const Image& image,
-                       const uint16_t offsetX,
-                       const uint16_t offsetY,
-                       TextureChannelDataType type = TextureChannelDataType::UnsignedByte) {
+                          const Image& image,
+                          const uint16_t offsetX,
+                          const uint16_t offsetY,
+                          TextureChannelDataType type = TextureChannelDataType::UnsignedByte) {
         assert(image.size.width + offsetX <= texture.size.width);
         assert(image.size.height + offsetY <= texture.size.height);
         auto format = image.channels == 4 ? TexturePixelType::RGBA : TexturePixelType::Alpha;
-        updateTextureResourceSub(*texture.resource, offsetX, offsetY, image.size, image.data.get(), format, type);
+        updateTextureResourceSub(texture.getResource(), offsetX, offsetY, image.size, image.data.get(), format, type);
     }
 
 protected:
     virtual std::unique_ptr<TextureResource> createTextureResource(
         Size, const void* data, TexturePixelType, TextureChannelDataType) = 0;
-    virtual void updateTextureResource(const TextureResource&, Size, const void* data,
+    virtual void updateTextureResource(TextureResource&, Size, const void* data,
         TexturePixelType, TextureChannelDataType) = 0;
-    virtual void updateTextureResourceSub(const TextureResource&, uint16_t xOffset, uint16_t yOffset, Size, const void* data,
+    virtual void updateTextureResourceSub(TextureResource&, uint16_t xOffset, uint16_t yOffset, Size, const void* data,
         TexturePixelType, TextureChannelDataType) = 0;
 
 public:
@@ -136,7 +136,7 @@ protected:
 
 public:
     DrawScope createDrawScope() {
-        return { createDrawScopeResource() };
+        return DrawScope{ createDrawScopeResource() };
     }
 
 protected:
diff --git a/src/mbgl/gfx/draw_scope.hpp b/src/mbgl/gfx/draw_scope.hpp
index 60aae7a44c..5cdb588317 100644
--- a/src/mbgl/gfx/draw_scope.hpp
+++ b/src/mbgl/gfx/draw_scope.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <memory>
+#include <cassert>
 
 namespace mbgl {
 namespace gfx {
@@ -14,6 +15,16 @@ public:
 
 class DrawScope {
 public:
+    explicit DrawScope(std::unique_ptr<DrawScopeResource> resource_) : resource(std::move(resource_)) {
+    }
+
+    template <typename T = DrawScopeResource>
+    T& getResource() const {
+        assert(resource);
+        return static_cast<T&>(*resource);
+    }
+
+protected:
     std::unique_ptr<DrawScopeResource> resource;
 };
 
diff --git a/src/mbgl/gfx/index_buffer.hpp b/src/mbgl/gfx/index_buffer.hpp
index ede949764f..60f361b497 100644
--- a/src/mbgl/gfx/index_buffer.hpp
+++ b/src/mbgl/gfx/index_buffer.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <memory>
+#include <cassert>
 
 namespace mbgl {
 namespace gfx {
@@ -14,8 +15,20 @@ public:
 
 class IndexBuffer {
 public:
+    IndexBuffer(const std::size_t elements_, std::unique_ptr<IndexBufferResource>&& resource_)
+        : elements(elements_), resource(std::move(resource_)) {
+    }
+
     std::size_t elements;
-    std::unique_ptr<const IndexBufferResource> resource;
+
+    template <typename T = IndexBufferResource>
+    T& getResource() const {
+        assert(resource);
+        return static_cast<T&>(*resource);
+    }
+
+protected:
+    std::unique_ptr<IndexBufferResource> resource;
 };
 
 } // namespace gfx
diff --git a/src/mbgl/gfx/texture.hpp b/src/mbgl/gfx/texture.hpp
index a957c4ebdf..00e94a8f6c 100644
--- a/src/mbgl/gfx/texture.hpp
+++ b/src/mbgl/gfx/texture.hpp
@@ -6,6 +6,7 @@
 #include <mbgl/util/indexed_tuple.hpp>
 
 #include <memory>
+#include <cassert>
 
 #define MBGL_DEFINE_TEXTURE(name_)                                                                 \
     struct name_ {                                                                                 \
@@ -27,11 +28,19 @@ public:
 
 class Texture {
 public:
-    Texture(Size size_, std::unique_ptr<TextureResource>&& resource_)
-        : size(std::move(size_)), resource(std::move(resource_)) {
+    Texture(const Size size_, std::unique_ptr<TextureResource>&& resource_)
+        : size(size_), resource(std::move(resource_)) {
+    }
+
+    template <typename T = TextureResource>
+    T& getResource() const {
+        assert(resource);
+        return static_cast<T&>(*resource);
     }
 
     Size size;
+
+protected:
     std::unique_ptr<TextureResource> resource;
 };
 
diff --git a/src/mbgl/gfx/vertex_buffer.hpp b/src/mbgl/gfx/vertex_buffer.hpp
index 2ed1e62759..fe98ec6505 100644
--- a/src/mbgl/gfx/vertex_buffer.hpp
+++ b/src/mbgl/gfx/vertex_buffer.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <memory>
+#include <cassert>
 
 namespace mbgl {
 namespace gfx {
@@ -17,8 +18,20 @@ public:
 template <class>
 class VertexBuffer {
 public:
+    VertexBuffer(const std::size_t elements_, std::unique_ptr<VertexBufferResource>&& resource_)
+        : elements(elements_), resource(std::move(resource_)) {
+    }
+
     std::size_t elements;
-    std::unique_ptr<const VertexBufferResource> resource;
+
+    template <typename T = VertexBufferResource>
+    T& getResource() const {
+        assert(resource);
+        return static_cast<T&>(*resource);
+    }
+
+protected:
+    std::unique_ptr<VertexBufferResource> resource;
 };
 
 } // namespace gfx