Merge changes I8783ad29,I2c860a84 into devel/master

[platform/core/uifw/dali-core.git] / dali / internal / update / common / double-buffered.h

diff --git a/dali/internal/update/common/double-buffered.h b/dali/internal/update/common/double-buffered.h
index 981caed..65f7cd6 100644 (file)
--- a/dali/internal/update/common/double-buffered.h
+++ b/dali/internal/update/common/double-buffered.h
@@ -1,8 +1,8 @@
-#ifndef __DALI_INTERNAL_SCENE_GRAPH_DOUBLE_BUFFERED_H__
-#define __DALI_INTERNAL_SCENE_GRAPH_DOUBLE_BUFFERED_H__
+#ifndef DALI_INTERNAL_SCENE_GRAPH_DOUBLE_BUFFERED_H
+#define DALI_INTERNAL_SCENE_GRAPH_DOUBLE_BUFFERED_H
 
 /*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2023 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,33 +19,25 @@
  */
 
 // INTERNAL INCLUDES
-#include <dali/public-api/math/matrix.h>
-#include <dali/public-api/math/quaternion.h>
-#include <dali/public-api/math/vector3.h>
+#include <dali/internal/common/buffer-index.h>
+#include <dali/internal/common/owner-pointer.h>
 
 namespace Dali
 {
-
 namespace Internal
 {
-
 // The number of buffers per scene-graph property
 static const unsigned int NUM_SCENE_GRAPH_BUFFERS = 2;
 
-// Buffer index used when reading off-stage values
-static const unsigned int ARBITRARY_OFF_STAGE_BUFFER = 0;
-
 namespace SceneGraph
 {
-
 /**
  * Templated class for a double-buffered value.
  */
-template <typename T>
+template<typename T>
 class DoubleBuffered
 {
 public:
-
   DoubleBuffered()
   : mValue1(),
     mValue2()
@@ -58,22 +50,21 @@ public:
   {
   }
 
-  inline T& operator[](const size_t i)
+  inline T& operator[](const BufferIndex i)
   {
     DALI_ASSERT_DEBUG(i < NUM_SCENE_GRAPH_BUFFERS);
 
-    return *(&mValue1+i);
+    return *(&mValue1 + i);
   }
 
-  inline const T& operator[](const size_t i) const
+  inline const T& operator[](const BufferIndex i) const
   {
     DALI_ASSERT_DEBUG(i < NUM_SCENE_GRAPH_BUFFERS);
 
-    return *(&mValue1+i);
+    return *(&mValue1 + i);
   }
 
 private:
-
   // Undefined
   DoubleBuffered<T>(const DoubleBuffered<T>&);
 
@@ -81,15 +72,145 @@ private:
   DoubleBuffered<T>& operator=(const DoubleBuffered<T>& rhs);
 
 private:
-
   T mValue1;
   T mValue2;
 };
 
+/**
+ * @brief Specialization for owner-pointer
+ *
+ * This class takes ownership of the pointers and releases the memory when the pointer
+ * is no longer used by either buffer
+ */
+template<typename T>
+class DoubleBuffered<OwnerPointer<T> >
+{
+public:
+  /**
+   * Class that deals with setting a value
+   */
+  class Setter
+  {
+  public:
+    /**
+     * @brief Assignment operator to that a value that will later
+     * be set in the correct buffer index of the object referenced by the setter.
+     */
+    Setter& operator=(T* value)
+    {
+      mValue = value;
+      return *this;
+    }
+
+    ~Setter()
+    {
+      mObject.Set(mIndex, mValue);
+    }
+
+  private:
+    Setter(DoubleBuffered& object,
+           BufferIndex     i,
+           T*              value)
+    : mObject(object),
+      mIndex(i),
+      mValue(value)
+    {
+    }
+
+    Setter(const Setter& rhs)
+    : mObject(rhs.mObject),
+      mIndex(rhs.mIndex),
+      mValue(rhs.mValue)
+    {
+    }
+
+    DoubleBuffered&   mObject; ///< Double-buffered object that will be changed
+    const BufferIndex mIndex;  ///< Buffer index that will be changed
+    T*                mValue;  ///< Value of the pointer
+
+    friend class DoubleBuffered;
+  };
+
+  DoubleBuffered()
+  : mValue1(NULL),
+    mValue2(NULL)
+  {
+  }
+
+  DoubleBuffered(T* val)
+  : mValue1(val),
+    mValue2(val)
+  {
+  }
+
+  ~DoubleBuffered()
+  {
+    if(mValue2 != mValue1)
+    {
+      delete mValue2;
+    }
+    delete mValue1;
+  }
+
+  void Set(BufferIndex i, T* value)
+  {
+    T*& current  = *(&mValue1 + i);
+    T*& previous = *(&mValue1 + 1u - i);
+
+    if(current != value && current != previous)
+    {
+      delete current;
+    }
+    current = value;
+  }
+
+  Setter operator[](BufferIndex i)
+  {
+    return Setter(*this, i, *(&mValue1 + i));
+  }
+
+  const T* operator[](BufferIndex i) const
+  {
+    DALI_ASSERT_DEBUG(i < NUM_SCENE_GRAPH_BUFFERS);
+
+    return *(&mValue1 + i);
+  }
+
+  /**
+   * Auto-age the property: if it was set the previous frame,
+   * then copy the value into the current frame's buffer.
+   */
+  void CopyPrevious(BufferIndex i)
+  {
+    DALI_ASSERT_DEBUG(i < NUM_SCENE_GRAPH_BUFFERS);
+
+    T*& current  = *(&mValue1 + i);
+    T*& previous = *(&mValue1 + 1u - i);
+
+    if(current != previous)
+    {
+      delete current;
+    }
+
+    current = previous;
+  }
+
+private:
+  // Undefined
+  DoubleBuffered(const DoubleBuffered&);
+
+  // Undefined
+  DoubleBuffered& operator=(const DoubleBuffered& rhs);
+
+private:
+  T* mValue1;
+  T* mValue2;
+};
+
 } // namespace SceneGraph
 
 } // namespace Internal
 
 } // namespace Dali
 
-#endif // __DALI_INTERNAL_SCENE_GRAPH_DOUBLE_BUFFERED_H__
+#endif // DALI_INTERNAL_SCENE_GRAPH_DOUBLE_BUFFERED_H