Added support for heterogenous metadata on the aiNodes.

code/FBXConverter.cpp

@@ -760,48 +760,33 @@ private:
 		aiMetadata* data = new aiMetadata();
 		data->mNumProperties = unparsedProperties.size() + numStaticMetaData;
 		data->mKeys = new aiString[data->mNumProperties]();
-		data->mValues = new aiString[data->mNumProperties]();
+		data->mValues = new aiMetaDataEntry[data->mNumProperties]();
 		nd.mMetaData = data;
 		int index = 0;
 
 		// find user defined properties (3ds Max)
-		data->mKeys[index].Set("UserProperties");
+		data->Set(index++, "UserProperties", aiString(PropertyGet<std::string>(props, "UDP3DSMAX", "")));
-		data->mValues[index].Set(PropertyGet<std::string>(props, "UDP3DSMAX", ""));
-		++index;
-
 		// preserve the info that a node was marked as Null node in the original file.
-		data->mKeys[index].Set("IsNull");
+		data->Set(index++, "IsNull", model.IsNull() ? true : false);
-		data->mValues[index].Set(model.IsNull() ? "true" : "false");
-		++index;
 
 		// add unparsed properties to the node's metadata
 		BOOST_FOREACH(const DirectPropertyMap::value_type& prop, unparsedProperties) {
 
-			// all values are converted to strings using the following stringstream
-			std::stringstream ss;
-			bool parse_succeeded = false;
-
 			// Interpret the property as a concrete type
-			if (const TypedProperty<std::string>* interpreted = prop.second->As<TypedProperty<std::string> >())
+			if (const TypedProperty<bool>* interpreted = prop.second->As<TypedProperty<bool> >())
-				ss << interpreted->Value();
+				data->Set(index++, prop.first, interpreted->Value());
-			else if (const TypedProperty<bool>* interpreted = prop.second->As<TypedProperty<bool> >())
-				ss << interpreted->Value();
 			else if (const TypedProperty<int>* interpreted = prop.second->As<TypedProperty<int> >())
-				ss << interpreted->Value();
+				data->Set(index++, prop.first, interpreted->Value());
 			else if (const TypedProperty<uint64_t>* interpreted = prop.second->As<TypedProperty<uint64_t> >())
-				ss << interpreted->Value();
+				data->Set(index++, prop.first, interpreted->Value());
 			else if (const TypedProperty<float>* interpreted = prop.second->As<TypedProperty<float> >())
-				ss << interpreted->Value();
+				data->Set(index++, prop.first, interpreted->Value());
+			else if (const TypedProperty<aiString>* interpreted = prop.second->As<TypedProperty<aiString> >())
+				data->Set(index++, prop.first, interpreted->Value());
 			else if (const TypedProperty<aiVector3D>* interpreted = prop.second->As<TypedProperty<aiVector3D> >())
-			{
+				data->Set(index++, prop.first, interpreted->Value());
-				aiVector3D v = interpreted->Value();
+			else
-				ss << v.x << ";" << v.y << ";" << v.z;
+				assert(false);
-			}
-
-			// add property to meta data
-			data->mKeys[index].Set(prop.first);
-			data->mValues[index].Set(ss.str());
-			++index;
 		}
 	}
 

code/IFCLoader.cpp

@@ -726,16 +726,12 @@ aiNode* ProcessSpatialStructure(aiNode* parent, const IfcProduct& el, Conversion
 			aiMetadata* data = new aiMetadata();
 			data->mNumProperties = properties.size();
 			data->mKeys = new aiString[data->mNumProperties]();
-			data->mValues = new aiString[data->mNumProperties]();
+			data->mValues = new aiMetaDataEntry[data->mNumProperties]();
+
+			unsigned int index = 0;
+			BOOST_FOREACH(const Metadata::value_type& kv, properties)
+				data->Set(index++, kv.first, aiString(kv.second));
 
-			unsigned int i = 0;
-			BOOST_FOREACH(const Metadata::value_type& kv, properties) {
-				data->mKeys[i].Set(kv.first);
-				if (kv.second.length() > 0) {
-					data->mValues[i].Set(kv.second);
-				}				
-				++i;
-			}
 			nd->mMetaData = data;
 		}
 	}

include/assimp/metadata.h

@@ -45,10 +45,116 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef __AI_METADATA_H_INC__
 #define __AI_METADATA_H_INC__
 
+#include <stdint.h>
+
+
+
+// -------------------------------------------------------------------------------
+/**
+  * Enum used to distinguish data types
+  */
+ // -------------------------------------------------------------------------------
+enum aiType
+{
+	AI_BOOL = 0, 
+	AI_INT = 1, 
+	AI_UINT64 = 2, 
+	AI_FLOAT = 3, 
+	AI_AISTRING = 4,
+	AI_AIVECTOR3D = 5,
+
+	FORCE_32BIT = INT_MAX
+};
+
+
+
+// -------------------------------------------------------------------------------
+/**
+  * Metadata entry
+  *
+  * The type field uniquely identifies the underlying type of the data field
+  */
+ // -------------------------------------------------------------------------------
+struct aiMetaDataEntry
+{
+	aiType type;
+	void* data;
+};
+
+
+
 #ifdef __cplusplus
