Code/CryEngine/CrySchematyc2/Lib.cpp

   1 // Copyright 2001-2019 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #include "StdAfx.h"
   4 #include "Lib.h"
   5
   6 #include <CrySerialization/BlackBox.h>
   7 #include <CrySerialization/IArchiveHost.h>
   8 #include <CrySerialization/STL.h>
   9 #include <CrySchematyc2/ILibRegistry.h>
  10 #include <CrySchematyc2/LibUtils.h>
  11 #include <CrySchematyc2/Deprecated/IGlobalFunction.h>
  12 #include <CrySchematyc2/Env/IEnvRegistry.h>
  13 #include <CrySchematyc2/Utils/StringUtils.h>
  14 #include <CrySchematyc2/Serialization/Resources/IResourceCollectorArchive.h>
  15 #include "CVars.h"
  16
  17 SERIALIZATION_ENUM_BEGIN_NESTED2(Schematyc2, CLibClassProperties, EInternalOverridePolicy, "Schematyc Library Class Property Override Policy")
  18         SERIALIZATION_ENUM(Schematyc2::CLibClassProperties::EInternalOverridePolicy::UseDefault, "UseDefault", "Default")
  19         SERIALIZATION_ENUM(Schematyc2::CLibClassProperties::EInternalOverridePolicy::OverrideDefault, "OverrideDefault", "Override")
  20 SERIALIZATION_ENUM_END()
  21
  22 namespace Schematyc2
  23 {
  24         const size_t CLibFunction::MIN_CAPACITY  = 512;
  25         const size_t CLibFunction::GROWTH_FACTOR = 8;
  26
  27         struct SComponentInstanceSortRef
  28         {
  29                 inline SComponentInstanceSortRef(size_t _iComponentInstance)
  30                         : iComponentInstance(_iComponentInstance)
  31                         , priority(0)
  32                 {}
  33
  34                 size_t       iComponentInstance;
  35                 int32        priority;
  36                 TSizeTVector dependencies;
  37         };
  38
  39         typedef std::vector<SComponentInstanceSortRef> TComponentInstanceSortRefVector;
  40
  41         struct SComponentInstanceSortPredicate
  42         {
  43                 inline bool operator () (const SComponentInstanceSortRef& lhs, const SComponentInstanceSortRef& rhs) const
  44                 {
  45                         if (lhs.priority != rhs.priority)
  46                         {
  47                                 return lhs.priority > rhs.priority;
  48                         }
  49                         return lhs.iComponentInstance < rhs.iComponentInstance;
  50                 }
  51         };
  52
  53         //////////////////////////////////////////////////////////////////////////
  54         CLibAbstractInterfaceFunction::CLibAbstractInterfaceFunction(const SGUID& guid, const char* szName)
  55                 : m_guid(guid)
  56                 , m_name(szName)
  57         {}
  58
  59         //////////////////////////////////////////////////////////////////////////
  60         SGUID CLibAbstractInterfaceFunction::GetGUID() const
  61         {
  62                 return m_guid;
  63         }
  64
  65         //////////////////////////////////////////////////////////////////////////
  66         const char* CLibAbstractInterfaceFunction::GetName() const
  67         {
  68                 return m_name.c_str();
  69         }
  70
  71         //////////////////////////////////////////////////////////////////////////
  72         TVariantConstArray CLibAbstractInterfaceFunction::GetVariantInputs() const
  73         {
  74                 return m_variantInputs;
  75         }
  76
  77         //////////////////////////////////////////////////////////////////////////
  78         TVariantConstArray CLibAbstractInterfaceFunction::GetVariantOutputs() const
  79         {
  80                 return m_variantOutputs;
  81         }
  82
  83         //////////////////////////////////////////////////////////////////////////
  84         void CLibAbstractInterfaceFunction::AddInput(const IAny& value)
  85         {
  86                 CVariantVectorOutputArchive archive(m_variantInputs);
  87                 archive(value, "", "");
  88         }
  89
  90         //////////////////////////////////////////////////////////////////////////
  91         void CLibAbstractInterfaceFunction::AddOutput(const IAny& value)
  92         {
  93                 CVariantVectorOutputArchive archive(m_variantOutputs);
  94                 archive(value, "", "");
  95         }
  96
  97         //////////////////////////////////////////////////////////////////////////
  98         CLibAbstractInterface::CLibAbstractInterface(const SGUID& guid, const char* szName)
  99                 : m_guid(guid)
 100                 , m_name(szName)
 101         {}
 102
 103         //////////////////////////////////////////////////////////////////////////
 104         SGUID CLibAbstractInterface::GetGUID() const
 105         {
 106                 return m_guid;
 107         }
 108
 109         //////////////////////////////////////////////////////////////////////////
 110         const char* CLibAbstractInterface::GetName() const
 111         {
 112                 return m_name.c_str();
 113         }
 114
 115         //////////////////////////////////////////////////////////////////////////
 116         CLibStateMachine::CLibStateMachine(const SGUID& guid, const char* szName, const EStateMachineLifetime lifetime, const EStateMachineNetAuthority netType)
 117                 : m_guid(guid)
 118                 , m_name(szName)
 119                 , m_lifetime(lifetime)
 120                 , m_netAuthority(netType)
 121                 , m_iPartner(INVALID_INDEX)
 122         {}
 123
 124         //////////////////////////////////////////////////////////////////////////
 125         SGUID CLibStateMachine::GetGUID() const
 126         {
 127                 return m_guid;
 128         }
 129
 130         //////////////////////////////////////////////////////////////////////////
 131         const char* CLibStateMachine::GetName() const
 132         {
 133                 return m_name.c_str();
 134         }
 135
 136         //////////////////////////////////////////////////////////////////////////
 137         EStateMachineLifetime CLibStateMachine::GetLifetime() const
 138         {
 139                 return m_lifetime;
 140         }
 141
 142         Schematyc2::EStateMachineNetAuthority CLibStateMachine::GetNetAuthority() const
 143         {
 144                 return m_netAuthority;
 145         }
 146
 147         //////////////////////////////////////////////////////////////////////////
 148         size_t CLibStateMachine::GetPartner() const
 149         {
 150                 return m_iPartner;
 151         }
 152
 153         //////////////////////////////////////////////////////////////////////////
 154         size_t CLibStateMachine::GetListenerCount() const
 155         {
 156                 return m_listeners.size();
 157         }
 158
 159         //////////////////////////////////////////////////////////////////////////
 160         size_t CLibStateMachine::GetListener(size_t iListener) const
 161         {
 162                 return iListener < m_listeners.size() ? m_listeners[iListener] : INVALID_INDEX;
 163         }
 164
 165         //////////////////////////////////////////////////////////////////////////
 166         size_t CLibStateMachine::GetVariableCount() const
 167         {
 168                 return m_variables.size();
 169         }
 170
 171         //////////////////////////////////////////////////////////////////////////
 172         size_t CLibStateMachine::GetVariable(const size_t iVariable) const
 173         {
 174                 return iVariable < m_variables.size() ? m_variables[iVariable] : INVALID_INDEX;
 175         }
 176
 177         //////////////////////////////////////////////////////////////////////////
 178         size_t CLibStateMachine::GetContainerCount() const
 179         {
 180                 return m_containers.size();
 181         }
 182
 183         //////////////////////////////////////////////////////////////////////////
 184         size_t CLibStateMachine::GetContainer(const size_t iContainer) const
 185         {
 186                 return iContainer < m_containers.size() ? m_containers[iContainer] : INVALID_INDEX;
 187         }
 188
 189         //////////////////////////////////////////////////////////////////////////
 190         void CLibStateMachine::SetBeginFunction(const LibFunctionId& functionId)
 191         {
 192                 m_beginFunctionId = functionId;
 193         }
 194
 195         //////////////////////////////////////////////////////////////////////////
 196         LibFunctionId CLibStateMachine::GetBeginFunction() const
 197         {
 198                 return m_beginFunctionId;
 199         }
 200
 201         //////////////////////////////////////////////////////////////////////////
 202         void CLibStateMachine::SetPartner(size_t iPartner)
 203         {
 204                 m_iPartner = iPartner;
 205         }
 206
 207         //////////////////////////////////////////////////////////////////////////
 208         void CLibStateMachine::AddListener(size_t iListener)
 209         {
 210                 m_listeners.push_back(iListener);
 211         }
 212
 213         //////////////////////////////////////////////////////////////////////////
 214         void CLibStateMachine::AddVariable(const size_t iVariable)
 215         {
 216                 m_variables.push_back(iVariable);
 217         }
 218
 219         //////////////////////////////////////////////////////////////////////////
 220         void CLibStateMachine::AddContainer(const size_t iContainer)
 221         {
 222                 m_containers.push_back(iContainer);
 223         }
 224
 225         //////////////////////////////////////////////////////////////////////////
 226         void CLibStateMachine::CompactMemory()
 227         {
 228                 m_listeners.shrink_to_fit();
 229                 m_variables.shrink_to_fit();
 230                 m_containers.shrink_to_fit();
 231         }
 232
 233
 234         //////////////////////////////////////////////////////////////////////////
 235         CLibState::CLibState(const SGUID& guid, const char* szName)
 236                 : m_guid(guid)
 237                 , m_name(szName)
 238                 , m_iParent(INVALID_INDEX)
 239                 , m_iPartner(INVALID_INDEX)
 240                 , m_iStateMachine(INVALID_INDEX)
 241         {}
 242
 243         //////////////////////////////////////////////////////////////////////////
 244         SGUID CLibState::GetGUID() const
 245         {
 246                 return m_guid;
 247         }
 248
 249         //////////////////////////////////////////////////////////////////////////
 250         const char* CLibState::GetName() const
 251         {
 252                 return m_name.c_str();
 253         }
 254
 255         //////////////////////////////////////////////////////////////////////////
 256         size_t CLibState::GetParent() const
 257         {
 258                 return m_iParent;
 259         }
 260
 261         //////////////////////////////////////////////////////////////////////////
 262         size_t CLibState::GetPartner() const
 263         {
 264                 return m_iPartner;
 265         }
 266
 267         //////////////////////////////////////////////////////////////////////////
 268         size_t CLibState::GetStateMachine() const
 269         {
 270                 return m_iStateMachine;
 271         }
 272
 273         //////////////////////////////////////////////////////////////////////////
 274         size_t CLibState::GetVariableCount() const
 275         {
 276                 return m_variables.size();
 277         }
 278
 279         //////////////////////////////////////////////////////////////////////////
 280         size_t CLibState::GetVariable(size_t iVariable) const
 281         {
 282                 return iVariable < m_variables.size() ? m_variables[iVariable] : INVALID_INDEX;
 283         }
 284
 285         //////////////////////////////////////////////////////////////////////////
 286         size_t CLibState::GetContainerCount() const
 287         {
 288                 return m_containers.size();
 289         }
 290
 291         //////////////////////////////////////////////////////////////////////////
 292         size_t CLibState::GetContainer(size_t iContainer) const
 293         {
 294                 return iContainer < m_containers.size() ? m_containers[iContainer] : INVALID_INDEX;
 295         }
 296
 297         //////////////////////////////////////////////////////////////////////////
 298         size_t CLibState::GetTimerCount() const
 299         {
 300                 return m_timers.size();
 301         }
 302
 303         //////////////////////////////////////////////////////////////////////////
 304         size_t CLibState::GetTimer(size_t iTimer) const
 305         {
 306                 return iTimer < m_timers.size() ? m_timers[iTimer] : INVALID_INDEX;
 307         }
 308
 309         //////////////////////////////////////////////////////////////////////////
 310         size_t CLibState::GetActionInstanceCount() const
 311         {
 312                 return m_actionInstances.size();
 313         }
 314
 315         //////////////////////////////////////////////////////////////////////////
 316         size_t CLibState::GetActionInstance(size_t iActionInstance) const
 317         {
 318                 return iActionInstance < m_actionInstances.size() ? m_actionInstances[iActionInstance] : INVALID_INDEX;
 319         }
 320
 321         //////////////////////////////////////////////////////////////////////////
 322         size_t CLibState::GetConstructorCount() const
 323         {
 324                 return m_constructors.size();
 325         }
 326
 327         //////////////////////////////////////////////////////////////////////////
 328         size_t CLibState::GetConstructor(size_t iConstructor) const
 329         {
 330                 return iConstructor < m_constructors.size() ? m_constructors[iConstructor] : INVALID_INDEX;
 331         }
 332
 333         //////////////////////////////////////////////////////////////////////////
 334         size_t CLibState::GetDestructorCount() const
 335         {
 336                 return m_destructors.size();
 337         }
 338
 339         //////////////////////////////////////////////////////////////////////////
 340         size_t CLibState::GetDestructor(size_t iDestructor) const
 341         {
 342                 return iDestructor < m_destructors.size() ? m_destructors[iDestructor] : INVALID_INDEX;
 343         }
 344
 345         //////////////////////////////////////////////////////////////////////////
 346         size_t CLibState::GetSignalReceiverCount() const
 347         {
 348                 return m_signalReceivers.size();
 349         }
 350
 351         //////////////////////////////////////////////////////////////////////////
 352         size_t CLibState::GetSignalReceiver(size_t iSignalReceiver) const
 353         {
 354                 return iSignalReceiver < m_signalReceivers.size() ? m_signalReceivers[iSignalReceiver] : INVALID_INDEX;
 355         }
 356
 357         ////////////////////////////////////////a//////////////////////////////////
 358         size_t CLibState::GetTransitionCount() const
 359         {
 360                 return m_transitions.size();
 361         }
 362
 363         //////////////////////////////////////////////////////////////////////////
 364         size_t CLibState::GetTransition(size_t iTransition) const
 365         {
 366                 return iTransition < m_transitions.size() ? m_transitions[iTransition] : INVALID_INDEX;
 367         }
 368
 369         //////////////////////////////////////////////////////////////////////////
 370         void CLibState::SetParent(size_t iParent)
 371         {
 372                 m_iParent = iParent;
 373         }
 374
 375         //////////////////////////////////////////////////////////////////////////
 376         void CLibState::SetPartner(size_t iPartner)
 377         {
 378                 m_iPartner = iPartner;
 379         }
 380
 381         //////////////////////////////////////////////////////////////////////////
 382         void CLibState::SetStateMachine(size_t iStateMachine)
 383         {
 384                 m_iStateMachine = iStateMachine;
 385         }
 386
 387         //////////////////////////////////////////////////////////////////////////
 388         void CLibState::AddVariable(size_t iVariable)
 389         {
 390                 m_variables.push_back(iVariable);
 391         }
 392
 393         //////////////////////////////////////////////////////////////////////////
 394         void CLibState::AddContainer(size_t iContainer)
 395         {
 396                 m_containers.push_back(iContainer);
 397         }
 398
 399         //////////////////////////////////////////////////////////////////////////
 400         void CLibState::AddTimer(size_t iTimer)
 401         {
 402                 m_timers.push_back(iTimer);
 403         }
 404
 405         //////////////////////////////////////////////////////////////////////////
 406         void CLibState::AddActionInstance(size_t iActionInstance)
 407         {
 408                 m_actionInstances.push_back(iActionInstance);
 409         }
 410
 411         //////////////////////////////////////////////////////////////////////////
 412         void CLibState::AddConstructor(size_t iConstructor)
 413         {
 414                 m_constructors.push_back(iConstructor);
 415         }
 416
 417         //////////////////////////////////////////////////////////////////////////
 418         void CLibState::AddDestructor(size_t iDestructor)
 419         {
 420                 m_destructors.push_back(iDestructor);
 421         }
 422
 423         //////////////////////////////////////////////////////////////////////////
 424         void CLibState::AddSignalReceiver(size_t iSignalReceiver)
 425         {
 426                 m_signalReceivers.push_back(iSignalReceiver);
 427         }
 428
 429         //////////////////////////////////////////////////////////////////////////
 430         void CLibState::AddTransition(size_t iTransition)
 431         {
 432                 m_transitions.push_back(iTransition);
 433         }
 434
 435         //////////////////////////////////////////////////////////////////////////
 436         void CLibState::CompactMemory()
 437         {
 438                 m_variables.shrink_to_fit();
 439                 m_containers.shrink_to_fit();
 440                 m_timers.shrink_to_fit();
 441                 m_actionInstances.shrink_to_fit();
 442                 m_constructors.shrink_to_fit();
 443                 m_destructors.shrink_to_fit();
 444                 m_signalReceivers.shrink_to_fit();
 445                 m_transitions.shrink_to_fit();
 446         }
 447
 448         //////////////////////////////////////////////////////////////////////////
 449         CLibVariable::CLibVariable(const SGUID& guid, const char* szName, EOverridePolicy overridePolicy, const IAny& value, size_t variantPos, size_t variantCount, ELibVariableFlags flags)
 450                 : m_guid(guid)
 451                 , m_name(szName)
 452                 , m_overridePolicy(overridePolicy)
 453                 , m_pValue(value.Clone())
 454                 , m_variantPos(variantPos)
 455                 , m_variantCount(variantCount)
 456                 , m_flags(flags)
 457         {}
 458
 459         //////////////////////////////////////////////////////////////////////////
 460         SGUID CLibVariable::GetGUID() const
 461         {
 462                 return m_guid;
 463         }
 464
 465         //////////////////////////////////////////////////////////////////////////
 466         const char* CLibVariable::GetName() const
 467         {
 468                 return m_name.c_str();
 469         }
 470
 471         //////////////////////////////////////////////////////////////////////////
 472         EOverridePolicy CLibVariable::GetOverridePolicy() const
 473         {
 474                 return m_overridePolicy;
 475         }
 476
 477         //////////////////////////////////////////////////////////////////////////
 478         IAnyConstPtr CLibVariable::GetValue() const
 479         {
 480                 return m_pValue;
 481         }
 482
 483         //////////////////////////////////////////////////////////////////////////
 484         size_t CLibVariable::GetVariantPos() const
 485         {
 486                 return m_variantPos;
 487         }
 488
 489         //////////////////////////////////////////////////////////////////////////
 490         size_t CLibVariable::GetVariantCount() const
 491         {
 492                 return m_variantCount;
 493         }
 494
 495         //////////////////////////////////////////////////////////////////////////
 496         ELibVariableFlags CLibVariable::GetFlags() const
 497         {
 498                 return m_flags;
 499         }
 500
 501         //////////////////////////////////////////////////////////////////////////
 502         void CLibVariable::SetOverridePolicy(EOverridePolicy overridePolicy)
 503         {
 504                 m_overridePolicy = overridePolicy;
 505         }
 506
 507         //////////////////////////////////////////////////////////////////////////
 508         CLibContainer::CLibContainer(const SGUID& guid, const char* name, const SGUID& typeGUID)
 509                 : m_guid(guid)
 510                 , m_name(name)
 511                 , m_typeGUID(typeGUID)
 512         {}
 513
 514         //////////////////////////////////////////////////////////////////////////
 515         SGUID CLibContainer::GetGUID() const
 516         {
 517                 return m_guid;
 518         }
 519
 520         //////////////////////////////////////////////////////////////////////////
 521         const char* CLibContainer::GetName() const
 522         {
 523                 return m_name.c_str();
 524         }
 525
 526         //////////////////////////////////////////////////////////////////////////
 527         SGUID CLibContainer::GetTypeGUID() const
 528         {
 529                 return m_typeGUID;
 530         }
 531
 532         //////////////////////////////////////////////////////////////////////////
 533         CLibTimer::CLibTimer(const SGUID& guid, const char* szName, const STimerParams& params)
 534                 : m_guid(guid)
 535                 , m_name(szName)
 536                 , m_params(params)
 537         {}
 538
 539         //////////////////////////////////////////////////////////////////////////
 540         SGUID CLibTimer::GetGUID() const
 541         {
 542                 return m_guid;
 543         }
 544
 545         //////////////////////////////////////////////////////////////////////////
 546         const char* CLibTimer::GetName() const
 547         {
 548                 return m_name.c_str();
 549         }
 550
 551         //////////////////////////////////////////////////////////////////////////
 552         const STimerParams& CLibTimer::GetParams() const
 553         {
 554                 return m_params;
 555         }
 556
 557         //////////////////////////////////////////////////////////////////////////
 558         CLibAbstractInterfaceImplementation::CLibAbstractInterfaceImplementation(const SGUID& guid, const char* name, const SGUID& interfaceGUID)
 559                 : m_guid(guid)
 560                 , m_name(name)
 561                 , m_interfaceGUID(interfaceGUID)
 562         {}
 563
 564         //////////////////////////////////////////////////////////////////////////
 565         SGUID CLibAbstractInterfaceImplementation::GetGUID() const
 566         {
 567                 return m_guid;
 568         }
 569
 570         //////////////////////////////////////////////////////////////////////////
 571         const char* CLibAbstractInterfaceImplementation::GetName() const
 572         {
 573                 return m_name.c_str();
 574         }
 575
 576         //////////////////////////////////////////////////////////////////////////
 577         SGUID CLibAbstractInterfaceImplementation::GetInterfaceGUID() const
 578         {
 579                 return m_interfaceGUID;
 580         }
 581
 582         //////////////////////////////////////////////////////////////////////////
 583         size_t CLibAbstractInterfaceImplementation::GetFunctionCount() const
 584         {
 585                 return m_functions.size();
 586         }
 587
 588         //////////////////////////////////////////////////////////////////////////
 589         SGUID CLibAbstractInterfaceImplementation::GetFunctionGUID(size_t iFunction) const
 590         {
 591                 return iFunction < m_functions.size() ? m_functions[iFunction].guid : SGUID();
 592         }
 593
 594         //////////////////////////////////////////////////////////////////////////
 595         LibFunctionId CLibAbstractInterfaceImplementation::GetFunctionId(size_t iFunction) const
 596         {
 597                 return iFunction < m_functions.size() ? m_functions[iFunction].functionId : LibFunctionId();
 598         }
 599
 600         //////////////////////////////////////////////////////////////////////////
 601         void CLibAbstractInterfaceImplementation::AddFunction(const SGUID& guid, const LibFunctionId& functionId)
 602         {
 603                 m_functions.push_back(SFunction(guid, functionId));
 604         }
 605
 606         //////////////////////////////////////////////////////////////////////////
 607         CLibAbstractInterfaceImplementation::SFunction::SFunction(const SGUID& _guid, const LibFunctionId& _functionId)
 608                 : guid(_guid)
 609                 , functionId(_functionId)
 610         {}
 611
 612         //////////////////////////////////////////////////////////////////////////
 613         CLibComponentInstance::CLibComponentInstance(const SGUID& guid, const char* szName, const SGUID& componentGUID, const IPropertiesConstPtr& pProperties, uint32 propertyFunctionIdx, uint32 parentIdx)
 614                 : m_guid(guid)
 615                 , m_name(szName)
 616                 , m_componentGUID(componentGUID)
 617                 , m_pProperties(pProperties)
 618                 , m_propertyFunctionIdx(propertyFunctionIdx)
 619                 , m_parentIdx(parentIdx)
 620         {}
 621
 622         //////////////////////////////////////////////////////////////////////////
 623         SGUID CLibComponentInstance::GetGUID() const
 624         {
 625                 return m_guid;
 626         }
 627
 628         //////////////////////////////////////////////////////////////////////////
 629         const char* CLibComponentInstance::GetName() const
 630         {
 631                 return m_name.c_str();
 632         }
 633
 634         //////////////////////////////////////////////////////////////////////////
 635         SGUID CLibComponentInstance::GetComponentGUID() const
 636         {
 637                 return m_componentGUID;
 638         }
 639
 640         //////////////////////////////////////////////////////////////////////////
 641         IPropertiesConstPtr CLibComponentInstance::GetProperties() const
 642         {
 643                 return m_pProperties;
 644         }
 645
 646         //////////////////////////////////////////////////////////////////////////
 647         uint32 CLibComponentInstance::GetPropertyFunctionIdx() const
 648         {
 649                 return m_propertyFunctionIdx;
 650         }
 651
 652         //////////////////////////////////////////////////////////////////////////
 653         uint32 CLibComponentInstance::GetParentIdx() const
 654         {
 655                 return m_parentIdx;
 656         }
 657
 658         //////////////////////////////////////////////////////////////////////////
 659         CLibActionInstance::CLibActionInstance(const SGUID& guid, const char* name, const SGUID& actionGUID, size_t iComponentInstance, const IPropertiesPtr& pProperties)
 660                 : m_guid(guid)
 661                 , m_name(name)
 662                 , m_actionGUID(actionGUID)
 663                 , m_iComponentInstance(iComponentInstance)
 664                 , m_pProperties(pProperties)
 665         {}
 666
 667         //////////////////////////////////////////////////////////////////////////
 668         SGUID CLibActionInstance::GetGUID() const
 669         {
 670                 return m_guid;
 671         }
 672
 673         //////////////////////////////////////////////////////////////////////////
 674         const char* CLibActionInstance::GetName() const
 675         {
 676                 return m_name.c_str();
 677         }
 678
 679         //////////////////////////////////////////////////////////////////////////
 680         SGUID CLibActionInstance::GetActionGUID() const
 681         {
 682                 return m_actionGUID;
 683         }
 684
 685         //////////////////////////////////////////////////////////////////////////
 686         size_t CLibActionInstance::GetComponentInstance() const
 687         {
 688                 return m_iComponentInstance;
 689         }
 690
 691         //////////////////////////////////////////////////////////////////////////
 692         IPropertiesConstPtr CLibActionInstance::GetProperties() const
 693         {
 694                 return m_pProperties;
 695         }
 696
 697         //////////////////////////////////////////////////////////////////////////
 698         CLibConstructor::CLibConstructor(const SGUID& guid, const LibFunctionId& functionId)
 699                 : m_guid(guid)
 700                 , m_functionId(functionId)
 701         {}
 702
 703         //////////////////////////////////////////////////////////////////////////
 704         SGUID CLibConstructor::GetGUID() const
 705         {
 706                 return m_guid;
 707         }
 708
 709         //////////////////////////////////////////////////////////////////////////
 710         LibFunctionId CLibConstructor::GetFunctionId() const
 711         {
 712                 return m_functionId;
 713         }
 714
 715         //////////////////////////////////////////////////////////////////////////
 716         CLibDestructor::CLibDestructor(const SGUID& guid, const LibFunctionId& functionId)
 717                 : m_guid(guid)
 718                 , m_functionId(functionId)
 719         {}
 720
 721         //////////////////////////////////////////////////////////////////////////
 722         SGUID CLibDestructor::GetGUID() const
 723         {
 724                 return m_guid;
 725         }
 726
 727         //////////////////////////////////////////////////////////////////////////
 728         LibFunctionId CLibDestructor::GetFunctionId() const
 729         {
 730                 return m_functionId;
 731         }
 732
 733         //////////////////////////////////////////////////////////////////////////
 734         CLibSignalReceiver::CLibSignalReceiver(const SGUID& guid, const SGUID& contextGUID, const LibFunctionId& functionId)
 735                 : m_guid(guid)
 736                 , m_contextGUID(contextGUID)
 737                 , m_functionId(functionId)
 738         {}
 739
 740         //////////////////////////////////////////////////////////////////////////
 741         SGUID CLibSignalReceiver::GetGUID() const
 742         {
 743                 return m_guid;
 744         }
 745
 746         //////////////////////////////////////////////////////////////////////////
 747         SGUID CLibSignalReceiver::GetContextGUID() const
 748         {
 749                 return m_contextGUID;
 750         }
 751
 752         //////////////////////////////////////////////////////////////////////////
 753         LibFunctionId CLibSignalReceiver::GetFunctionId() const
 754         {
 755                 return m_functionId;
 756         }
 757
 758         //////////////////////////////////////////////////////////////////////////
 759         CLibTransition::CLibTransition(const SGUID& guid, const SGUID& contextGUID, const LibFunctionId& functionId)
 760                 : m_guid(guid)
 761                 , m_contextGUID(contextGUID)
 762                 , m_functionId(functionId)
 763         {}
 764
 765         //////////////////////////////////////////////////////////////////////////
 766         SGUID CLibTransition::GetGUID() const
 767         {
 768                 return m_guid;
 769         }
 770
 771         //////////////////////////////////////////////////////////////////////////
 772         SGUID CLibTransition::GetContextGUID() const
 773         {
 774                 return m_contextGUID;
 775         }
 776
 777         //////////////////////////////////////////////////////////////////////////
 778         LibFunctionId CLibTransition::GetFunctionId() const
 779         {
 780                 return m_functionId;
 781         }
 782
 783         //////////////////////////////////////////////////////////////////////////
 784         CLibFunction::CLibFunction()
 785                 : m_capacity(0)
 786                 , m_size(0)
 787                 , m_lastOpPos(INVALID_INDEX)
 788                 , m_pBegin(NULL)
 789                 , m_executionFilter(EGraphExecutionFilter::Always)
 790         {}
 791
 792         //////////////////////////////////////////////////////////////////////////
 793         CLibFunction::~CLibFunction()
 794         {
 795                 Release();
 796         }
 797
 798         //////////////////////////////////////////////////////////////////////////
 799         SGUID CLibFunction::GetGUID() const
 800         {
 801                 return m_guid;
 802         }
 803
 804         //////////////////////////////////////////////////////////////////////////
 805         SGUID CLibFunction::GetClassGUID() const
 806         {
 807                 return m_classGUID;
 808         }
 809
 810         //////////////////////////////////////////////////////////////////////////
 811         void CLibFunction::SetName(const char* name)
 812         {
 813                 m_name = name;
 814         }
 815
 816         //////////////////////////////////////////////////////////////////////////
 817         const char* CLibFunction::GetName() const
 818         {
 819                 return m_name.c_str();
 820         }
 821
 822         //////////////////////////////////////////////////////////////////////////
 823         void CLibFunction::SetScope(const char* scope)
 824         {
 825                 m_scope = scope;
 826         }
 827
 828         //////////////////////////////////////////////////////////////////////////
 829         const char* CLibFunction::GetScope() const
 830         {
 831                 return m_scope.c_str();
 832         }
 833
 834         //////////////////////////////////////////////////////////////////////////
 835         void CLibFunction::SetFileName(const char* fileName)
 836         {
 837                 m_fileName = fileName;
 838         }
 839
 840         //////////////////////////////////////////////////////////////////////////
 841         const char* CLibFunction::GetFileName() const
 842         {
 843                 return m_fileName.c_str();
 844         }
 845
 846         //////////////////////////////////////////////////////////////////////////
 847         void CLibFunction::SetAuthor(const char* author)
 848         {
 849                 m_author = author;
 850         }
 851
 852         //////////////////////////////////////////////////////////////////////////
 853         const char* CLibFunction::GetAuthor() const
 854         {
 855                 return m_author.c_str();
 856         }
 857
 858         //////////////////////////////////////////////////////////////////////////
 859         void CLibFunction::SetDescription(const char* szDescription)
 860         {
 861                 m_textDesc = szDescription;
 862         }
 863
 864         //////////////////////////////////////////////////////////////////////////
 865         const char* CLibFunction::GetDescription() const
 866         {
 867                 return m_textDesc.c_str();
 868         }
 869
 870         //////////////////////////////////////////////////////////////////////////
 871         void CLibFunction::AddInput(const char* name, const char* textDesc, const IAny& value)
 872         {
 873                 m_inputs.push_back(SParam(name, textDesc));
 874                 CVariantVectorOutputArchive     archive(m_variantInputs);
 875                 archive(const_cast<IAny&>(value), "", "");
 876         }
 877
 878         //////////////////////////////////////////////////////////////////////////
 879         size_t CLibFunction::GetInputCount() const
 880         {
 881                 return m_inputs.size();
 882         }
 883
 884         //////////////////////////////////////////////////////////////////////////
 885         const char* CLibFunction::GetInputName(size_t iInput) const
 886         {
 887                 return iInput < m_inputs.size() ? m_inputs[iInput].name.c_str() : "";
 888         }
 889
 890         //////////////////////////////////////////////////////////////////////////
 891         const char* CLibFunction::GetInputTextDesc(size_t iInput) const
 892         {
 893                 return iInput < m_inputs.size() ? m_inputs[iInput].textDesc.c_str() : "";
 894         }
 895
 896         //////////////////////////////////////////////////////////////////////////
 897         TVariantConstArray CLibFunction::GetVariantInputs() const
 898         {
 899                 return m_variantInputs;
 900         }
 901
 902         //////////////////////////////////////////////////////////////////////////
 903         void CLibFunction::AddOutput(const char* name, const char* textDesc, const IAny& value)
 904         {
 905                 m_outputs.push_back(SParam(name, textDesc));
 906                 CVariantVectorOutputArchive     archive(m_variantOutputs);
 907                 archive(const_cast<IAny&>(value), "", "");
 908         }
 909
 910         //////////////////////////////////////////////////////////////////////////
 911         size_t CLibFunction::GetOutputCount() const
 912         {
 913                 return m_outputs.size();
 914         }
 915
 916         //////////////////////////////////////////////////////////////////////////
 917         const char* CLibFunction::GetOutputName(size_t iOutput) const
 918         {
 919                 return iOutput < m_outputs.size() ? m_outputs[iOutput].name.c_str() : "";
 920         }
 921
 922         //////////////////////////////////////////////////////////////////////////
 923         const char* CLibFunction::GetOutputTextDesc(size_t iOutput) const
 924         {
 925                 return iOutput < m_outputs.size() ? m_outputs[iOutput].textDesc.c_str() : "";
 926         }
 927
 928         //////////////////////////////////////////////////////////////////////////
 929         TVariantConstArray CLibFunction::GetVariantOutputs() const
 930         {
 931                 return m_variantOutputs;
 932         }
 933
 934         //////////////////////////////////////////////////////////////////////////
 935         TVariantConstArray CLibFunction::GetVariantConsts() const
 936         {
 937                 return m_variantConsts;
 938         }
 939
 940         //////////////////////////////////////////////////////////////////////////
 941         GlobalFunctionConstTable CLibFunction::GetGlobalFunctionTable() const
 942         {
 943                 return m_globalFunctionTable;
 944         }
 945
 946         //////////////////////////////////////////////////////////////////////////
 947         ComponentMemberFunctionConstTable CLibFunction::GetComponentMemberFunctionTable() const
 948         {
 949                 return m_componentMemberFunctionTable;
 950         }
 951
 952         //////////////////////////////////////////////////////////////////////////
 953         ActionMemberFunctionConstTable CLibFunction::GetActionMemberFunctionTable() const
 954         {
 955                 return m_actionMemberFunctionTable;
 956         }
 957
 958         //////////////////////////////////////////////////////////////////////////
 959         size_t CLibFunction::GetSize() const
 960         {
 961                 return m_size;
 962         }
 963
 964         //////////////////////////////////////////////////////////////////////////
 965         const SVMOp* CLibFunction::GetOp(size_t pos) const
 966         {
 967                 CRY_ASSERT(pos < m_size);
 968                 return pos < m_size ? reinterpret_cast<const SVMOp*>(m_pBegin + pos) : NULL;
 969         }
 970
 971         //////////////////////////////////////////////////////////////////////////
 972         void CLibFunction::SetGUID(const SGUID& guid)
 973         {
 974                 m_guid = guid;
 975         }
 976
 977         //////////////////////////////////////////////////////////////////////////
 978         void CLibFunction::SetClassGUID(const SGUID& classGUID)
 979         {
 980                 m_classGUID = classGUID;
 981         }
 982
 983         //////////////////////////////////////////////////////////////////////////
 984         size_t CLibFunction::AddConstValue(const CVariant& value)
 985         {
 986                 TVariantVector::iterator        iBeginConst = m_variantConsts.begin();
 987                 TVariantVector::iterator        iEndConst = m_variantConsts.end();
 988                 TVariantVector::iterator        iConst = std::find(iBeginConst, iEndConst, value);
 989                 if(iConst != iEndConst)
 990                 {
 991                         return iConst - iBeginConst;
 992                 }
 993                 else
 994                 {
 995                         m_variantConsts.push_back(value);
 996                         return m_variantConsts.size() - 1;
 997                 }
 998         }
 999
1000         //////////////////////////////////////////////////////////////////////////
1001         size_t CLibFunction::AddGlobalFunction(const IGlobalFunctionConstPtr& pGlobalFunction)
1002         {
1003                 GlobalFunctionTable::iterator   iBeginGlobalFunction = m_globalFunctionTable.begin();
1004                 GlobalFunctionTable::iterator   iEndGlobalFunction = m_globalFunctionTable.end();
1005                 GlobalFunctionTable::iterator   iGlobalFunction = std::find(iBeginGlobalFunction, iEndGlobalFunction, pGlobalFunction);
1006                 if(iGlobalFunction != iEndGlobalFunction)
1007                 {
1008                         return iGlobalFunction - iBeginGlobalFunction;
1009                 }
1010                 else
1011                 {
1012                         m_globalFunctionTable.push_back(pGlobalFunction);
1013                         return m_globalFunctionTable.size() - 1;
1014                 }
1015         }
1016
1017         //////////////////////////////////////////////////////////////////////////
1018         size_t CLibFunction::AddComponentMemberFunction(const IComponentMemberFunctionConstPtr& pComponentMemberFunction)
1019         {
1020                 ComponentMemberFunctionTable::iterator  iBeginComponentMemberFunction = m_componentMemberFunctionTable.begin();
1021                 ComponentMemberFunctionTable::iterator  iEndComponentMemberFunction = m_componentMemberFunctionTable.end();
1022                 ComponentMemberFunctionTable::iterator  iComponentMemberFunction = std::find(iBeginComponentMemberFunction, iEndComponentMemberFunction, pComponentMemberFunction);
1023                 if(iComponentMemberFunction != iEndComponentMemberFunction)
1024                 {
1025                         return iComponentMemberFunction - iBeginComponentMemberFunction;
1026                 }
1027                 else
1028                 {
1029                         m_componentMemberFunctionTable.push_back(pComponentMemberFunction);
1030                         return m_componentMemberFunctionTable.size() - 1;
1031                 }
1032         }
1033
1034         //////////////////////////////////////////////////////////////////////////
1035         size_t CLibFunction::AddActionMemberFunction(const IActionMemberFunctionConstPtr& pActionMemberFunction)
1036         {
1037                 ActionMemberFunctionTable::iterator     iBeginActionMemberFunction = m_actionMemberFunctionTable.begin();
1038                 ActionMemberFunctionTable::iterator     iEndActionMemberFunction = m_actionMemberFunctionTable.end();
1039                 ActionMemberFunctionTable::iterator     iActionMemberFunction = std::find(iBeginActionMemberFunction, iEndActionMemberFunction, pActionMemberFunction);
1040                 if(iActionMemberFunction != iEndActionMemberFunction)
1041                 {
1042                         return iActionMemberFunction - iBeginActionMemberFunction;
1043                 }
1044                 else
1045                 {
1046                         m_actionMemberFunctionTable.push_back(pActionMemberFunction);
1047                         return m_actionMemberFunctionTable.size() - 1;
1048                 }
1049         }
1050
1051         //////////////////////////////////////////////////////////////////////////
1052         void CLibFunction::SetGraphExecutionFilter(EGraphExecutionFilter filter)
1053         {
1054                 m_executionFilter = filter;
1055         }
1056
1057         void CLibFunction::AddDebugOperationSymbolNode(size_t pos, const SGUID& guid)
1058         {
1059                 if (!guid.cryGUID.IsNull())
1060                 {
1061                         DebugSymbolTable::iterator result = m_debugSymbolTable.find(pos);
1062
1063                         if (result == m_debugSymbolTable.end())
1064                         {
1065                                 m_debugSymbolTable.emplace(pos, SDebugSymbol(guid, "", ILibFunction::SDebugSymbol::EDebugSymbolType::Node));
1066                         }
1067                         else
1068                         {
1069                                 if (result->second.type == ILibFunction::SDebugSymbol::EDebugSymbolType::Input)
1070                                 {
1071                                         result->second.type = ILibFunction::SDebugSymbol::EDebugSymbolType::NodeAndInput;
1072                                 }
1073                                 else
1074                                 {
1075                                         CRY_ASSERT(result == m_debugSymbolTable.end(), "[Schematyc Debugger] Trying to add a debug symbol (Node) already registred.");
1076                                 }
1077                         }
1078                 }
1079         }
1080
1081         void CLibFunction::AddDebugOperationSymbolInput(size_t pos, const SGUID& guid, const char* input)
1082         {
1083                 if (!guid.cryGUID.IsNull())
1084                 {
1085                         DebugSymbolTable::const_iterator result = m_debugSymbolTable.find(pos);
1086
1087                         if (result == m_debugSymbolTable.end())
1088                         {
1089                                 m_debugSymbolTable.emplace(pos, SDebugSymbol(guid, input, ILibFunction::SDebugSymbol::EDebugSymbolType::Input));
1090                         }
1091
1092                         CRY_ASSERT(result == m_debugSymbolTable.end(), "[Schematyc Debugger] Trying to add a debug symbol (Input) already registered.");
1093                 }
1094         }
1095
1096         const Schematyc2::ILibFunction::SDebugSymbol* CLibFunction::GetDebugOperationSymbol(size_t pos) const
1097         {
1098                 DebugSymbolTable::const_iterator result = m_debugSymbolTable.find(pos);
1099                 if (result != m_debugSymbolTable.end())
1100                 {
1101                         return &result->second;
1102                 }
1103
1104                 return nullptr;
1105         }
1106
1107         size_t CLibFunction::GetDebugOperationsSize() const
1108         {
1109                 return m_debugSymbolTable.size();
1110         }
1111
1112         void CLibFunction::ClearDebugOperationSymbols()
1113         {
1114                 m_debugSymbolTable.clear();
1115         }
1116
1117         //////////////////////////////////////////////////////////////////////////
1118         bool CLibFunction::IsGraphExecutionAllowed() const
1119         {
1120                 switch (m_executionFilter)
1121                 {
1122                 case EGraphExecutionFilter::Always:
1123                         return true;
1124
1125                 case EGraphExecutionFilter::DevModeOrLoggingEnabled:
1126                         return gEnv->pSystem->IsDevMode() || CVars::sc2_LogToFile != 0;
1127
1128                 case EGraphExecutionFilter::DevModeOnly:
1129                         return gEnv->pSystem->IsDevMode();
1130
1131                 default:
1132                         CRY_ASSERT(false, "Wrong execution filter value in schematyc function.");
1133                 }
1134                 return false;
1135         }
1136
1137         //////////////////////////////////////////////////////////////////////////
1138         size_t CLibFunction::AddOp(const SVMOp& op)
1139         {
1140                 if (op.size > (m_capacity - m_size))
1141                 {
1142                         const size_t capacity = /*std::*/max(m_capacity * GROWTH_FACTOR, /*std::*/max(op.size, MIN_CAPACITY));
1143                         if (uint8* pBegin = static_cast<uint8*>(realloc(m_pBegin, capacity)))
1144                         {
1145                                 m_capacity = capacity;
1146                                 m_pBegin = pBegin;
1147                         }
1148                         else
1149                         {
1150                                 SCHEMATYC2_COMPILER_FATAL_ERROR("Unable to add operation");
1151                         }
1152                 }
1153                 memcpy(m_pBegin + m_size, &op, op.size);
1154                 m_lastOpPos = m_size;
1155                 m_size += op.size;
1156                 return m_lastOpPos;
1157         }
1158
1159         //////////////////////////////////////////////////////////////////////////
1160         SVMOp* CLibFunction::GetOp(size_t pos)
1161         {
1162                 CRY_ASSERT(pos < m_size);
1163                 return pos < m_size ? reinterpret_cast<SVMOp*>(m_pBegin + pos) : NULL;
1164         }
1165
1166         //////////////////////////////////////////////////////////////////////////
1167         SVMOp* CLibFunction::GetLastOp()
1168         {
1169                 return m_lastOpPos != INVALID_INDEX ? GetOp(m_lastOpPos) : NULL;
1170         }
1171
1172         //////////////////////////////////////////////////////////////////////////
1173         void CLibFunction::Release()
1174         {
1175                 if(m_pBegin)
1176                 {
1177                         free(m_pBegin);
1178                 }
1179                 m_capacity      = 0;
1180                 m_size                  = 0;
1181                 m_lastOpPos     = INVALID_INDEX;
1182                 m_pBegin                = NULL;
1183
1184                 ClearDebugOperationSymbols();
1185         }
1186
1187         //////////////////////////////////////////////////////////////////////////
1188         void CLibFunction::CompactMemory()
1189         {
1190                 if (m_size < m_capacity)
1191                 {
1192                         if (uint8* pBegin = static_cast<uint8*>(realloc(m_pBegin, m_size)))
1193                         {
1194                                 m_pBegin = pBegin;
1195                                 m_capacity = m_size;
1196                         }
1197                 }
1198
1199                 m_inputs.shrink_to_fit();
1200                 m_variantInputs.shrink_to_fit();
1201                 m_outputs.shrink_to_fit();
1202                 m_variantOutputs.shrink_to_fit();
1203                 m_variantConsts.shrink_to_fit();
1204                 m_globalFunctionTable.shrink_to_fit();
1205                 m_componentMemberFunctionTable.shrink_to_fit();
1206                 m_actionMemberFunctionTable.shrink_to_fit();
1207         }
1208
1209         //////////////////////////////////////////////////////////////////////////
1210         CLibFunction::SParam::SParam(const char* _name, const char* _textDesc)
1211                 : name(_name)
1212                 , textDesc(_textDesc)
1213         {}
1214
1215         //////////////////////////////////////////////////////////////////////////
1216         CLibClassProperties::SProperty::SProperty()
1217                 : overridePolicy(EInternalOverridePolicy::UseDefault)
1218         {}
1219
1220         //////////////////////////////////////////////////////////////////////////
1221         CLibClassProperties::SProperty::SProperty(const char* _szLabel, const IAnyPtr& _pValue, EInternalOverridePolicy _overridePolicy)
1222                         : label(_szLabel)
1223                         , pValue(_pValue)
1224                         , overridePolicy(_overridePolicy)
1225         {}
1226
1227         //////////////////////////////////////////////////////////////////////////
1228         CLibClassProperties::SProperty::SProperty(const SProperty& rhs)
1229                 : label(rhs.label)
1230                 , pValue(rhs.pValue->Clone())
1231                 , overridePolicy(rhs.overridePolicy)
1232         {}
1233
1234         //////////////////////////////////////////////////////////////////////////
1235         void CLibClassProperties::SProperty::Serialize(Serialization::IArchive& archive)
1236         {
1237                 const bool isPrecaching = archive.caps(Schematyc2::IResourceCollectorArchive::ArchiveCaps);
1238                 if(archive.isEdit() || isPrecaching)
1239                 {
1240                         archive(overridePolicy, "overridePolicy", "Override");
1241                         if(overridePolicy == EInternalOverridePolicy::OverrideDefault)
1242                         {
1243                                 archive(*pValue, "value", "Value");
1244                         }
1245                 }
1246                 else
1247                 {
1248                         archive(*pValue, "value");
1249                         archive(overridePolicy, "overridePolicy");
1250                 }
1251         }
1252
1253         //////////////////////////////////////////////////////////////////////////
1254         CLibClassProperties::CLibClassProperties(const LibVariables& variables)
1255         {
1256                 for(const CLibVariable& variable : variables)
1257                 {
1258                         if(variable.GetOverridePolicy() != EOverridePolicy::Finalize)
1259                         {
1260                                 if((variable.GetFlags() & ELibVariableFlags::ClassProperty) != 0)
1261                                 {
1262                                         IAnyConstPtr pVariableValue = variable.GetValue();
1263                                         if(pVariableValue)
1264                                         {
1265                                                 m_properties.insert(Properties::value_type(variable.GetGUID(), SProperty(variable.GetName(), pVariableValue->Clone(), EInternalOverridePolicy::UseDefault)));
1266                                         }
1267                                 }
1268                         }
1269                 }
1270         }
1271
1272         //////////////////////////////////////////////////////////////////////////
1273         CLibClassProperties::CLibClassProperties(const CLibClassProperties& rhs)
1274                 : m_properties(rhs.m_properties)
1275         {}
1276
1277         //////////////////////////////////////////////////////////////////////////
1278         ILibClassPropertiesPtr CLibClassProperties::Clone() const
1279         {
1280                 return std::make_shared<CLibClassProperties>(*this);
1281         }
1282
1283         //////////////////////////////////////////////////////////////////////////
1284         void CLibClassProperties::Serialize(Serialization::IArchive& archive)
1285         {
1286                 if(archive.isEdit())
1287                 {
1288                         PropertiesByLabel propertiesByLabel;
1289                         for(Properties::value_type& property : m_properties)
1290                         {
1291                                 propertiesByLabel.insert(PropertiesByLabel::value_type(property.second.label.c_str(), property.second));
1292                         }
1293                         for(PropertiesByLabel::value_type& property : propertiesByLabel)
1294                         {
1295                                 archive(property.second, property.first, property.first);
1296                         }
1297                 }
1298                 else if(archive.isInput() && !archive.caps(Serialization::IArchive::BINARY)) // Check for binary archive because binary archives do not currently support black box serialization.
1299                 {
1300                         typedef std::map<SGUID, Serialization::SBlackBox> BlackBoxProperties;
1301
1302                         BlackBoxProperties blackBoxProperties;
1303                         archive(blackBoxProperties, "properties");
1304                         for(BlackBoxProperties::value_type& blackBoxProperty : blackBoxProperties)
1305                         {
1306                                 Properties::iterator itProperty = m_properties.find(blackBoxProperty.first);
1307                                 if(itProperty != m_properties.end())
1308                                 {
1309                                         Serialization::LoadBlackBox(itProperty->second, blackBoxProperty.second);
1310                                 }
1311                         }
1312                 }
1313                 else
1314                 {
1315                          archive(m_properties, "properties");
1316                 }
1317         }
1318
1319         //////////////////////////////////////////////////////////////////////////
1320         IAnyConstPtr CLibClassProperties::GetProperty(const SGUID& guid) const
1321         {
1322                 Properties::const_iterator itProperty = m_properties.find(guid);
1323                 if((itProperty != m_properties.end()))
1324                 {
1325                         if(itProperty->second.overridePolicy == EInternalOverridePolicy::OverrideDefault)
1326                         {
1327                                 return itProperty->second.pValue;
1328                         }
1329                 }
1330                 return IAnyConstPtr();
1331         }
1332
1333         //////////////////////////////////////////////////////////////////////////
1334         void CLibClassProperties::VisitProperties(const LibClassPropertyVisitor& visitor) const
1335         {
1336                 SCHEMATYC2_SYSTEM_ASSERT(visitor);
1337                 if(visitor)
1338                 {
1339                         for(const Properties::value_type& property : m_properties)
1340                         {
1341                                 visitor(property.first, property.second.label.c_str(), property.second.pValue);
1342                         }
1343                 }
1344         }
1345
1346         //////////////////////////////////////////////////////////////////////////
1347         void CLibClassProperties::OverrideProperty(const SGUID& guid, const IAny& value)
1348         {
1349                 Properties::iterator itProperty = m_properties.find(guid);
1350                 if((itProperty != m_properties.end()))
1351                 {
1352                         SProperty& property = itProperty->second;
1353                         if(property.pValue)
1354                         {
1355                                 *property.pValue        = value;
1356                                 property.overridePolicy = EInternalOverridePolicy::OverrideDefault;
1357                         }
1358                 }
1359         }
1360
1361         //////////////////////////////////////////////////////////////////////////
1362         CLibClass::CLibClass(const ILib& lib, const SGUID& guid, const char* szName, const SGUID& foundationGUID, const IPropertiesConstPtr& pFoundationProperties)
1363                 : m_lib(lib)
1364                 , m_guid(guid)
1365                 , m_name(szName)
1366                 , m_foundationGUID(foundationGUID)
1367                 , m_pFoundationProperties(pFoundationProperties ? pFoundationProperties->Clone() : IPropertiesPtr())
1368                 , m_nextFunctionId(1)
1369         {}
1370
1371         //////////////////////////////////////////////////////////////////////////
1372         const ILib& CLibClass::GetLib() const
1373         {
1374                 return m_lib;
1375         }
1376
1377         //////////////////////////////////////////////////////////////////////////
1378         SGUID CLibClass::GetGUID() const
1379         {
1380                 return m_guid;
1381         }
1382
1383         //////////////////////////////////////////////////////////////////////////
1384         const char* CLibClass::GetName() const
1385         {
1386                 return m_name.c_str();
1387         }
1388
1389         //////////////////////////////////////////////////////////////////////////
1390         SGUID CLibClass::GetFoundationGUID() const
1391         {
1392                 return m_foundationGUID;
1393         }
1394
1395         //////////////////////////////////////////////////////////////////////////
1396         IPropertiesConstPtr CLibClass::GetFoundationProperties() const
1397         {
1398                 return m_pFoundationProperties;
1399         }
1400
1401         //////////////////////////////////////////////////////////////////////////
1402         ILibClassPropertiesPtr CLibClass::CreateProperties() const
1403         {
1404                 return std::make_shared<CLibClassProperties>(m_variables);
1405         }
1406
1407         //////////////////////////////////////////////////////////////////////////
1408         size_t CLibClass::GetStateMachineCount() const
1409         {
1410                 return m_stateMachines.size();
1411         }
1412
1413         //////////////////////////////////////////////////////////////////////////
1414         const ILibStateMachine* CLibClass::GetStateMachine(size_t iStateMachine) const
1415         {
1416                 return iStateMachine < m_stateMachines.size() ? &m_stateMachines[iStateMachine] : NULL;
1417         }
1418
1419         //////////////////////////////////////////////////////////////////////////
1420         size_t CLibClass::GetStateCount() const
1421         {
1422                 return m_states.size();
1423         }
1424
1425         //////////////////////////////////////////////////////////////////////////
1426         const ILibState* CLibClass::GetState(size_t iState) const
1427         {
1428                 return iState < m_states.size() ? &m_states[iState] : NULL;
1429         }
1430
1431         //////////////////////////////////////////////////////////////////////////
1432         size_t CLibClass::GetVariableCount() const
1433         {
1434                 return m_variables.size();
1435         }
1436
1437         //////////////////////////////////////////////////////////////////////////
1438         const ILibVariable* CLibClass::GetVariable(size_t iVariable) const
1439         {
1440                 return iVariable < m_variables.size() ? &m_variables[iVariable] : NULL;
1441         }
1442
1443         //////////////////////////////////////////////////////////////////////////
1444         TVariantConstArray CLibClass::GetVariants() const
1445         {
1446                 return m_variants;
1447         }
1448
1449         //////////////////////////////////////////////////////////////////////////
1450         size_t CLibClass::GetContainerCount() const
1451         {
1452                 return m_containers.size();
1453         }
1454
1455         //////////////////////////////////////////////////////////////////////////
1456         const ILibContainer* CLibClass::GetContainer(size_t iContainer) const
1457         {
1458                 return iContainer < m_containers.size() ? &m_containers[iContainer] : NULL;
1459         }
1460
1461         //////////////////////////////////////////////////////////////////////////
1462         size_t CLibClass::GetTimerCount() const
1463         {
1464                 return m_timers.size();
1465         }
1466
1467         //////////////////////////////////////////////////////////////////////////
1468         const ILibTimer* CLibClass::GetTimer(size_t iTimer) const
1469         {
1470                 return iTimer < m_timers.size() ? &m_timers[iTimer] : NULL;
1471         }
1472
1473         //////////////////////////////////////////////////////////////////////////
1474         size_t CLibClass::GetPersistentTimerCount() const
1475         {
1476                 return m_persistentTimers.size();
1477         }
1478
1479         //////////////////////////////////////////////////////////////////////////
1480         size_t CLibClass::GetPersistentTimer(size_t iPersistentTimer) const
1481         {
1482                 return iPersistentTimer < m_persistentTimers.size() ? m_persistentTimers[iPersistentTimer] : INVALID_INDEX;
1483         }
1484
1485         //////////////////////////////////////////////////////////////////////////
1486         size_t CLibClass::GetAbstractInterfaceImplementationCount() const
1487         {
1488                 return m_abstractInterfaceImplementations.size();
1489         }
1490
1491         //////////////////////////////////////////////////////////////////////////
1492         const ILibAbstractInterfaceImplementation* CLibClass::GetAbstractInterfaceImplementation(size_t iAbstractInterfaceImplementation) const
1493         {
1494                 return iAbstractInterfaceImplementation < m_abstractInterfaceImplementations.size() ? &m_abstractInterfaceImplementations[iAbstractInterfaceImplementation] : NULL;
1495         }
1496
1497         //////////////////////////////////////////////////////////////////////////
1498         size_t CLibClass::GetComponentInstanceCount() const
1499         {
1500                 return m_componentInstances.size();
1501         }
1502
1503         //////////////////////////////////////////////////////////////////////////
1504         const ILibComponentInstance* CLibClass::GetComponentInstance(size_t iComponentInstance) const
1505         {
1506                 return iComponentInstance < m_componentInstances.size() ? &m_componentInstances[iComponentInstance] : NULL;
1507         }
1508
1509         //////////////////////////////////////////////////////////////////////////
1510         size_t CLibClass::GetActionInstanceCount() const
1511         {
1512                 return m_actionInstances.size();
1513         }
1514
1515         //////////////////////////////////////////////////////////////////////////
1516         const ILibActionInstance* CLibClass::GetActionInstance(size_t iActionInstance) const
1517         {
1518                 return iActionInstance < m_actionInstances.size() ? &m_actionInstances[iActionInstance] : NULL;
1519         }
1520
1521         //////////////////////////////////////////////////////////////////////////
1522         size_t CLibClass::GetPersistentActionInstanceCount() const
1523         {
1524                 return m_persistentActionInstances.size();
1525         }
1526
1527         //////////////////////////////////////////////////////////////////////////
1528         size_t CLibClass::GetPersistentActionInstance(size_t iPersistentActionInstance) const
1529         {
1530                 return iPersistentActionInstance < m_persistentActionInstances.size() ? m_persistentActionInstances[iPersistentActionInstance] : INVALID_INDEX;
1531         }
1532
1533         //////////////////////////////////////////////////////////////////////////
1534         size_t CLibClass::GetConstructorCount() const
1535         {
1536                 return m_constructors.size();
1537         }
1538
1539         //////////////////////////////////////////////////////////////////////////
1540         const ILibConstructor* CLibClass::GetConstructor(size_t iConstructor) const
1541         {
1542                 return iConstructor < m_constructors.size() ? &m_constructors[iConstructor] : NULL;
1543         }
1544
1545         //////////////////////////////////////////////////////////////////////////
1546         size_t CLibClass::GetPersistentConstructorCount() const
1547         {
1548                 return m_persistentConstructors.size();
1549         }
1550
1551         //////////////////////////////////////////////////////////////////////////
1552         size_t CLibClass::GetPersistentConstructor(size_t iPersistentConstructor) const
1553         {
1554                 return iPersistentConstructor < m_persistentConstructors.size() ? m_persistentConstructors[iPersistentConstructor] : INVALID_INDEX;
1555         }
1556
1557         //////////////////////////////////////////////////////////////////////////
1558         size_t CLibClass::GetDestructorCount() const
1559         {
1560                 return m_destructors.size();
1561         }
1562
1563         //////////////////////////////////////////////////////////////////////////
1564         const ILibDestructor* CLibClass::GetDestructor(size_t iDestructor) const
1565         {
1566                 return iDestructor < m_destructors.size() ? &m_destructors[iDestructor] : NULL;
1567         }
1568
1569         //////////////////////////////////////////////////////////////////////////
1570         size_t CLibClass::GetPersistentDestructorCount() const
1571         {
1572                 return m_persistentDestructors.size();
1573         }
1574
1575         //////////////////////////////////////////////////////////////////////////
1576         size_t CLibClass::GetPersistentDestructor(size_t iPersistentDestructor) const
1577         {
1578                 return iPersistentDestructor < m_persistentDestructors.size() ? m_persistentDestructors[iPersistentDestructor] : INVALID_INDEX;
1579         }
1580
1581         //////////////////////////////////////////////////////////////////////////
1582         size_t CLibClass::GetSignalReceiverCount() const
1583         {
1584                 return m_signalReceivers.size();
1585         }
1586
1587         //////////////////////////////////////////////////////////////////////////
1588         const ILibSignalReceiver* CLibClass::GetSignalReceiver(size_t iSignalReceiver) const
1589         {
1590                 return iSignalReceiver < m_signalReceivers.size() ? &m_signalReceivers[iSignalReceiver] : NULL;
1591         }
1592
1593         //////////////////////////////////////////////////////////////////////////
1594         size_t CLibClass::GetPersistentSignalReceiverCount() const
1595         {
1596                 return m_persistentSignalReceivers.size();
1597         }
1598
1599         //////////////////////////////////////////////////////////////////////////
1600         size_t CLibClass::GetPersistentSignalReceiver(size_t iPersistentSignalReceiver) const
1601         {
1602                 return iPersistentSignalReceiver < m_persistentSignalReceivers.size() ? m_persistentSignalReceivers[iPersistentSignalReceiver] : INVALID_INDEX;
1603         }
1604
1605         //////////////////////////////////////////////////////////////////////////
1606         size_t CLibClass::GetTransitionCount() const
1607         {
1608                 return m_transitions.size();
1609         }
1610
1611         //////////////////////////////////////////////////////////////////////////
1612         const ILibTransition* CLibClass::GetTransition(size_t iTransition) const
1613         {
1614                 return iTransition < m_transitions.size() ? &m_transitions[iTransition] : NULL;
1615         }
1616
1617         //////////////////////////////////////////////////////////////////////////
1618         LibFunctionId CLibClass::GetFunctionId(const SGUID& guid) const
1619         {
1620                 TFunctionIdByGUIDMap::const_iterator    iFunctionId = m_functionIdsByGUID.find(guid);
1621                 return iFunctionId != m_functionIdsByGUID.end() ? iFunctionId->second : LibFunctionId::s_invalid;
1622         }
1623
1624         //////////////////////////////////////////////////////////////////////////
1625         const ILibFunction* CLibClass::GetFunction(const LibFunctionId& functionId) const
1626         {
1627                 TFunctionMap::const_iterator    iFunction = m_functions.find(functionId);
1628                 return iFunction != m_functions.end() ? &iFunction->second.function : NULL;
1629         }
1630
1631         const SGUID CLibClass::GetFunctionGUID(const LibFunctionId& functionId) const
1632         {
1633                 TFunctionMap::const_iterator    iFunction = m_functions.find(functionId);
1634                 return iFunction != m_functions.end() ? iFunction->second.function.GetGUID() : SGUID();
1635         }
1636
1637         //////////////////////////////////////////////////////////////////////////
1638         const CRuntimeFunction* CLibClass::GetFunction_New(uint32 functionIdx) const
1639         {
1640                 return functionIdx < m_functions_New.size() ? m_functions_New[functionIdx].get() : nullptr;
1641         }
1642
1643         //////////////////////////////////////////////////////////////////////////
1644         void CLibClass::PreviewGraphFunctions(const SGUID& graphGUID, const StringStreamOutCallback& stringStreamOutCallback) const
1645         {
1646                 for(TFunctionMap::const_iterator iFunction = m_functions.begin(), iEndFunction = m_functions.end(); iFunction != iEndFunction; ++ iFunction)
1647                 {
1648                         const SFunction&        function = iFunction->second;
1649                         if(function.function.GetGUID() == graphGUID)
1650                         {
1651                                 PreviewFunction(function.function, stringStreamOutCallback);
1652                         }
1653                 }
1654         }
1655
1656         //////////////////////////////////////////////////////////////////////////
1657         size_t CLibClass::AddStateMachine(const SGUID& guid, const char* name, EStateMachineLifetime lifetime, EStateMachineNetAuthority netType)
1658         {
1659                 m_stateMachines.push_back(CLibStateMachine(guid, name, lifetime, netType));
1660                 return m_stateMachines.size() - 1;
1661         }
1662
1663         //////////////////////////////////////////////////////////////////////////
1664         CLibStateMachine* CLibClass::GetStateMachine(size_t iStateMachine)
1665         {
1666                 return iStateMachine < m_stateMachines.size() ? &m_stateMachines[iStateMachine] : nullptr;
1667         }
1668
1669         //////////////////////////////////////////////////////////////////////////
1670         size_t CLibClass::AddState(const SGUID& guid, const char* name)
1671         {
1672                 m_states.push_back(CLibState(guid, name));
1673                 return m_states.size() - 1;
1674         }
1675
1676         //////////////////////////////////////////////////////////////////////////
1677         CLibState* CLibClass::GetState(size_t iState)
1678         {
1679                 return iState < m_states.size() ? &m_states[iState] : nullptr;
1680         }
1681
1682         //////////////////////////////////////////////////////////////////////////
1683         size_t CLibClass::AddVariable(const SGUID& guid, const char* szName, EOverridePolicy overridePolicy, const IAny& value, size_t variantPos, size_t variantCount, ELibVariableFlags flags)
1684         {
1685                 m_variables.push_back(CLibVariable(guid, szName, overridePolicy, value, variantPos, variantCount, flags));
1686                 return m_variables.size() - 1;
1687         }
1688
1689         //////////////////////////////////////////////////////////////////////////
1690         CLibVariable* CLibClass::GetVariable(size_t iVariable)
1691         {
1692                 return iVariable < m_variables.size() ? &m_variables[iVariable] : nullptr;
1693         }
1694
1695         //////////////////////////////////////////////////////////////////////////
1696         size_t CLibClass::AddContainer(const SGUID& guid, const char* szName, const SGUID& typeGUID)
1697         {
1698                 m_containers.push_back(CLibContainer(guid, szName, typeGUID));
1699                 return m_containers.size() - 1;
1700         }
1701
1702         //////////////////////////////////////////////////////////////////////////
1703         CLibContainer* CLibClass::GetContainer(size_t iContainer)
1704         {
1705                 return iContainer < m_containers.size() ? &m_containers[iContainer] : nullptr;
1706         }
1707
1708         //////////////////////////////////////////////////////////////////////////
1709         TVariantVector& CLibClass::GetVariants()
1710         {
1711                 return m_variants;
1712         }
1713
1714         //////////////////////////////////////////////////////////////////////////
1715         size_t CLibClass::AddTimer(const SGUID& guid, const char* szName, const STimerParams& params)
1716         {
1717                 m_timers.push_back(CLibTimer(guid, szName, params));
1718                 return m_timers.size() - 1;
1719         }
1720
1721         //////////////////////////////////////////////////////////////////////////
1722         size_t CLibClass::AddPersistentTimer(const SGUID& guid, const char* szName, const STimerParams& params)
1723         {
1724                 m_persistentTimers.push_back(m_timers.size());
1725                 return AddTimer(guid, szName, params);
1726         }
1727
1728         //////////////////////////////////////////////////////////////////////////
1729         CLibTimer* CLibClass::GetTimer(size_t iTimer)
1730         {
1731                 return iTimer < m_timers.size() ? &m_timers[iTimer] : nullptr;
1732         }
1733
1734         //////////////////////////////////////////////////////////////////////////
1735         size_t CLibClass::AddAbstractInterfaceImplementation(const SGUID& guid, const char* szName, const SGUID& interfaceGUID)
1736         {
1737                 m_abstractInterfaceImplementations.push_back(CLibAbstractInterfaceImplementation(guid, szName, interfaceGUID));
1738                 return m_abstractInterfaceImplementations.size() - 1;
1739         }
1740
1741         //////////////////////////////////////////////////////////////////////////
1742         CLibAbstractInterfaceImplementation* CLibClass::GetAbstractInterfaceImplementation(size_t iAbstractInterfaceImplementation)
1743         {
1744                 return iAbstractInterfaceImplementation < m_abstractInterfaceImplementations.size() ? &m_abstractInterfaceImplementations[iAbstractInterfaceImplementation] : NULL;
1745         }
1746
1747         //////////////////////////////////////////////////////////////////////////
1748         size_t CLibClass::AddComponentInstance(const SGUID& guid, const char* szName, const SGUID& componentGUID, const IPropertiesPtr& pProperties, uint32 propertyFunctionIdx, uint32 parentIdx)
1749         {
1750                 m_componentInstances.push_back(CLibComponentInstance(guid, szName, componentGUID, pProperties, propertyFunctionIdx, parentIdx));
1751                 return m_componentInstances.size() - 1;
1752         }
1753
1754         //////////////////////////////////////////////////////////////////////////
1755         CLibComponentInstance* CLibClass::GetComponentInstance(size_t iComponentInstance)
1756         {
1757                 return iComponentInstance < m_componentInstances.size() ? &m_componentInstances[iComponentInstance] : NULL;
1758         }
1759
1760         //////////////////////////////////////////////////////////////////////////
1761         void CLibClass::SortComponentInstances()
1762         {
1763                 IEnvRegistry&                                                                           envRegistry = gEnv->pSchematyc2->GetEnvRegistry();
1764                 const size_t                                                                            componentInstanceCount = m_componentInstances.size();
1765                 TComponentInstanceSortRefVector componentInstanceSortRefs;
1766                 componentInstanceSortRefs.reserve(componentInstanceCount);
1767                 for(size_t iComponentInstance = 0; iComponentInstance < componentInstanceCount; ++ iComponentInstance)
1768                 {
1769                         const CLibComponentInstance&    componentInstance = m_componentInstances[iComponentInstance];
1770                         IComponentFactoryConstPtr                       pComponentFactory = envRegistry.GetComponentFactory(componentInstance.GetComponentGUID());
1771                         CRY_ASSERT(pComponentFactory);
1772                         if(pComponentFactory)
1773                         {
1774                                 componentInstanceSortRefs.push_back(SComponentInstanceSortRef(iComponentInstance));
1775
1776                                 SComponentInstanceSortRef&      componentInstanceSortRef = componentInstanceSortRefs.back();
1777                                 const size_t                                                            componentDependencyCount = pComponentFactory->GetDependencyCount();
1778                                 componentInstanceSortRef.dependencies.reserve(componentDependencyCount);
1779                                 for(size_t iComponentDependency = 0; iComponentDependency < componentDependencyCount; ++ iComponentDependency)
1780                                 {
1781                                         const SGUID     componentDependencyGUID = pComponentFactory->GetDependencyGUID(iComponentDependency);
1782                                         for(size_t iOtherComponentInstance = 0; iOtherComponentInstance < componentInstanceCount; ++ iOtherComponentInstance)
1783                                         {
1784                                                 if(m_componentInstances[iOtherComponentInstance].GetComponentGUID() == componentDependencyGUID)
1785                                                 {
1786                                                         componentInstanceSortRef.dependencies.push_back(iOtherComponentInstance);
1787                                                         break;
1788                                                 }
1789                                         }
1790                                 }
1791                         }
1792                 }
1793
1794                 bool    resolveDependencies;
1795                 do
1796                 {
1797                         resolveDependencies = false;
1798                         for(size_t iComponentInstance = 0; iComponentInstance < componentInstanceCount; ++ iComponentInstance)
1799                         {
1800                                 SComponentInstanceSortRef&      componentInstanceSortRef = componentInstanceSortRefs[iComponentInstance];
1801                                 for(TSizeTVector::const_iterator iComponentDependency = componentInstanceSortRef.dependencies.begin(), iEndComponentDependency = componentInstanceSortRef.dependencies.end(); iComponentDependency != iEndComponentDependency; ++ iComponentDependency)
1802                                 {
1803                                         SComponentInstanceSortRef&      otherComponentInstanceSortRef = componentInstanceSortRefs[*iComponentDependency];
1804                                         if(otherComponentInstanceSortRef.priority <= componentInstanceSortRef.priority)
1805                                         {
1806                                                 otherComponentInstanceSortRef.priority = componentInstanceSortRef.priority + 1;
1807                                                 resolveDependencies = true;
1808                                         }
1809                                 }
1810                         }
1811                 } while(resolveDependencies);
1812                 std::sort(componentInstanceSortRefs.begin(), componentInstanceSortRefs.end(), SComponentInstanceSortPredicate());
1813
1814                 TComponentInstanceVector        componentInstances;
1815                 componentInstances.reserve(componentInstanceCount);
1816                 for(size_t iComponentInstance = 0; iComponentInstance < componentInstanceCount; ++ iComponentInstance)
1817                 {
1818                         componentInstances.push_back(m_componentInstances[componentInstanceSortRefs[iComponentInstance].iComponentInstance]);
1819                 }
1820                 std::swap(componentInstances, m_componentInstances);
1821         }
1822
1823         //////////////////////////////////////////////////////////////////////////
1824         void CLibClass::ValidateSingletonComponentInstances() const
1825         {
1826                 IEnvRegistry& envRegistry = gEnv->pSchematyc2->GetEnvRegistry();
1827
1828                 const size_t componentInstanceCount = m_componentInstances.size();
1829
1830                 VectorMap<SGUID, SGUID> singletons;
1831                 singletons.reserve(componentInstanceCount);
1832
1833                 for (size_t iComponentInstance = 0; iComponentInstance < componentInstanceCount; ++iComponentInstance)
1834                 {
1835                         const CLibComponentInstance& componentInstance = m_componentInstances[iComponentInstance];
1836                         const SGUID componentGuid = componentInstance.GetComponentGUID();
1837                         IComponentFactoryConstPtr pComponentFactory = envRegistry.GetComponentFactory(componentGuid);
1838                         if ((pComponentFactory->GetFlags() & EComponentFlags::Singleton) != 0)
1839                         {
1840                                 const SGUID instanceGuid = componentInstance.GetGUID();
1841                                 auto iter = singletons.find(componentGuid);
1842                                 if (singletons.find(componentGuid) == singletons.end())
1843                                 {
1844                                         singletons[componentGuid] = instanceGuid;
1845                                 }
1846                                 else
1847                                 {
1848                                         stack_string guid1, guid2, guid3;
1849                                         SCHEMATYC2_COMPILER_ERROR("Singleton component %s '%s' instance %s is repeated several time. First instance %s",
1850                                                 StringUtils::SysGUIDToString(componentGuid.sysGUID, guid1),
1851                                                 componentInstance.GetName(),
1852                                                 StringUtils::SysGUIDToString(instanceGuid.sysGUID, guid2),
1853                                                 StringUtils::SysGUIDToString(iter->second.sysGUID, guid3));
1854                                 }
1855                         }
1856                 }
1857         }
1858
1859         //////////////////////////////////////////////////////////////////////////
1860         size_t CLibClass::AddActionInstance(const SGUID& guid, const char* name, const SGUID& actionGUID, size_t iComponentInstance, const IPropertiesPtr& pProperties)
1861         {
1862                 m_actionInstances.push_back(CLibActionInstance(guid, name, actionGUID, iComponentInstance, pProperties));
1863                 return m_actionInstances.size() - 1;
1864         }
1865
1866         //////////////////////////////////////////////////////////////////////////
1867         size_t CLibClass::AddPersistentActionInstance(const SGUID& guid, const char* name, const SGUID& actionGUID, size_t iComponentInstance, const IPropertiesPtr& pProperties)
1868         {
1869                 m_persistentActionInstances.push_back(m_actionInstances.size());
1870                 return AddActionInstance(guid, name, actionGUID, iComponentInstance, pProperties);
1871         }
1872
1873         //////////////////////////////////////////////////////////////////////////
1874         CLibActionInstance* CLibClass::GetActionInstance(size_t iActionInstance)
1875         {
1876                 return iActionInstance < m_actionInstances.size() ? &m_actionInstances[iActionInstance] : NULL;
1877         }
1878
1879         //////////////////////////////////////////////////////////////////////////
1880         size_t CLibClass::AddConstructor(const SGUID& guid, const LibFunctionId& functionId)
1881         {
1882                 m_constructors.push_back(CLibConstructor(guid, functionId));
1883                 return m_constructors.size() - 1;
1884         }
1885
1886         //////////////////////////////////////////////////////////////////////////
1887         size_t CLibClass::AddPersistentConstructor(const SGUID& guid, const LibFunctionId& functionId)
1888         {
1889                 m_persistentConstructors.push_back(m_constructors.size());
1890                 return AddConstructor(guid, functionId);
1891         }
1892
1893         //////////////////////////////////////////////////////////////////////////
1894         CLibConstructor* CLibClass::GetConstructor(size_t iConstructor)
1895         {
1896                 return iConstructor < m_constructors.size() ? &m_constructors[iConstructor] : NULL;
1897         }
1898
1899         //////////////////////////////////////////////////////////////////////////
1900         size_t CLibClass::AddDestructor(const SGUID& guid, const LibFunctionId& functionId)
1901         {
1902                 m_destructors.push_back(CLibDestructor(guid, functionId));
1903                 return m_destructors.size() - 1;
1904         }
1905
1906         //////////////////////////////////////////////////////////////////////////
1907         size_t CLibClass::AddPersistentDestructor(const SGUID& guid, const LibFunctionId& functionId)
1908         {
1909                 m_persistentDestructors.push_back(m_destructors.size());
1910                 return AddDestructor(guid, functionId);
1911         }
1912
1913         //////////////////////////////////////////////////////////////////////////
1914         CLibDestructor* CLibClass::GetDestructor(size_t iDestructor)
1915         {
1916                 return iDestructor < m_destructors.size() ? &m_destructors[iDestructor] : NULL;
1917         }
1918
1919         //////////////////////////////////////////////////////////////////////////
1920         size_t CLibClass::AddSignalReceiver(const SGUID& guid, const SGUID& contextGUID, const LibFunctionId& functionId)
1921         {
1922                 m_signalReceivers.push_back(CLibSignalReceiver(guid, contextGUID, functionId));
1923                 return m_signalReceivers.size() - 1;
1924         }
1925
1926         //////////////////////////////////////////////////////////////////////////
1927         size_t CLibClass::AddPersistentSignalReceiver(const SGUID& guid, const SGUID& contextGUID, const LibFunctionId& functionId)
1928         {
1929                 m_persistentSignalReceivers.push_back(m_signalReceivers.size());
1930                 return AddSignalReceiver(guid, contextGUID, functionId);
1931         }
1932
1933         //////////////////////////////////////////////////////////////////////////
1934         CLibSignalReceiver* CLibClass::GetSignalReceiver(size_t iSignalReceiver)
1935         {
1936                 return iSignalReceiver < m_signalReceivers.size() ? &m_signalReceivers[iSignalReceiver] : NULL;
1937         }
1938
1939         //////////////////////////////////////////////////////////////////////////
1940         size_t CLibClass::AddTransition(const SGUID& guid, const SGUID& contextGUID, const LibFunctionId& functionId)
1941         {
1942                 m_transitions.push_back(CLibTransition(guid, contextGUID, functionId));
1943                 return m_transitions.size() - 1;
1944         }
1945
1946         //////////////////////////////////////////////////////////////////////////
1947         CLibTransition* CLibClass::GetTransition(size_t iTransition)
1948         {
1949                 return iTransition < m_transitions.size() ? &m_transitions[iTransition] : NULL;
1950         }
1951
1952         //////////////////////////////////////////////////////////////////////////
1953         LibFunctionId CLibClass::AddFunction(const SGUID& graphGUID)
1954         {
1955                 LibFunctionId functionId = m_nextFunctionId ++;
1956                 m_functions.insert(TFunctionMap::value_type(functionId, SFunction(graphGUID)));
1957                 return functionId;
1958         }
1959
1960         //////////////////////////////////////////////////////////////////////////
1961         CLibFunction* CLibClass::GetFunction(const LibFunctionId& functionId)
1962         {
1963                 TFunctionMap::iterator  iFunction = m_functions.find(functionId);
1964                 return iFunction != m_functions.end() ? &iFunction->second.function : NULL;
1965         }
1966
1967         //////////////////////////////////////////////////////////////////////////
1968         uint32 CLibClass::AddFunction_New(const SGUID& guid)
1969         {
1970                 const uint32        functionIdx = m_functions_New.size();
1971                 CRuntimeFunctionPtr pFunction = std::make_shared<CRuntimeFunction>(guid);
1972                 m_functions_New.push_back(pFunction);
1973                 return functionIdx;
1974         }
1975
1976         //////////////////////////////////////////////////////////////////////////
1977         CRuntimeFunction* CLibClass::GetFunction_New(uint32 functionIdx)
1978         {
1979                 return functionIdx < m_functions_New.size() ? m_functions_New[functionIdx].get() : nullptr;
1980         }
1981
1982         //////////////////////////////////////////////////////////////////////////
1983         bool CLibClass::BindFunctionToGUID(const LibFunctionId& functionId, const SGUID& guid)
1984         {
1985                 return m_functionIdsByGUID.insert(TFunctionIdByGUIDMap::value_type(guid, functionId)).second;
1986         }
1987
1988         //////////////////////////////////////////////////////////////////////////
1989         void CLibClass::CompactMemory()
1990         {
1991                 for (TFunctionMap::value_type& functionPair : m_functions)
1992                 {
1993                         functionPair.second.function.CompactMemory();
1994                 }
1995
1996                 m_stateMachines.shrink_to_fit();
1997                 for (CLibStateMachine& stateMachine : m_stateMachines)
1998                 {
1999                         stateMachine.CompactMemory();
2000                 }
2001
2002                 m_states.shrink_to_fit();
2003                 for (CLibState& state : m_states)
2004                 {
2005                         state.CompactMemory();
2006                 }
2007
2008                 m_variables.shrink_to_fit();
2009                 m_containers.shrink_to_fit();
2010                 m_variants.shrink_to_fit();
2011                 m_timers.shrink_to_fit();
2012                 m_persistentTimers.shrink_to_fit();
2013                 m_abstractInterfaceImplementations.shrink_to_fit();
2014                 m_componentInstances.shrink_to_fit();
2015                 m_actionInstances.shrink_to_fit();
2016                 m_persistentActionInstances.shrink_to_fit();
2017                 m_constructors.shrink_to_fit();
2018                 m_persistentConstructors.shrink_to_fit();
2019                 m_destructors.shrink_to_fit();
2020                 m_persistentDestructors.shrink_to_fit();
2021                 m_signalReceivers.shrink_to_fit();
2022                 m_persistentSignalReceivers.shrink_to_fit();
2023                 m_transitions.shrink_to_fit();
2024                 m_functions_New.shrink_to_fit();
2025                 for (CRuntimeFunctionPtr& pFunction : m_functions_New)
2026                 {
2027                         pFunction->CompactMemory();
2028                 }
2029
2030                 m_resourcesToPrecache.shrink_to_fit();
2031         }
2032
2033         //////////////////////////////////////////////////////////////////////////
2034         void CLibClass::AddPrecacheResource(IAnyConstPtr resource)
2035         {
2036                 m_resourcesToPrecache.emplace_back(resource);
2037         }
2038
2039         //////////////////////////////////////////////////////////////////////////
2040         size_t CLibClass::GetPrecacheResourceCount() const
2041         {
2042                 return m_resourcesToPrecache.size();
2043         }
2044
2045         //////////////////////////////////////////////////////////////////////////
2046         IAnyConstPtr CLibClass::GetPrecacheResource(size_t ressourceIdx) const
2047         {
2048                 return ressourceIdx < m_resourcesToPrecache.size() ? m_resourcesToPrecache[ressourceIdx] : nullptr;
2049         }
2050
2051         //////////////////////////////////////////////////////////////////////////
2052         CLibClass::SFunction::SFunction(const SGUID& _graphGUID)
2053         {
2054                 function.SetGUID(_graphGUID);
2055         }
2056
2057         //////////////////////////////////////////////////////////////////////////
2058         void CLibClass::PreviewFunction(const CLibFunction& function, StringStreamOutCallback stringStreamOutCallback) const
2059         {
2060                 stringStreamOutCallback("function ");
2061                 stringStreamOutCallback(function.GetName());
2062                 if(function.GetSize() > 0)
2063                 {
2064                         stringStreamOutCallback("\n\n");
2065                         for(size_t functionPos = 0, size = function.GetSize(); functionPos < size; )
2066                         {
2067                                 const SVMOp*    pOp = function.GetOp(functionPos);
2068                                 {
2069                                         size_t  pos = static_cast<size_t>(reinterpret_cast<const uint8*>(pOp) - reinterpret_cast<const uint8*>(function.GetOp(0)));
2070                                         char            stringBuffer[StringUtils::s_sizeTStringBufferSize] = "";
2071                                         stringStreamOutCallback(StringUtils::SizeTToString(pos, stringBuffer));
2072                                 }
2073                                 switch(pOp->opCode)
2074                                 {
2075                                 case SVMOp::PUSH:
2076                                         {
2077                                                 const SVMPushOp*        pPushOp = static_cast<const SVMPushOp*>(pOp);
2078                                                 const CVariant&         value = function.GetVariantConsts()[pPushOp->iConstValue];
2079                                                 const bool                              valueIsString = (value.GetTypeId() == CVariant::STRING) || (value.GetTypeId() == CVariant::POOL_STRING);
2080                                                 stack_string                    stringBuffer;
2081                                                 StringUtils::VariantToString(value, stringBuffer);
2082                                                 stringStreamOutCallback("\tPUSH ");
2083                                                 if(valueIsString == true)
2084                                                 {
2085                                                         stringStreamOutCallback("\"");
2086                                                 }
2087                                                 stringStreamOutCallback(stringBuffer.c_str());
2088                                                 if(valueIsString == true)
2089                                                 {
2090                                                         stringStreamOutCallback("\"");
2091                                                 }
2092                                                 stringStreamOutCallback("\n");
2093                                                 break;
2094                                         }
2095                                 case SVMOp::SET:
2096                                         {
2097                                                 const SVMSetOp* pSetOp = static_cast<const SVMSetOp*>(pOp);
2098                                                 const CVariant& value = function.GetVariantConsts()[pSetOp->iConstValue];
2099                                                 const bool                      valueIsString = (value.GetTypeId() == CVariant::STRING) || (value.GetTypeId() == CVariant::POOL_STRING);
2100                                                 stack_string            stringBuffer;
2101                                                 StringUtils::SizeTToString(pSetOp->pos, stringBuffer);
2102                                                 stringStreamOutCallback("\tSET ");
2103                                                 stringStreamOutCallback(stringBuffer.c_str());
2104                                                 stringStreamOutCallback(" ");
2105                                                 StringUtils::VariantToString(value, stringBuffer);
2106                                                 if(valueIsString == true)
2107                                                 {
2108                                                         stringStreamOutCallback("\"");
2109                                                 }
2110                                                 stringStreamOutCallback(stringBuffer.c_str());
2111                                                 if(valueIsString == true)
2112                                                 {
2113                                                         stringStreamOutCallback("\"");
2114                                                 }
2115                                                 stringStreamOutCallback("\n");
2116                                                 break;
2117                                         }
2118                                 case SVMOp::COPY:
2119                                         {
2120                                                 const size_t    srcPos = static_cast<const SVMCopyOp*>(pOp)->srcPos;
2121                                                 const size_t    dstPos = static_cast<const SVMCopyOp*>(pOp)->dstPos;
2122                                                 char                                    stringBuffer[StringUtils::s_sizeTStringBufferSize] = "";
2123                                                 stringStreamOutCallback("\tCOPY ");
2124                                                 if(srcPos == INVALID_INDEX)
2125                                                 {
2126                                                         stringStreamOutCallback("TOP");
2127                                                 }
2128                                                 else
2129                                                 {
2130                                                         stringStreamOutCallback(StringUtils::SizeTToString(srcPos, stringBuffer));
2131                                                 }
2132                                                 stringStreamOutCallback(" ");
2133                                                 if(dstPos == INVALID_INDEX)
2134                                                 {
2135                                                         stringStreamOutCallback("TOP");
2136                                                 }
2137                                                 else
2138                                                 {
2139                                                         stringStreamOutCallback(StringUtils::SizeTToString(dstPos, stringBuffer));
2140                                                 }
2141                                                 stringStreamOutCallback("\n");
2142                                                 break;
2143                                         }
2144                                 case SVMOp::POP:
2145                                         {
2146                                                 const SVMPopOp* pPopOp = static_cast<const SVMPopOp*>(pOp);
2147                                                 char                                            stringBuffer[StringUtils::s_sizeTStringBufferSize] = "";
2148                                                 stringStreamOutCallback("\tPOP ");
2149                                                 stringStreamOutCallback(StringUtils::SizeTToString(pPopOp->count, stringBuffer));
2150                                                 stringStreamOutCallback("\n");
2151                                                 break;
2152                                         }
2153                                 case SVMOp::COLLAPSE:
2154                                         {
2155                                                 const SVMCollapseOp*    pCollapseOp = static_cast<const SVMCollapseOp*>(pOp);
2156                                                 char                                                                    stringBuffer[StringUtils::s_sizeTStringBufferSize] = "";
2157                                                 stringStreamOutCallback("\tCOLLAPSE ");
2158                                                 stringStreamOutCallback(StringUtils::SizeTToString(pCollapseOp->pos, stringBuffer));
2159                                                 stringStreamOutCallback("\n");
2160                                                 break;
2161                                         }
2162                                 case SVMOp::LOAD:
2163                                         {
2164                                                 const SVMLoadOp*        pLoadOp = static_cast<const SVMLoadOp*>(pOp);
2165                                                 const char*                             variableName = "?";
2166                                                 char                                                    stringBuffer[StringUtils::s_sizeTStringBufferSize] = "";
2167                                                 for(size_t iVariable = 0, variableCount = GetVariableCount(); iVariable < variableCount; ++ iVariable)
2168                                                 {
2169                                                         const ILibVariable&     variable = *GetVariable(iVariable);
2170                                                         if(variable.GetVariantPos() == pLoadOp->pos)
2171                                                         {
2172                                                                 variableName = variable.GetName();
2173                                                                 break;
2174                                                         }
2175                                                 }
2176                                                 stringStreamOutCallback("\tLOAD ");
2177                                                 stringStreamOutCallback(variableName);
2178                                                 stringStreamOutCallback(" ");
2179                                                 stringStreamOutCallback(StringUtils::SizeTToString(pLoadOp->count, stringBuffer));
2180                                                 stringStreamOutCallback("\n");
2181                                                 break;
2182                                         }
2183                                 case SVMOp::STORE:
2184                                         {
2185                                                 const SVMStoreOp*       pStoreOp = static_cast<const SVMStoreOp*>(pOp);
2186                                                 const char*                             variableName = "?";
2187                                                 char                                                    stringBuffer[StringUtils::s_sizeTStringBufferSize] = "";
2188                                                 for(size_t iVariable = 0, variableCount = GetVariableCount(); iVariable < variableCount; ++ iVariable)
2189                                                 {
2190                                                         const ILibVariable&     variable = *GetVariable(iVariable);
2191                                                         if(variable.GetVariantPos() == pStoreOp->pos)
2192                                                         {
2193                                                                 variableName = variable.GetName();
2194                                                                 break;
2195                                                         }
2196                                                 }
2197                                                 stringStreamOutCallback("\tSTORE ");
2198                                                 stringStreamOutCallback(variableName);
2199                                                 stringStreamOutCallback(" ");
2200                                                 stringStreamOutCallback(StringUtils::SizeTToString(pStoreOp->count, stringBuffer));
2201                                                 stringStreamOutCallback("\n");
2202                                                 break;
2203                                         }
2204                                 case SVMOp::CONTAINER_ADD:
2205                                         {
2206                                                 const SVMContainerAddOp*        pContainerAddOp = static_cast<const SVMContainerAddOp*>(pOp);
2207                                                 char                                                                                    stringBuffer[StringUtils::s_sizeTStringBufferSize] = "";
2208                                                 stringStreamOutCallback("\tCONTAINER_ADD ");
2209                                                 stringStreamOutCallback(GetContainer(pContainerAddOp->iContainer)->GetName());
2210                                                 stringStreamOutCallback(" ");
2211                                                 stringStreamOutCallback(StringUtils::SizeTToString(pContainerAddOp->count, stringBuffer));
2212                                                 stringStreamOutCallback("\n");
2213                                                 break;
2214                                         }
2215                                 case SVMOp::CONTAINER_REMOVE_BY_INDEX:
2216                                         {
2217                                                 const SVMContainerRemoveByIndexOp*      pContainerRemoveByIndexOp = static_cast<const SVMContainerRemoveByIndexOp*>(pOp);
2218                                                 stringStreamOutCallback("\tCONTAINER_REMOVE_BY_INDEX ");
2219                                                 stringStreamOutCallback(GetContainer(pContainerRemoveByIndexOp->iContainer)->GetName());
2220                                                 stringStreamOutCallback("\n");
2221                                                 break;
2222                                         }
2223                                 case SVMOp::CONTAINER_REMOVE_BY_VALUE:
2224                                         {
2225                                                 const SVMContainerRemoveByValueOp*      pContainerRemoveByValueOp = static_cast<const SVMContainerRemoveByValueOp*>(pOp);
2226                                                 char                                                                                                                            stringBuffer[StringUtils::s_sizeTStringBufferSize] = "";
2227                                                 stringStreamOutCallback("\tCONTAINER_REMOVE_BY_VALUE ");
2228                                                 stringStreamOutCallback(GetContainer(pContainerRemoveByValueOp->iContainer)->GetName());
2229                                                 stringStreamOutCallback(" ");
2230                                                 stringStreamOutCallback(StringUtils::SizeTToString(pContainerRemoveByValueOp->count, stringBuffer));
2231                                                 stringStreamOutCallback("\n");
2232                                                 break;
2233                                         }
2234                                 case SVMOp::CONTAINER_CLEAR:
2235                                         {
2236                                                 const SVMContainerClearOp*      pContainerClearOp = static_cast<const SVMContainerClearOp*>(pOp);
2237                                                 stringStreamOutCallback("\tCONTAINER_CLEAR ");
2238                                                 stringStreamOutCallback(GetContainer(pContainerClearOp->iContainer)->GetName());
2239                                                 stringStreamOutCallback("\n");
2240                                                 break;
2241                                         }
2242                                 case SVMOp::CONTAINER_SIZE:
2243                                         {
2244                                                 const SVMContainerSizeOp*       pContainerSizeOp = static_cast<const SVMContainerSizeOp*>(pOp);
2245                                                 char                                                                                    stringBuffer[StringUtils::s_sizeTStringBufferSize] = "";
2246                                                 stringStreamOutCallback("\tCONTAINER_SIZE ");
2247                                                 stringStreamOutCallback(GetContainer(pContainerSizeOp->iContainer)->GetName());
2248                                                 stringStreamOutCallback(" ");
2249                                                 stringStreamOutCallback(StringUtils::SizeTToString(pContainerSizeOp->divisor, stringBuffer));
2250                                                 stringStreamOutCallback("\n");
2251                                                 break;
2252                                         }
2253                                 case SVMOp::CONTAINER_GET:
2254                                         {
2255                                                 const SVMContainerGetOp*        pContainerGetOp = static_cast<const SVMContainerGetOp*>(pOp);
2256                                                 stringStreamOutCallback("\tCONTAINER_GET ");
2257                                                 stringStreamOutCallback(GetContainer(pContainerGetOp->iContainer)->GetName());
2258                                                 stringStreamOutCallback("\n");
2259                                                 break;
2260                                         }
2261                                 case SVMOp::CONTAINER_SET:
2262                                         {
2263                                                 const SVMContainerSetOp*        pContainerSetOp = static_cast<const SVMContainerSetOp*>(pOp);
2264                                                 char                                                                                    stringBuffer[StringUtils::s_sizeTStringBufferSize] = "";
2265                                                 stringStreamOutCallback("\tCONTAINER_SET ");
2266                                                 stringStreamOutCallback(GetContainer(pContainerSetOp->iContainer)->GetName());
2267                                                 stringStreamOutCallback(" ");
2268                                                 stringStreamOutCallback(StringUtils::SizeTToString(pContainerSetOp->count, stringBuffer));
2269                                                 stringStreamOutCallback("\n");
2270                                                 break;
2271                                         }
2272                                 case SVMOp::CONTAINER_FIND_BY_VALUE:
2273                                         {
2274                                                 const SVMContainerFindByValueOp*        pContainerFindByValueOp = static_cast<const SVMContainerFindByValueOp*>(pOp);
2275                                                 char                                                                                                                    stringBuffer[StringUtils::s_sizeTStringBufferSize] = "";
2276                                                 stringStreamOutCallback("\tCONTAINER_FIND_BY_VALUE ");
2277                                                 stringStreamOutCallback(GetContainer(pContainerFindByValueOp->iContainer)->GetName());
2278                                                 stringStreamOutCallback(" ");
2279                                                 stringStreamOutCallback(StringUtils::SizeTToString(pContainerFindByValueOp->count, stringBuffer));
2280                                                 stringStreamOutCallback("\n");
2281                                                 break;
2282                                         }
2283                                 case SVMOp::COMPARE:
2284                                         {
2285                                                 const SVMCompareOp*     pCompareOp = static_cast<const SVMCompareOp*>(pOp);
2286                                                 char                                                            stringBuffer[StringUtils::s_sizeTStringBufferSize] = "";
2287                                                 stringStreamOutCallback("\tCOMPARE ");
2288                                                 stringStreamOutCallback(StringUtils::SizeTToString(pCompareOp->lhsPos, stringBuffer));
2289                                                 stringStreamOutCallback(" ");
2290                                                 stringStreamOutCallback(StringUtils::SizeTToString(pCompareOp->rhsPos, stringBuffer));
2291                                                 stringStreamOutCallback(" ");
2292                                                 stringStreamOutCallback(StringUtils::SizeTToString(pCompareOp->count, stringBuffer));
2293                                                 stringStreamOutCallback("\n");
2294                                                 break;
2295                                         }
2296                                 case SVMOp::INCREMENT_INT32:
2297                                         {
2298                                                 const SVMIncrementInt32Op*      pIncrementInt32Op = static_cast<const SVMIncrementInt32Op*>(pOp);
2299                                                 char                                                                                            stringBuffer[StringUtils::s_sizeTStringBufferSize] = "";
2300                                                 stringStreamOutCallback("\tINCREMENT_INT32 ");
2301                                                 stringStreamOutCallback(StringUtils::SizeTToString(pIncrementInt32Op->pos, stringBuffer));
2302                                                 stringStreamOutCallback("\n");
2303                                                 break;
2304                                         }
2305                                 case SVMOp::LESS_THAN_INT32:
2306                                         {
2307                                                 const SVMLessThanInt32Op*       pLessThanInt32Op = static_cast<const SVMLessThanInt32Op*>(pOp);
2308                                                 char                                                                                    stringBuffer[StringUtils::s_sizeTStringBufferSize] = "";
2309                                                 stringStreamOutCallback("\tLESS_THAN_INT32 ");
2310                                                 stringStreamOutCallback(StringUtils::SizeTToString(pLessThanInt32Op->lhsPos, stringBuffer));
2311                                                 stringStreamOutCallback(" ");
2312                                                 stringStreamOutCallback(StringUtils::SizeTToString(pLessThanInt32Op->rhsPos, stringBuffer));
2313                                                 stringStreamOutCallback("\n");
2314                                                 break;
2315                                         }
2316                                 case SVMOp::GREATER_THAN_INT32:
2317                                         {
2318                                                 const SVMGreaterThanInt32Op*    pGreaterThanInt32Op = static_cast<const SVMGreaterThanInt32Op*>(pOp);
2319                                                 char                                                                                                    stringBuffer[StringUtils::s_sizeTStringBufferSize] = "";
2320                                                 stringStreamOutCallback("\tGREATER_THAN_INT32 ");
2321                                                 stringStreamOutCallback(StringUtils::SizeTToString(pGreaterThanInt32Op->lhsPos, stringBuffer));
2322                                                 stringStreamOutCallback(" ");
2323                                                 stringStreamOutCallback(StringUtils::SizeTToString(pGreaterThanInt32Op->rhsPos, stringBuffer));
2324                                                 stringStreamOutCallback("\n");
2325                                                 break;
2326                                         }
2327                                 case SVMOp::BRANCH:
2328                                         {
2329                                                 const size_t    pos = static_cast<const SVMBranchOp*>(pOp)->pos;
2330                                                 char                                    stringBuffer[StringUtils::s_sizeTStringBufferSize] = "";
2331                                                 stringStreamOutCallback("\tBRANCH ");
2332                                                 stringStreamOutCallback(StringUtils::SizeTToString(pos, stringBuffer));
2333                                                 stringStreamOutCallback("\n");
2334                                                 break;
2335                                         }
2336                                 case SVMOp::BRANCH_IF_ZERO:
2337                                         {
2338                                                 const size_t    pos = static_cast<const SVMBranchIfZeroOp*>(pOp)->pos;
2339                                                 char                                    stringBuffer[StringUtils::s_sizeTStringBufferSize] = "";
2340                                                 stringStreamOutCallback("\tBRANCH_IF_ZERO ");
2341                                                 stringStreamOutCallback(StringUtils::SizeTToString(pos, stringBuffer));
2342                                                 stringStreamOutCallback("\n");
2343                                                 break;
2344                                         }
2345                                 case SVMOp::BRANCH_IF_NOT_ZERO:
2346                                         {
2347                                                 const size_t    pos = static_cast<const SVMBranchIfNotZeroOp*>(pOp)->pos;
2348                                                 char                                    stringBuffer[StringUtils::s_sizeTStringBufferSize] = "";
2349                                                 stringStreamOutCallback("\tBRANCH_IF_NOT_ZERO ");
2350                                                 stringStreamOutCallback(StringUtils::SizeTToString(pos, stringBuffer));
2351                                                 stringStreamOutCallback("\n");
2352                                                 break;
2353                                         }
2354                                 case SVMOp::GET_OBJECT:
2355                                         {
2356                                                 stringStreamOutCallback("\tGET_OBJECT\n");
2357                                                 break;
2358                                         }
2359                                 case SVMOp::START_TIMER:
2360                                         {
2361                                                 // #SchematycTODO : Can we get to the timer's name from here?
2362                                                 char    guidString[StringUtils::s_guidStringBufferSize] = "";
2363                                                 StringUtils::SysGUIDToString(static_cast<const SVMStartTimerOp*>(pOp)->guid.sysGUID, guidString);
2364                                                 stringStreamOutCallback("\tSTART_TIMER ");
2365                                                 stringStreamOutCallback(guidString);
2366                                                 stringStreamOutCallback("\n");
2367                                                 break;
2368                                         }
2369                                 case SVMOp::STOP_TIMER:
2370                                         {
2371                                                 // #SchematycTODO : Can we get to the timer's name from here?
2372                                                 char    guidString[StringUtils::s_guidStringBufferSize] = "";
2373                                                 StringUtils::SysGUIDToString(static_cast<const SVMStopTimerOp*>(pOp)->guid.sysGUID, guidString);
2374                                                 stringStreamOutCallback("\tSTOP_TIMER ");
2375                                                 stringStreamOutCallback(guidString);
2376                                                 stringStreamOutCallback("\n");
2377                                                 break;
2378                                         }
2379                                 case SVMOp::SEND_SIGNAL:
2380                                         {
2381                                                 const SVMSendSignalOp*  pSendSignalOp = static_cast<const SVMSendSignalOp*>(pOp);
2382                                                 stringStreamOutCallback("\tSEND_SIGNAL ");
2383                                                 if(ISignalConstPtr pSignal = gEnv->pSchematyc2->GetLibRegistry().GetSignal(pSendSignalOp->guid))
2384                                                 {
2385                                                         stringStreamOutCallback(pSignal->GetName());
2386                                                         stringStreamOutCallback("\n");
2387                                                 }
2388                                                 else
2389                                                 {
2390                                                         stringStreamOutCallback("?\n");
2391                                                 }
2392                                                 break;
2393                                         }
2394                                 case SVMOp::BROADCAST_SIGNAL:
2395                                         {
2396                                                 const SVMBroadcastSignalOp*     pBroadcastSignalOp = static_cast<const SVMBroadcastSignalOp*>(pOp);
2397                                                 stringStreamOutCallback("\tBROADCAST_SIGNAL ");
2398                                                 if(ISignalConstPtr pSignal = gEnv->pSchematyc2->GetLibRegistry().GetSignal(pBroadcastSignalOp->guid))
2399                                                 {
2400                                                         stringStreamOutCallback(pSignal->GetName());
2401                                                         stringStreamOutCallback("\n");
2402                                                 }
2403                                                 else
2404                                                 {
2405                                                         stringStreamOutCallback("?\n");
2406                                                 }
2407                                                 break;
2408                                         }
2409                                 case SVMOp::CALL_GLOBAL_FUNCTION:
2410                                         {
2411                                                 const SVMCallGlobalFunctionOp*  pCallGlobalFunctionOp = static_cast<const SVMCallGlobalFunctionOp*>(pOp);
2412                                                 IGlobalFunctionConstPtr                                 pFunction = function.GetGlobalFunctionTable()[pCallGlobalFunctionOp->iGlobalFunction];
2413                                                 stringStreamOutCallback("\tCALL_GLOBAL_FUNCTION ");
2414                                                 stringStreamOutCallback(pFunction->GetName());
2415                                                 stringStreamOutCallback("\n");
2416                                                 break;
2417                                         }
2418                                 case SVMOp::CALL_ENV_ABSTRACT_INTERFACE_FUNCTION:
2419                                         {
2420                                                 const SVMCallEnvAbstractInterfaceFunctionOp*    pCallEnvAbstractInterfaceFunctionOp = static_cast<const SVMCallEnvAbstractInterfaceFunctionOp*>(pOp);
2421                                                 stringStreamOutCallback("\tCALL_ENV_ABSTRACT_INTERFACE_FUNCTION ");
2422                                                 if(IAbstractInterfaceConstPtr pAbstractInterface = gEnv->pSchematyc2->GetEnvRegistry().GetAbstractInterface(pCallEnvAbstractInterfaceFunctionOp->abstractInterfaceGUID))
2423                                                 {
2424                                                         stringStreamOutCallback(pAbstractInterface->GetName());
2425                                                 }
2426                                                 else
2427                                                 {
2428                                                         stringStreamOutCallback("?");
2429                                                 }
2430                                                 stringStreamOutCallback(" ");
2431                                                 if(IAbstractInterfaceFunctionConstPtr pFunction = gEnv->pSchematyc2->GetEnvRegistry().GetAbstractInterfaceFunction(pCallEnvAbstractInterfaceFunctionOp->functionGUID))
2432                                                 {
2433                                                         stringStreamOutCallback(pFunction->GetName());
2434                                                 }
2435                                                 else
2436                                                 {
2437                                                         stringStreamOutCallback("?");
2438                                                 }
2439                                                 stringStreamOutCallback("\n");
2440                                                 break;
2441                                         }
2442                                 case SVMOp::CALL_LIB_ABSTRACT_INTERFACE_FUNCTION:
2443                                         {
2444                                                 const SVMCallLibAbstractInterfaceFunctionOp*    pCallLibAbstractInterfaceFunctionOp = static_cast<const SVMCallLibAbstractInterfaceFunctionOp*>(pOp);
2445                                                 stringStreamOutCallback("\tCALL_LIB_ABSTRACT_INTERFACE_FUNCTION ");
2446                                                 if(ILibAbstractInterfaceConstPtr pAbstractInterface = gEnv->pSchematyc2->GetLibRegistry().GetAbstractInterface(pCallLibAbstractInterfaceFunctionOp->abstractInterfaceGUID))
2447                                                 {
2448                                                         stringStreamOutCallback(pAbstractInterface->GetName());
2449                                                 }
2450                                                 else
2451                                                 {
2452                                                         stringStreamOutCallback("?");
2453                                                 }
2454                                                 stringStreamOutCallback(" ");
2455                                                 if(ILibAbstractInterfaceFunctionConstPtr pFunction = gEnv->pSchematyc2->GetLibRegistry().GetAbstractInterfaceFunction(pCallLibAbstractInterfaceFunctionOp->functionGUID))
2456                                                 {
2457                                                         stringStreamOutCallback(pFunction->GetName());
2458                                                 }
2459                                                 else
2460                                                 {
2461                                                         stringStreamOutCallback("?");
2462                                                 }
2463                                                 stringStreamOutCallback("\n");
2464                                                 break;
2465                                         }
2466                                 case SVMOp::CALL_COMPONENT_MEMBER_FUNCTION:
2467                                         {
2468                                                 const SVMCallComponentMemberFunctionOp* pCallComponentMemberFunctionOp = static_cast<const SVMCallComponentMemberFunctionOp*>(pOp);
2469                                                 IComponentMemberFunctionConstPtr                                pFunction = function.GetComponentMemberFunctionTable()[pCallComponentMemberFunctionOp->iComponentMemberFunction];
2470                                                 stringStreamOutCallback("\tCALL_COMPONENT_MEMBER_FUNCTION ");
2471                                                 stringStreamOutCallback(pFunction->GetName());
2472                                                 stringStreamOutCallback("\n");
2473                                                 break;
2474                                         }
2475                                 case SVMOp::CALL_ACTION_MEMBER_FUNCTION:
2476                                         {
2477                                                 const SVMCallActionMemberFunctionOp*    pCallActionMemberFunctionOp = static_cast<const SVMCallActionMemberFunctionOp*>(pOp);
2478                                                 IActionMemberFunctionConstPtr                                   pFunction = function.GetActionMemberFunctionTable()[pCallActionMemberFunctionOp->iActionMemberFunction];
2479                                                 stringStreamOutCallback("\tCALL_ACTION_MEMBER_FUNCTION ");
2480                                                 stringStreamOutCallback(pFunction->GetName());
2481                                                 stringStreamOutCallback("\n");
2482                                                 break;
2483                                         }
2484                                 case SVMOp::CALL_LIB_FUNCTION:
2485                                         {
2486                                                 stringStreamOutCallback("\tCALL_LIB_FUNCTION ");
2487                                                 const SVMCallLibFunctionOp*     pCallLibFunctionOp = static_cast<const SVMCallLibFunctionOp*>(pOp);
2488                                                 if(const ILibFunction* pFunction = GetFunction(pCallLibFunctionOp->functionId))
2489                                                 {
2490                                                         stringStreamOutCallback(pFunction->GetName());
2491                                                         stringStreamOutCallback("\n");
2492                                                 }
2493                                                 else
2494                                                 {
2495                                                         stringStreamOutCallback("?\n");
2496                                                 }
2497                                                 break;
2498                                         }
2499                                 case SVMOp::RETURN:
2500                                         {
2501                                                 stringStreamOutCallback("\tRETURN\n");
2502                                                 break;
2503                                         }
2504                                 }
2505                                 functionPos += pOp->size;
2506                         }
2507                         stringStreamOutCallback("\nend\n\n");
2508                 }
2509         }
2510
2511         //////////////////////////////////////////////////////////////////////////
2512         CLib::CLib(const char* name)
2513                 : m_name(name)
2514         {}
2515
2516         //////////////////////////////////////////////////////////////////////////
2517         const char* CLib::GetName() const
2518         {
2519                 return m_name.c_str();
2520         }
2521
2522         //////////////////////////////////////////////////////////////////////////
2523         ISignalConstPtr CLib::GetSignal(const SGUID& guid) const
2524         {
2525                 TSignalMap::const_iterator      iSignal = m_signals.find(guid);
2526                 return iSignal != m_signals.end() ? iSignal->second : ISignalConstPtr();
2527         }
2528
2529         //////////////////////////////////////////////////////////////////////////
2530         void CLib::VisitSignals(const LibSignalVisitor& visitor)
2531         {
2532                 CRY_ASSERT(visitor);
2533                 if(visitor)
2534                 {
2535                         for(TSignalMap::iterator iSignal = m_signals.begin(), iEndSignal = m_signals.end(); iSignal != iEndSignal; ++ iSignal)
2536                         {
2537                                 if(visitor(iSignal->second) != EVisitStatus::Continue)
2538                                 {
2539                                         return;
2540                                 }
2541                         }
2542                 }
2543         }
2544
2545         //////////////////////////////////////////////////////////////////////////
2546         ILibAbstractInterfaceConstPtr CLib::GetAbstractInterface(const SGUID& guid) const
2547         {
2548                 TAbstractInterfaceMap::const_iterator   iAbstractInterface = m_abstractInterfaces.find(guid);
2549                 return iAbstractInterface != m_abstractInterfaces.end() ? iAbstractInterface->second : ILibAbstractInterfaceConstPtr();
2550         }
2551
2552         //////////////////////////////////////////////////////////////////////////
2553         void CLib::VisitAbstractInterfaces(const ILibAbstractInterfaceVisitor& visitor)
2554         {
2555                 CRY_ASSERT(visitor);
2556                 if(visitor)
2557                 {
2558                         for(TAbstractInterfaceMap::iterator iAbstractInterface = m_abstractInterfaces.begin(), iEndAbstractInterface = m_abstractInterfaces.end(); iAbstractInterface != iEndAbstractInterface; ++ iAbstractInterface)
2559                         {
2560                                 if(visitor(iAbstractInterface->second) != EVisitStatus::Continue)
2561                                 {
2562                                         return;
2563                                 }
2564                         }
2565                 }
2566         }
2567
2568         //////////////////////////////////////////////////////////////////////////
2569         ILibAbstractInterfaceFunctionConstPtr CLib::GetAbstractInterfaceFunction(const SGUID& guid) const
2570         {
2571                 TAbstractInterfaceFunctionMap::const_iterator   iAbstractInterfaceFunction = m_abstractInterfaceFunctions.find(guid);
2572                 return iAbstractInterfaceFunction != m_abstractInterfaceFunctions.end() ? iAbstractInterfaceFunction->second : ILibAbstractInterfaceFunctionConstPtr();
2573         }
2574
2575         //////////////////////////////////////////////////////////////////////////
2576         void CLib::VisitAbstractInterfaceFunctions(const ILibAbstractInterfaceFunctionVisitor& visitor)
2577         {
2578                 CRY_ASSERT(visitor);
2579                 if(visitor)
2580                 {
2581                         for(TAbstractInterfaceFunctionMap::iterator iAbstractInterfaceFunction = m_abstractInterfaceFunctions.begin(), iEndAbstractInterfaceFunction = m_abstractInterfaceFunctions.end(); iAbstractInterfaceFunction != iEndAbstractInterfaceFunction; ++ iAbstractInterfaceFunction)
2582                         {
2583                                 if(visitor(iAbstractInterfaceFunction->second) != EVisitStatus::Continue)
2584                                 {
2585                                         return;
2586                                 }
2587                         }
2588                 }
2589         }
2590
2591         //////////////////////////////////////////////////////////////////////////
2592         ILibClassConstPtr CLib::GetClass(const SGUID& guid) const
2593         {
2594                 TClassMap::const_iterator       iClass = m_classes.find(guid);
2595                 return iClass != m_classes.end() ? iClass->second : ILibClassConstPtr();
2596         }
2597
2598         //////////////////////////////////////////////////////////////////////////
2599         void CLib::VisitClasses(const ILibClassVisitor& visitor) const
2600         {
2601                 CRY_ASSERT(visitor);
2602                 if(visitor)
2603                 {
2604                         for(TClassMap::const_iterator iClass = m_classes.begin(), iEndClass = m_classes.end(); iClass != iEndClass; ++ iClass)
2605                         {
2606                                 if(visitor(iClass->second) != EVisitStatus::Continue)
2607                                 {
2608                                         return;
2609                                 }
2610                         }
2611                 }
2612         }
2613
2614         //////////////////////////////////////////////////////////////////////////
2615         void CLib::PreviewGraphFunctions(const SGUID& graphGUID, const StringStreamOutCallback& stringStreamOutCallback) const
2616         {
2617                 for(TClassMap::const_iterator iClass = m_classes.begin(), iEndClass = m_classes.end(); iClass != iEndClass; ++ iClass)
2618                 {
2619                         iClass->second->PreviewGraphFunctions(graphGUID, stringStreamOutCallback);
2620                 }
2621         }
2622
2623         //////////////////////////////////////////////////////////////////////////
2624         CSignalPtr CLib::AddSignal(const SGUID& guid, const SGUID& senderGUID, const char* name)
2625         {
2626                 if(GetSignal(guid) == NULL)
2627                 {
2628                         CSignalPtr      pSignal(new CSignal(guid, senderGUID, name));
2629                         m_signals.insert(TSignalMap::value_type(guid, pSignal));
2630                         return pSignal;
2631                 }
2632                 return CSignalPtr();
2633         }
2634
2635         //////////////////////////////////////////////////////////////////////////
2636         CSignalPtr CLib::GetSignal(const SGUID& guid)
2637         {
2638                 TSignalMap::iterator    iSignal = m_signals.find(guid);
2639                 return iSignal != m_signals.end() ? iSignal->second : CSignalPtr();
2640         }
2641
2642         //////////////////////////////////////////////////////////////////////////
2643         CLibAbstractInterfacePtr CLib::AddAbstractInterface(const SGUID& guid, const char* name)
2644         {
2645                 if(!GetAbstractInterface(guid))
2646                 {
2647                         CLibAbstractInterfacePtr        pAbstractInterface(new CLibAbstractInterface(guid, name));
2648                         m_abstractInterfaces.insert(TAbstractInterfaceMap::value_type(guid, pAbstractInterface));
2649                         return pAbstractInterface;
2650                 }
2651                 return CLibAbstractInterfacePtr();
2652         }
2653
2654         //////////////////////////////////////////////////////////////////////////
2655         CLibAbstractInterfacePtr CLib::GetAbstractInterface(const SGUID& guid)
2656         {
2657                 TAbstractInterfaceMap::iterator iAbstractInterface = m_abstractInterfaces.find(guid);
2658                 return iAbstractInterface != m_abstractInterfaces.end() ? iAbstractInterface->second : CLibAbstractInterfacePtr();
2659         }
2660
2661         //////////////////////////////////////////////////////////////////////////
2662         CLibAbstractInterfaceFunctionPtr CLib::AddAbstractInterfaceFunction(const SGUID& guid, const char* name)
2663         {
2664                 if(!GetAbstractInterfaceFunction(guid))
2665                 {
2666                         CLibAbstractInterfaceFunctionPtr        pAbstractInterfaceFunction(new CLibAbstractInterfaceFunction(guid, name));
2667                         m_abstractInterfaceFunctions.insert(TAbstractInterfaceFunctionMap::value_type(guid, pAbstractInterfaceFunction));
2668                         return pAbstractInterfaceFunction;
2669                 }
2670                 return CLibAbstractInterfaceFunctionPtr();
2671         }
2672
2673         //////////////////////////////////////////////////////////////////////////
2674         CLibAbstractInterfaceFunctionPtr CLib::GetAbstractInterfaceFunction(const SGUID& guid)
2675         {
2676                 TAbstractInterfaceFunctionMap::iterator iAbstractInterfaceFunction = m_abstractInterfaceFunctions.find(guid);
2677                 return iAbstractInterfaceFunction != m_abstractInterfaceFunctions.end() ? iAbstractInterfaceFunction->second : CLibAbstractInterfaceFunctionPtr();
2678         }
2679
2680         //////////////////////////////////////////////////////////////////////////
2681         CLibClassPtr CLib::AddClass(const SGUID& guid, const char* name, const SGUID& foundationGUID, const IPropertiesConstPtr& pFoundationProperties)
2682         {
2683                 if(!GetClass(guid))
2684                 {
2685                         CLibClassPtr pClass(new CLibClass(*this, guid, name, foundationGUID, pFoundationProperties));
2686                         m_classes.insert(TClassMap::value_type(guid, pClass));
2687                         return pClass;
2688                 }
2689                 return CLibClassPtr();
2690         }
2691
2692         //////////////////////////////////////////////////////////////////////////
2693         CLibClassPtr CLib::GetClass(const SGUID& guid)
2694         {
2695                 TClassMap::iterator     iClass = m_classes.find(guid);
2696                 return iClass != m_classes.end() ? iClass->second : CLibClassPtr();
2697         }
2698
2699         //////////////////////////////////////////////////////////////////////////
2700         void CLib::CompactMemory()
2701         {
2702                 for (TClassMap::value_type& classPair : m_classes)
2703                 {
2704                         classPair.second->CompactMemory();
2705                 }
2706         }
2707 }