PathComponent.h

#pragma once
 
#include <Core/Messages/EventMessage.h>
#include <Core/World/Component.h>
#include <Core/World/ComponentManager.h>
#include <Foundation/Types/Bitflags.h>
#include <GameEngine/GameEngineDLL.h>
#include <RendererCore/RendererCoreDLL.h>
 
struct plMsgTransformChanged;
struct plMsgParentChanged;
 
 
PL_DECLARE_FLAGS(plUInt32, plPathComponentFlags, VisualizePath, VisualizeUpDir);
PL_DECLARE_REFLECTABLE_TYPE(PL_GAMEENGINE_DLL, plPathComponentFlags);
 
 
struct PL_GAMEENGINE_DLL plMsgPathChanged : public plEventMessage
{
  PL_DECLARE_MESSAGE_TYPE(plMsgPathChanged, plEventMessage);
};
 
 
class plPathComponentManager : public plComponentManager<class plPathComponent, plBlockStorageType::FreeList>
{
public:
  plPathComponentManager(plWorld* pWorld);
 
  void SetEnableUpdate(plPathComponent* pThis, bool bEnable);
 
protected:
  void Initialize() override;
  void Update(const plWorldModule::UpdateContext& context);
 
  plHybridArray<plPathComponent*, 32> m_NeedUpdate;
};
 
class PL_GAMEENGINE_DLL plPathComponent : public plComponent
{
  PL_DECLARE_COMPONENT_TYPE(plPathComponent, plComponent, plPathComponentManager);
 
  // plComponent
 
public:
  virtual void SerializeComponent(plWorldWriter& ref_stream) const override;
  virtual void DeserializeComponent(plWorldReader& ref_stream) override;
 
protected:
  virtual void OnActivated() override;
  virtual void OnDeactivated() override;
 
  // plPathComponent
 
public:
  plPathComponent();
  ~plPathComponent();
 
  void OnMsgPathChanged(plMsgPathChanged& ref_msg); // [ message handler ]
 
  void SetClosed(bool bClosed);                // [ property ]
  bool GetClosed() const { return m_bClosed; } // [ property ]
 
  void SetPathFlags(plBitflags<plPathComponentFlags> flags);                    // [ property ]
  plBitflags<plPathComponentFlags> GetPathFlags() const { return m_PathFlags; } // [ property ]
 
 
  struct ControlPoint
  {
    plVec3 m_vPosition = plVec3::MakeZero();
    plVec3 m_vTangentIn = plVec3::MakeZero();
    plVec3 m_vTangentOut = plVec3::MakeZero();
    plAngle m_Roll;
 
    plResult Serialize(plStreamWriter& ref_writer) const;
    plResult Deserialize(plStreamReader& ref_reader);
  };
 
  void EnsureControlPointRepresentationIsUpToDate();
 
  const plArrayPtr<const plPathComponent::ControlPoint> GetControlPointRepresentation() const { return m_ControlPointRepresentation; }
 
 
  struct LinearizedElement
  {
    plVec3 m_vPosition = plVec3::MakeZero();
    plVec3 m_vUpDirection = plVec3::MakeAxisZ();
  };
 
  void EnsureLinearizedRepresentationIsUpToDate();
 
  const plArrayPtr<const plPathComponent::LinearizedElement> GetLinearizedRepresentation() const { return m_LinearizedRepresentation; }
 
  float GetLinearizedRepresentationLength() const { return m_fLinearizedLength; }
 
  void SetDisableControlPointUpdates(bool bDisable) { m_bDisableControlPointUpdates = bDisable; }
 
  struct LinearSampler
  {
    void SetToStart();
 
  private:
    friend class plPathComponent;
 
    float m_fSegmentFraction = 0.0f;
    plUInt32 m_uiSegmentNode = 0;
  };
 
  void SetLinearSamplerTo(LinearSampler& ref_sampler, float fDistance) const;
 
  bool AdvanceLinearSamplerBy(LinearSampler& ref_sampler, float& inout_fAddDistance) const;
 
  plPathComponent::LinearizedElement SampleLinearizedRepresentation(const LinearSampler& sampler) const;
 
  void SetLinearizationError(float fError);                             // [ property ]
  float GetLinearizationError() const { return m_fLinearizationError; } // [ property ]
 
protected:
  plUInt32 Nodes_GetCount() const { return m_Nodes.GetCount(); }         // [ property ]
  const plString& Nodes_GetNode(plUInt32 i) const { return m_Nodes[i]; } // [ property ]
  void Nodes_SetNode(plUInt32 i, const plString& node);                  // [ property ]
  void Nodes_Insert(plUInt32 uiIndex, const plString& node);             // [ property ]
  void Nodes_Remove(plUInt32 uiIndex);                                   // [ property ]
 
  void FindControlPoints(plDynamicArray<ControlPoint>& out_ControlPoints) const;
  void CreateLinearizedPathRepresentation(const plDynamicArray<ControlPoint>& points);
 
  void DrawDebugVisualizations();
 
  plBitflags<plPathComponentFlags> m_PathFlags;                 // [ property ]
  float m_fLinearizationError = 0.05f;                          // [ property ]
  float m_fLinearizedLength = 0.0f;                             //
  bool m_bDisableControlPointUpdates = false;                   //
  bool m_bControlPointsChanged = true;                          //
  bool m_bLinearizedRepresentationChanged = true;               //
  bool m_bClosed = false;                                       // [ property ]
  plDynamicArray<plString> m_Nodes;                             // [ property ]
  plDynamicArray<LinearizedElement> m_LinearizedRepresentation; //
  plDynamicArray<ControlPoint> m_ControlPointRepresentation;    //
};
 
 
using plPathNodeComponentManager = plComponentManager<class plPathNodeComponent, plBlockStorageType::Compact>;
 
struct plPathNodeTangentMode
{
  using StorageType = plUInt8;
 
  enum Enum
  {
    Auto,   
    Linear, 
 
    Default = Auto
  };
};
 
PL_DECLARE_REFLECTABLE_TYPE(PL_GAMEENGINE_DLL, plPathNodeTangentMode);
 
 
class PL_GAMEENGINE_DLL plPathNodeComponent : public plComponent
{
  PL_DECLARE_COMPONENT_TYPE(plPathNodeComponent, plComponent, plPathNodeComponentManager);
 
  // plPathNodeComponent
 
public:
  plPathNodeComponent();
  ~plPathNodeComponent();
 
  void SetRoll(plAngle roll);                                                      // [ property ]
  plAngle GetRoll() const { return m_Roll; }                                       // [ property ]
                                                                                   //
  void SetTangentMode1(plEnum<plPathNodeTangentMode> mode);                        // [ property ]
  plEnum<plPathNodeTangentMode> GetTangentMode1() const { return m_TangentMode1; } // [ property ]
                                                                                   //
  void SetTangentMode2(plEnum<plPathNodeTangentMode> mode);                        // [ property ]
  plEnum<plPathNodeTangentMode> GetTangentMode2() const { return m_TangentMode2; } // [ property ]
 
protected:
  void OnMsgTransformChanged(plMsgTransformChanged& msg);
  void OnMsgParentChanged(plMsgParentChanged& msg);
 
  virtual void OnActivated() override;
  virtual void OnDeactivated() override;
 
  void PathChanged();
 
  plAngle m_Roll;
  plEnum<plPathNodeTangentMode> m_TangentMode1;
  plEnum<plPathNodeTangentMode> m_TangentMode2;
};