update external headers

ios/include/backend/BufferDescriptor.h

@@ -27,6 +27,8 @@
 
 namespace filament::backend {
 
+class CallbackHandler;
+
 /**
  * A CPU memory-buffer descriptor, typically used to transfer data from the CPU to the GPU.
  *
@@ -53,8 +55,8 @@ public:
 
     //! calls the callback to advertise BufferDescriptor no-longer owns the buffer
     ~BufferDescriptor() noexcept {
-        if (callback) {
-            callback(buffer, size, user);
+        if (mCallback) {
+            mCallback(buffer, size, mUser);
         }
     }
 
@@ -62,19 +64,21 @@ public:
     BufferDescriptor& operator=(const BufferDescriptor& rhs) = delete;
 
     BufferDescriptor(BufferDescriptor&& rhs) noexcept
-        : buffer(rhs.buffer), size(rhs.size), callback(rhs.callback), user(rhs.user) {
+        : buffer(rhs.buffer), size(rhs.size),
+          mCallback(rhs.mCallback), mUser(rhs.mUser), mHandler(rhs.mHandler) {
             rhs.buffer = nullptr;
-            rhs.callback = nullptr;
+            rhs.mCallback = nullptr;
     }
 
     BufferDescriptor& operator=(BufferDescriptor&& rhs) noexcept {
         if (this != &rhs) {
             buffer = rhs.buffer;
             size = rhs.size;
-            callback = rhs.callback;
-            user = rhs.user;
+            mCallback = rhs.mCallback;
+            mUser = rhs.mUser;
+            mHandler = rhs.mHandler;
             rhs.buffer = nullptr;
-            rhs.callback = nullptr;
+            rhs.mCallback = nullptr;
         }
         return *this;
     }
@@ -88,7 +92,20 @@ public:
      */
     BufferDescriptor(void const* buffer, size_t size,
             Callback callback = nullptr, void* user = nullptr) noexcept
-                : buffer(const_cast<void*>(buffer)), size(size), callback(callback), user(user) {
+                : buffer(const_cast<void*>(buffer)), size(size), mCallback(callback), mUser(user) {
+    }
+
+    /**
+     * Creates a BufferDescriptor that references a CPU memory-buffer
+     * @param buffer    Memory address of the CPU buffer to reference
+     * @param size      Size of the CPU buffer in bytes
+     * @param callback  A callback used to release the CPU buffer from this BufferDescriptor
+     * @param user      An opaque user pointer passed to the callback function when it's called
+     */
+    BufferDescriptor(void const* buffer, size_t size,
+            CallbackHandler* handler, Callback callback, void* user = nullptr) noexcept
+                : buffer(const_cast<void*>(buffer)), size(size),
+                mCallback(callback), mUser(user), mHandler(handler) {
     }
 
     // --------------------------------------------------------------------------------------------
@@ -100,14 +117,15 @@ public:
      *
      * @param buffer    Memory address of the CPU buffer to reference
      * @param size      Size of the CPU buffer in bytes
+     * @param handler   Handler to use to dispatch the callback, or nullptr for the default handler
      * @return          a new BufferDescriptor
      */
-    template<typename T, void(T::*method)(void const* buffer, size_t size)>
+    template<typename T, void(T::*method)(void const*, size_t)>
     static BufferDescriptor make(
-            void const* buffer, size_t size, T* data) noexcept {
+            void const* buffer, size_t size, T* data, CallbackHandler* handler = nullptr) noexcept {
         return {
                 buffer, size,
-                [](void* b, size_t s, void* u) {
+                handler, [](void* b, size_t s, void* u) {
                     (*static_cast<T**>(u)->*method)(b, s);
                 }, data
         };
@@ -123,14 +141,15 @@ public:
      * @param buffer    Memory address of the CPU buffer to reference
      * @param size      Size of the CPU buffer in bytes
      * @param functor   functor of type f(void const* buffer, size_t size)
+     * @param handler   Handler to use to dispatch the callback, or nullptr for the default handler
      * @return          a new BufferDescriptor
      */
     template<typename T>
     static BufferDescriptor make(
-            void const* buffer, size_t size, T&& functor) noexcept {
+            void const* buffer, size_t size, T&& functor, CallbackHandler* handler = nullptr) noexcept {
         return {
                 buffer, size,
-                [](void* b, size_t s, void* u) {
+                handler, [](void* b, size_t s, void* u) {
                     T& that = *static_cast<T*>(u);
                     that(b, s);
                     delete &that;
@@ -147,21 +166,39 @@ public:
      * @param user      An opaque user pointer passed to the callbeck function when it's called
      */
     void setCallback(Callback callback, void* user = nullptr) noexcept {
-        this->callback = callback;
-        this->user = user;
+        this->mCallback = callback;
+        this->mUser = user;
+        this->mHandler = nullptr;
+    }
+
+    /**
+     * Set or replace the release callback function
+     * @param handler   The Handler to use to dispatch the callback
+     * @param callback  The new callback function
+     * @param user      An opaque user pointer passed to the callbeck function when it's called
+     */
+    void setCallback(CallbackHandler* handler, Callback callback, void* user = nullptr) noexcept {
+        mCallback = callback;
+        mUser = user;
+        mHandler = handler;
     }
 
     //! Returns whether a release callback is set
-    bool hasCallback() const noexcept { return callback != nullptr; }
+    bool hasCallback() const noexcept { return mCallback != nullptr; }
 
     //! Returns the currently set release callback function
     Callback getCallback() const noexcept {
-        return callback;
+        return mCallback;
+    }
+
+    //! Returns the handler for this callback or nullptr if the default handler is to be used.
+    CallbackHandler* getHandler() const noexcept {
+        return mHandler;
     }
 
     //! Returns the user opaque pointer associated to this BufferDescriptor
     void* getUser() const noexcept {
-        return user;
+        return mUser;
     }
 
     //! CPU mempry-buffer virtual address
@@ -172,8 +209,9 @@ public:
 
 private:
     // callback when the buffer is consumed.
-    Callback callback = nullptr;
-    void* user = nullptr;
+    Callback mCallback = nullptr;
+    void* mUser = nullptr;
+    CallbackHandler* mHandler = nullptr;
 };
 
 } // namespace filament::backend