#define DALI_INTERNAL_SCENE_GRAPH_UNIFORM_MAP_H
/*
- * Copyright (c) 2015 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.
* limitations under the License.
*/
-#include <dali/devel-api/common/hash.h>
-#include <dali/devel-api/common/owner-container.h>
+// EXTERNAL INCLUDES
+#include <cstdint> // uint32_t
#include <string>
+// INTERNAL INCLUDES
+#include <dali/public-api/common/dali-vector.h>
+
+#include <dali/devel-api/common/hash.h>
+
+#include <dali/internal/common/const-string.h>
+
namespace Dali
{
namespace Internal
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(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()
- : propertyPtr( NULL ),
- uniformName( "" ),
- uniformNameHash( 0 )
- {
- }
+ 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};
};
/**
* The UniformMap class is used to map uniform names to property values. It is available
- * in all of the classes responsible for rendering:
- * Actor, Renderer, Geometry, Material, Shader.
+ * in the following rendering classes: Node, Renderer, Shader.
*
- * It can be observed for changes to the mapping table.
+ * They can test the ChangeCounter to see if the mapping has been updated.
*/
class UniformMap
{
public:
- class Observer
- {
- public:
- virtual void UniformMappingsChanged(const UniformMap& mappings) = 0;
- };
-
- /**
- * Constructor
- */
- UniformMap();
-
- /**
- * Destructor
- */
- ~UniformMap();
-
- /**
- * Add an observer that watches for changes in the mappings
- */
- void AddObserver( Observer& observer );
-
- /**
- * Remove an observer
- */
- void RemoveObserver( Observer& observer );
+ using SizeType = uint32_t;
/**
* 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;
+
+ /**
+ * Return the change counter
+ */
+ inline std::size_t GetChangeCounter() const
+ {
+ return mChangeCounter;
+ }
private:
/**
void MappingChanged();
private:
- typedef OwnerContainer< UniformPropertyMapping* > UniformMapContainer;
- typedef UniformMapContainer::Iterator UniformMapIter;
- typedef Dali::Vector< Observer* > Observers;
- typedef Observers::Iterator ObserversIter;
-
- UniformMapContainer mUniformMaps; // Owner container of uniform maps
+ using UniformMapContainer = Dali::Vector<UniformPropertyMapping>;
+ using UniformMapIter = UniformMapContainer::Iterator;
- Observers mObservers;
+ UniformMapContainer mUniformMaps; ///< container of uniform maps
+ std::size_t mChangeCounter{0u}; ///< Counter that is incremented when the map changes
};
-
} // namespace SceneGraph
} // namespace Internal
} // namespace Dali