Changed handling of uniforms of arrays of structs

[platform/core/uifw/dali-core.git] / dali / internal / update / common / uniform-map.h

diff --git a/dali/internal/update/common/uniform-map.h b/dali/internal/update/common/uniform-map.h
index d34c014..0a505de 100644 (file)
--- a/dali/internal/update/common/uniform-map.h
+++ b/dali/internal/update/common/uniform-map.h
@@ -2,7 +2,7 @@
 #define DALI_INTERNAL_SCENE_GRAPH_UNIFORM_MAP_H
 
 /*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
@@ -17,9 +17,14 @@
  * limitations under the License.
  */
 
+// EXTERNAL INCLUDES
+#include <cstdint> // uint32_t
+#include <string>
+
+// INTERNAL INCLUDES
 #include <dali/devel-api/common/hash.h>
 #include <dali/devel-api/common/owner-container.h>
-#include <string>
+#include <dali/internal/common/const-string.h>
 
 namespace Dali
 {
@@ -29,36 +34,50 @@ class PropertyInputImpl;
 
 namespace SceneGraph
 {
-
 /**
  * The uniform map is used to map a uniform name to a property value.
  */
 class UniformPropertyMapping
 {
 public:
-  typedef unsigned long Hash;
+  using Hash = unsigned long;
 
   /**
    * Constructor
    */
-  UniformPropertyMapping( const std::string& theUniformName, const PropertyInputImpl* thePropertyPtr )
-  : propertyPtr( thePropertyPtr ),
-    uniformName( theUniformName ),
-    uniformNameHash( Dali::CalculateHash( theUniformName ) )
-  {
-  }
-
-  UniformPropertyMapping()
-  : propertyPtr( NULL ),
-    uniformName( "" ),
-    uniformNameHash( 0 )
+  UniformPropertyMapping(ConstString theUniformName, const PropertyInputImpl* thePropertyPtr)
+  : propertyPtr(thePropertyPtr),
+    uniformName(theUniformName),
+    uniformNameHash(0u),
+    uniformNameHashNoArray(0u),
+    arrayIndex(0u)
   {
+    // Look for array index closing bracket
+    auto nameStringView = theUniformName.GetStringView();
+    auto pos            = nameStringView.rfind("]");
+
+    // If found, extract the array index and store it, if it's an element in an array of basic types.
+    if(pos != std::string::npos)
+    {
+      auto pos0 = theUniformName.GetStringView().rfind("[", pos);
+      if(pos == nameStringView.length() - 1) // if element is in struct, don't set array index.
+      {
+        arrayIndex = atoi(theUniformName.GetCString() + pos0 + 1);
+      }
+      // Calculate hash from name without array index
+      uniformNameHashNoArray = Dali::CalculateHash(theUniformName.GetStringView().substr(0, pos0).data(), '[');
+    }
+    uniformName     = theUniformName;
+    uniformNameHash = Dali::CalculateHash(theUniformName.GetCString());
   }
 
+  UniformPropertyMapping() = default;
 
-  const PropertyInputImpl* propertyPtr;
-  std::string uniformName;
-  Hash uniformNameHash;
+  const PropertyInputImpl* propertyPtr{nullptr};
+  ConstString              uniformName{};
+  Hash                     uniformNameHash{0u};
+  Hash                     uniformNameHashNoArray{0u};
+  int32_t                  arrayIndex{0u};
 };
 
 /**
@@ -71,60 +90,62 @@ public:
 class UniformMap
 {
 public:
+  using SizeType = uint32_t;
+
   class Observer
   {
   public:
+    /**
+     * Inform observer that uniform mappings have been changed
+     * @param mappings
+     */
     virtual void UniformMappingsChanged(const UniformMap& mappings) = 0;
-  };
 
-  /**
-   * Constructor
-   */
-  UniformMap();
-
-  /**
-   * Destructor
-   */
-  ~UniformMap();
+  protected:
+    /**
+     * Virtual destructor, no deletion through this interface
+     */
+    virtual ~Observer() = default;
+  };
 
   /**
    * Add an observer that watches for changes in the mappings
    */
-  void AddObserver( Observer& observer );
+  void AddObserver(Observer& observer);
 
   /**
    * Remove an observer
    */
-  void RemoveObserver( Observer& observer );
+  void RemoveObserver(Observer& observer);
 
   /**
    * Add a map to the mappings table.
    */
-  void Add( UniformPropertyMapping* map );
+  void Add(UniformPropertyMapping map);
 
   /**
    * Remove a map from the mappings table
    */
-  void Remove( const std::string& uniformName );
+  void Remove(ConstString uniformName);
 
   /**
    * Find a property given the uniform name.
    * @return The address of the property if it's in the map, or NULL otherwise.
    */
-  const PropertyInputImpl* Find( const std::string& uniformName );
+  const PropertyInputImpl* Find(ConstString uniformName);
 
   /**
    * Get the count of uniforms in the map
    * @return The number of uniform mappings
    */
-  unsigned int Count() const;
+  SizeType Count() const;
 
   /**
    * @pre index must be in the range 0 :: Count()-1
    * @param[in] index The index of the element to fetch
    * @return reference to the element in the map
    */
-  const UniformPropertyMapping& operator[]( unsigned int index ) const;
+  const UniformPropertyMapping& operator[](SizeType index) const;
 
 private:
   /**
@@ -133,17 +154,16 @@ private:
   void MappingChanged();
 
 private:
-  typedef OwnerContainer< UniformPropertyMapping* > UniformMapContainer;
-  typedef UniformMapContainer::Iterator UniformMapIter;
-  typedef Dali::Vector< Observer* > Observers;
-  typedef Observers::Iterator ObserversIter;
+  using UniformMapContainer = Dali::Vector<UniformPropertyMapping>;
+  using UniformMapIter      = UniformMapContainer::Iterator;
+  using Observers           = Dali::Vector<Observer*>;
+  using ObserversIter       = Observers::Iterator;
 
   UniformMapContainer mUniformMaps; // Owner container of uniform maps
 
   Observers mObservers;
 };
 
-
 } // namespace SceneGraph
 } // namespace Internal
 } // namespace Dali