WorldReader.h

#pragma once
 
#include <Core/World/World.h>
#include <Foundation/IO/MemoryStream.h>
#include <Foundation/IO/Stream.h>
#include <Foundation/Time/Time.h>
#include <Foundation/Types/UniquePtr.h>
 
class plStringDeduplicationReadContext;
class plProgress;
class plProgressRange;
 
struct plPrefabInstantiationOptions
{
  plGameObjectHandle m_hParent;
 
  plDynamicArray<plGameObject*>* m_pCreatedRootObjectsOut = nullptr;
  plDynamicArray<plGameObject*>* m_pCreatedChildObjectsOut = nullptr;
  const plUInt16* m_pOverrideTeamID = nullptr;
 
  bool m_bForceDynamic = false;
 
  plTempHashedString m_ReplaceNamedRootWithParent;
 
  enum class RandomSeedMode
  {
    DeterministicFromParent, 
    CompletelyRandom,        
    FixedFromSerialization,  
    CustomRootValue,         
  };
 
  RandomSeedMode m_RandomSeedMode = RandomSeedMode::DeterministicFromParent;
  plUInt32 m_uiCustomRandomSeedRootValue = 0;
 
  plTime m_MaxStepTime = plTime::MakeZero();
 
  plProgress* m_pProgress = nullptr;
};
 
class PL_CORE_DLL plWorldReader
{
public:
  class InstantiationContextBase
  {
  public:
    enum class StepResult
    {
      Continue,          
      ContinueNextFrame, 
      Finished,          
    };
 
    virtual ~InstantiationContextBase() = default;
 
    virtual StepResult Step() = 0;
 
    virtual void Cancel() = 0;
  };
 
  plWorldReader();
  ~plWorldReader();
 
  plResult ReadWorldDescription(plStreamReader& inout_stream, bool bWarningOnUnkownSkip = true);
 
  plUniquePtr<InstantiationContextBase> InstantiateWorld(plWorld& ref_world, const plUInt16* pOverrideTeamID = nullptr, plTime maxStepTime = plTime::MakeZero(), plProgress* pProgress = nullptr);
 
  plUniquePtr<InstantiationContextBase> InstantiatePrefab(plWorld& ref_world, const plTransform& rootTransform, const plPrefabInstantiationOptions& options);
 
  plStreamReader& GetStream() const { return *m_pStream; }
 
  plGameObjectHandle ReadGameObjectHandle();
 
  void ReadComponentHandle(plComponentHandle& out_hComponent);
 
  plUInt32 GetComponentTypeVersion(const plRTTI* pRtti) const;
 
  void ClearAndCompact();
 
  plUInt64 GetHeapMemoryUsage() const;
 
  using FindComponentTypeCallback = plDelegate<const plRTTI*(plStringView sTypeName)>;
 
  static FindComponentTypeCallback s_FindComponentTypeCallback;
 
  plUInt32 GetRootObjectCount() const;
  plUInt32 GetChildObjectCount() const;
 
  static void SetMaxStepTime(InstantiationContextBase* pContext, plTime maxStepTime);
  static plTime GetMaxStepTime(InstantiationContextBase* pContext);
 
private:
  struct GameObjectToCreate
  {
    plGameObjectDesc m_Desc;
    plString m_sGlobalKey;
    plUInt32 m_uiParentHandleIdx;
  };
 
  void ReadGameObjectDesc(GameObjectToCreate& godesc);
  void ReadComponentTypeInfo(plUInt32 uiComponentTypeIdx);
  void ReadComponentDataToMemStream(bool warningOnUnknownSkip = true);
  void ClearHandles();
  plUniquePtr<InstantiationContextBase> Instantiate(plWorld& world, bool bUseTransform, const plTransform& rootTransform, const plPrefabInstantiationOptions& options);
 
  plStreamReader* m_pStream = nullptr;
  plWorld* m_pWorld = nullptr;
 
  plUInt8 m_uiVersion = 0;
  plDynamicArray<plGameObjectHandle> m_IndexToGameObjectHandle;
 
  plDynamicArray<GameObjectToCreate> m_RootObjectsToCreate;
  plDynamicArray<GameObjectToCreate> m_ChildObjectsToCreate;
 
  struct ComponentTypeInfo
  {
    const plRTTI* m_pRtti = nullptr;
    plDynamicArray<plComponentHandle> m_ComponentIndexToHandle;
    plUInt32 m_uiNumComponents = 0;
  };
 
  plDynamicArray<ComponentTypeInfo> m_ComponentTypes;
  plHashTable<const plRTTI*, plUInt32> m_ComponentTypeVersions;
  plDefaultMemoryStreamStorage m_ComponentCreationStream;
  plDefaultMemoryStreamStorage m_ComponentDataStream;
  plUInt64 m_uiTotalNumComponents = 0;
 
  plUniquePtr<plStringDeduplicationReadContext> m_pStringDedupReadContext;
 
  class InstantiationContext : public InstantiationContextBase
  {
  public:
    InstantiationContext(plWorldReader& ref_worldReader, bool bUseTransform, const plTransform& rootTransform, const plPrefabInstantiationOptions& options);
    ~InstantiationContext();
 
    virtual StepResult Step() override;
    virtual void Cancel() override;
 
    template <bool UseTransform>
    bool CreateGameObjects(const plDynamicArray<GameObjectToCreate>& objects, plGameObjectHandle hParent, plDynamicArray<plGameObject*>* out_pCreatedObjects, plTime endTime);
 
    bool CreateComponents(plTime endTime);
    bool DeserializeComponents(plTime endTime);
    bool AddComponentsToBatch(plTime endTime);
 
    void SetMaxStepTime(plTime stepTime);
    plTime GetMaxStepTime() const;
 
  private:
    void BeginNextProgressStep(plStringView sName);
    void SetSubProgressCompletion(double fCompletion);
 
    friend class plWorldReader;
    plWorldReader& m_WorldReader;
 
    bool m_bUseTransform = false;
    plTransform m_RootTransform;
 
    plPrefabInstantiationOptions m_Options;
 
    plComponentInitBatchHandle m_hComponentInitBatch;
 
    // Current state
    struct Phase
    {
      enum Enum
      {
        Invalid = -1,
        CreateRootObjects,
        CreateChildObjects,
        CreateComponents,
        DeserializeComponents,
        AddComponentsToBatch,
        InitComponents,
 
        Count
      };
    };
 
    Phase::Enum m_Phase = Phase::Invalid;
    plUInt32 m_uiCurrentIndex = 0; // object or component
    plUInt32 m_uiCurrentComponentTypeIndex = 0;
    plUInt64 m_uiCurrentNumComponentsProcessed = 0;
    plMemoryStreamReader m_CurrentReader;
 
    plUniquePtr<plProgressRange> m_pOverallProgressRange;
    plUniquePtr<plProgressRange> m_pSubProgressRange;
  };
};