-extern "C" {
+
+// -------------------------------------------------------------------------------
+/**
+  * Helper functions to get the aiType enum entry for a type
+  */
+ // -------------------------------------------------------------------------------
+inline aiType GetAiType( bool ) { return aiType::AI_BOOL; }
+inline aiType GetAiType( int ) { return aiType::AI_INT; }
+inline aiType GetAiType( uint64_t ) { return aiType::AI_UINT64; }
+inline aiType GetAiType( float ) { return aiType::AI_FLOAT; }
+inline aiType GetAiType( aiString ) { return aiType::AI_AISTRING; }
+inline aiType GetAiType( aiVector3D ) { return aiType::AI_AIVECTOR3D; }
+
+
+
+// -------------------------------------------------------------------------------
+/**
+  * Transform
+  *
+  * Applies the callable, c, to the given data of the given type.
+  * The callable, c, is expected to have the following interface
+  *
+  *		c( T* data )
+  *
+  * where T can be any type with a corresponding entry in the aiType enum.
+  */
+ // -------------------------------------------------------------------------------
+template<typename callable>
+inline void transform( aiType type, void* data, callable c )
+{
+	switch (type) 
+	{
+	case aiType::AI_BOOL:
+		callable(static_cast<bool*>(data));
+		break;
+	case aiType::AI_INT:
+		callable(static_cast<int*>(data));
+		break;
+	case aiType::AI_UINT64:
+		callable(static_cast<uint64_t*>(data));
+		break;
+	case aiType::AI_FLOAT:
+		callable(static_cast<float*>(data));
+		break;
+	case aiType::AI_AISTRING:
+		callable(static_cast<aiString*>(data));
+		break;
+	case aiType::AI_AIVECTOR3D:
+		callable(static_cast<aiVector3D*>(data));
+		break;
+	default:
+		assert(false);
+		break;
+	}
+}
+
+// -------------------------------------------------------------------------------
+/**
+  * Transform. 
+  * 
+  * This is a convenience overload for aiMetaDataEntry's.
+  */
+ // -------------------------------------------------------------------------------
+template<typename callable>
+inline void transform( aiMetaDataEntry entry, callable c )
+{ transform(entry.type, entry.data, c); }
+
 #endif
 
+
+
 // -------------------------------------------------------------------------------
 /**
   * Container for holding metadata.
@@ -66,18 +172,17 @@ struct aiMetadata
 
 	/** Arrays of values, may not be NULL. Entries in this array may be NULL if the
 	  * corresponding property key has no assigned value. */
-	C_STRUCT aiString* mValues;
+	C_STRUCT aiMetaDataEntry* mValues;
 
 #ifdef __cplusplus
 
 	/** Constructor */
 	aiMetadata()
-	{
 		// set all members to zero by default
-		mKeys = NULL;
+		: mKeys(NULL)
-		mValues = NULL;
+		, mValues(NULL)
-		mNumProperties = 0;
+		, mNumProperties(0)
-	}
+	{}
 
 
 	/** Destructor */
@@ -86,27 +191,60 @@ struct aiMetadata
 		if (mKeys)
 			delete [] mKeys;
 		if (mValues)
+		{
+			// Delete each metadata entry
+			for (unsigned i=0; i<mNumProperties; ++i)
+				transform(mValues[i], (void (*)(void*))(operator delete));
+			// Delete the metadata array
 			delete [] mValues;
 		}
 		
+	}
 
-	inline bool Get(const aiString& key, aiString& value)
+
+
+	template<typename T>
+	inline void Set( unsigned index, const std::string& key, const T& value )
 	{
-		for (unsigned i=0; i<mNumProperties; ++i) {
+		// In range assertion
-			if (mKeys[i]==key) {
+		assert(index < mNumProperties);
-				value=mValues[i];
+
+		// Set metadata key
+		mKeys[index] = key;
+
+		// Set metadata type
+		mValues[index].type = GetAiType(value);
+		// Copy the given value to the dynamic storage
+		mValues[index].data = new T(value);
+	}
+
+	template<typename T>
+	inline bool Get( unsigned index, T& value )
+	{
+		// Return false if the output data type does 
+		// not match the found value's data type
+		if (GetAiType(value) != mValues[index].type)
+			return false;
+
+		// Otherwise, output the found value and 
+		// return true
+		value = *static_cast<T*>(mValues[index].data);
 		return true;
 	}
-		}
+
+	template<typename T>
+	inline bool Get( const aiString& key, T& value )
+	{
+		// Search for the given key
+		for (unsigned i=0; i<mNumProperties; ++i)
+			if (mKeys[i]==key)
+				return Get(i, value);
 		return false;
 	}
+
 #endif // __cplusplus
 };
 
-#ifdef __cplusplus
-} //extern "C" {
-#endif
-
 #endif // __AI_METADATA_H_INC__