RTFXData.h

Go to the documentation of this file.

#ifndef __RTFX_DATA__
#define __RTFX_DATA__

#include "RTFXBoostIncludes.h"
#include "RTFXMath.h"
#include "RTFXRecorder.h"
#include "RTFXHelpers.h"
#include "RTFXProperty.h"
#include "RTFXObject.h"
#include "RTFXCamera.h"
#include "RTFXLight.h"
#include "RTFXGeometry.h"
#include "RTFXSkeleton.h"
#include "RTFXParticleSystem.h"
#include "RTFXRaw.h"
#include "RTFXScript.h"
#include "RTFXCustom.h"

using namespace std;

namespace RTFX
{
    class RTFXAPI RTFXData 
    {
        public:
            RTFXData();
            ~RTFXData();

            void DeleteObjectMemoryMap();

            void DeletePropertyMemoryMap();

            void DeleteParentMemoryVector();

            void DeleteChildrenMemoryVector();

            void SetID( boost::uuids::uuid _id );

            void SetRoot( bool _root );

            void SetName( std::string _name );

            void SetDescription( std::string _description );

            boost::uuids::uuid GetID();

            bool GetRoot();

            std::string GetName();

            std::string GetDescription();

            void AddProperty( RTFXProperty * _property );

            bool PropertyExists( boost::uuids::uuid _id, std::string _propertyName );

            void DeleteProperty( boost::uuids::uuid _id, std::string _propertyName );

            RTFXProperty * GetProperty( boost::uuids::uuid _id, std::string _propertyName );

            void AddObject( RTFXObject * _object );

            bool ObjectExists( boost::uuids::uuid _id );

            bool ObjectExists( std::string _name );

            RTFXObject * GetAnObject( boost::uuids::uuid _id );

            RTFXObject * GetAnObject( std::string _name );

            void DeleteObject( boost::uuids::uuid _id );

            void DeleteObject( std::string _name );

            void DeleteAllWithOwner( boost::uuids::uuid _id );

            std::vector<RTFXData *> * GetParents();

            std::vector<RTFXData *> * GetChildren();

            void AddParent( RTFXData * _parent );

            void AddChild( RTFXData * _child );

            RTFXData * FindParent( std::string _name );

            RTFXData * FindChild( std::string _name );

            void DeleteParent( std::string _name );

            std::vector<RTFXProperty *> GetChangedProperties();

            vector<RTFXObject *> GetNewObjects();

            RTFXData * GetUpdated();

            void Rebuild();

            RTFXObject * FindObjectInGraph( boost::uuids::uuid _id );

            RTFXProperty * FindPropertyNotAtObjectLevel( boost::uuids::uuid _id, std::string _propertyName );

            RTFXData * FindChild( boost::uuids::uuid _id );

            vector<RTFXObject *> GetAllObjects();

            unsigned int NumberOfObjectsOfType( unsigned int _type );

            bool AreThereAnyObjectsOfType( unsigned int _type );

            vector<RTFXObject *> GetObjectsOfType( RTFXObject::RTFXObjectType _objectType );

            void Merge( RTFXData * _other );

            RTFXBIGINT GetNumObjects();

            boost::uuids::uuid GetObjectIDOfTypeAtIndex( unsigned int _type, unsigned int _idx );


            void UpdateProcessCompleted();

            void SetLocks( bool _useLocks )
            {
                useLocks = _useLocks;
            }

            bool GetLockStatus()
            {
                return useLocks;
            }

            void RemoveObjectReferences( boost::uuids::uuid _id );

            void RemovePropertyReferences( boost::uuids::uuid _owner, string _name );

            void AssignOwner( boost::uuids::uuid _owner )
            {
                // Object owners
                std::map<boost::uuids::uuid, RTFXObject *>::iterator iter_ = objectMap.begin();
                while ( iter_ != objectMap.end() )
                {
                    // If the owner is NIL, give it an owner
                    if ( ( (*iter_).second )->GetOwner() == boost::uuids::nil_uuid() )
                    {
                        ( (*iter_).second )->SetOwner( _owner );
                    }
                    iter_ ++;
                }

                // Property owners
                std::map< pair<boost::uuids::uuid, std::string>, RTFXProperty *>::iterator iter2_ = propertyMap.begin();
                while ( iter2_ != propertyMap.end() )
                {
                    // if the owner is NIL, give it an owner
                    if ( ( (*iter2_).second )->GetOwner() == boost::uuids::nil_uuid() )
                        ( (*iter2_).second )->SetOwner( _owner );
                    iter2_ ++;
                }
            }

        private:
            bool MergeObject( RTFXObject * _obj );

            bool MergeProperty( RTFXProperty * _prop );

            bool useLocks;

            RTFXObject * FindAnObject( boost::uuids::uuid _id )
            {
                RTFXObject * ptr_ = NULL;

                {
                    debug( ostringstream().flush() << "RTFXData::FindAnObject: by id - " << boost::lexical_cast<string>(_id) << endl );
                    if ( ObjectExists( _id ) )
                    {
                        ptr_ = objectMap[ _id ];
                        debug( ostringstream().flush() << "RTFXData::FindAnObject: object exists - " << ptr_->GetName() << endl );
                    }
                    else
                        debug( ostringstream().flush() << "RTFXData::FindAnObject: by id - object not found" << endl );
                }
                return ptr_;
            }

            RTFXObject * FindAnObject( std::string _name )
            {
                RTFXObject * ptr_ = NULL;

                {
                    debug( ostringstream().flush() << "RTFXData::FindAnObject: by name - " << _name << endl );
                    if ( ObjectExists( _name ) )
                        ptr_ = FindAnObject( objectMapByName[ _name ] );
                    else
                        debug( ostringstream().flush() << "RTFXData::FindAnObject: by name - object not found" << endl );
                }
                return ptr_;
            }

            boost::mutex graphLock;

            boost::uuids::uuid id;

            bool isRoot;

            std::string name;

            std::string description;

            std::map< pair<boost::uuids::uuid, std::string>, RTFXProperty *> propertyMap;

            std::map<boost::uuids::uuid, RTFXObject *> objectMap;

            std::map<std::string, boost::uuids::uuid> objectMapByName;

            std::vector<RTFXData *> parents;

            std::vector<RTFXData *> children;

            std::map<RTFXObject::RTFXObjectType, std::vector<boost::uuids::uuid> > listOfObjectIdsByType;

            //boost::recursive_mutex objectMutex;

            friend class boost::serialization::access;

            template<class Archive>
            void serialize( Archive &_ar, const unsigned int _version )
            {
                _ar & id & isRoot & name & description;
                _ar & objectMap & objectMapByName;
                _ar & propertyMap & children & listOfObjectIdsByType; // & objectMap & children;
            };
    };

    RTFXAPI void Serialize( RTFXData * _graph, string &_output );

    RTFXAPI RTFXData * Deserialize( string &_data );

    RTFXAPI void SerializeText( RTFXData * _graph, string &_output );

    RTFXAPI RTFXData * DeserializeText( string &_data );
}

#endif