gatedefinition.h

Go to the documentation of this file.

/*
* Copyright 2015 Autodesk, Inc. All rights reserved.
* Use of this software is subject to the terms of the Autodesk license agreement and any attachments or Appendices thereto provided at the time of installation or download,
* or which otherwise accompanies this software in either electronic or hard copy form, or which is signed by you and accepted by Autodesk.
*/

#ifndef Navigation_GateDefinition_H
#define Navigation_GateDefinition_H

#include "gwnavruntime/visualsystem/displaylistblob.h"
#include "gwnavruntime/kernel/SF_RefCount.h"
#include "gwnavruntime/channel/channel.h"


namespace Kaim
{

class World;


// A GateDefinition contains all necessary information to compute a gate at a given
// place along the string-pulled path.
class GateDefinition
{
public:
    GateDefinition();
    GateDefinition(GateType type, const Vec3f& pathPos, const Vec2f& gateLeftDir);
    GateDefinition(GateType type, const Vec3f& pathPos, const Vec3f& turnInnerPos, const Vec2f& gateLeftDir);

    GateType     GetGateType()     const { return m_gateType; }
    const Vec3f& GetPathPos()      const { return m_pathPos; }
    const Vec3f& GetTurnInnerPos() const { return m_turnInnerPos; }
    const Vec2f& GetGateLeftDir()  const { return m_gateLeftDir; }

private:
    Vec3f m_pathPos;
    Vec3f m_turnInnerPos;
    Vec2f m_gateLeftDir;
    GateType m_gateType;
};

template <class OSTREAM>
inline OSTREAM& operator<<(OSTREAM& os, const GateDefinition& g)
{
    os << "[p=" << g.GetPathPos() << ", t=" << g.GetTurnInnerPos() << ", lDir=" << g.GetGateLeftDir();
    switch (g.GetGateType())
    {
    case UndefinedGateType    :   os << ", type=UndefinedGateType    ]";   break;
    case StartGate            :   os << ", type=StartGate            ]";   break;
    case EndGate              :   os << ", type=EndGate              ]";   break;
    case SmallLeftTurn        :   os << ", type=SmallLeftTurn        ]";   break;
    case LeftTurnStart        :   os << ", type=LeftTurnStart        ]";   break;
    case LeftTurnIntermediary :   os << ", type=LeftTurnIntermediary ]";   break;
    case LeftTurnEnd          :   os << ", type=LeftTurnEnd          ]";   break;
    case SmallRightTurn       :   os << ", type=SmallRightTurn       ]";   break;
    case RightTurnStart       :   os << ", type=RightTurnStart       ]";   break;
    case RightTurnIntermediary:   os << ", type=RightTurnIntermediary]";   break;
    case RightTurnEnd         :   os << ", type=RightTurnEnd         ]";   break;
    case WidthAdjustment      :   os << ", type=WidthAdjustment      ]";   break;
    case ClampingAdjustment   :   os << ", type=ClampingAdjustment   ]";   break;

    default:   os << ", !!! wrong gate type (" << g.GetGateType() << ") !!!]";   break;
    }

    return os;
}

class GateDefinitionPersistentDisplayListIds
{
public:
    GateDefinitionPersistentDisplayListIds()
        : m_world(KY_NULL)
        , m_singleFrame(true)
        , m_displayListId_Nodes(KyUInt32MAXVAL)
        , m_displayListId_Edges(KyUInt32MAXVAL)
        , m_displayListId_TurnInnerPos(KyUInt32MAXVAL)
        , m_displayListId_LeftDirs(KyUInt32MAXVAL)
    {}

    ~GateDefinitionPersistentDisplayListIds() {}

    void Initialize(World* world);
    void Release();

public:
    World* m_world;
    bool m_singleFrame;

    KyUInt32 m_displayListId_Nodes;
    KyUInt32 m_displayListId_Edges;
    KyUInt32 m_displayListId_TurnInnerPos;
    KyUInt32 m_displayListId_LeftDirs;
};

class GateDefinitionDisplayConfig
{
public:
    GateDefinitionDisplayConfig() { SetDefaults(); }

    void SetDefaults();

    VisualShapeColor m_pathPosColor;
    VisualShapeColor m_turnInnerPosColor;
    VisualShapeColor m_leftDirColor;
    VisualColor m_pathEdgeColor;
    VisualColor m_pathToTurnInnerPosColor_Left;
    VisualColor m_pathToTurnInnerPosColor_Right;

    VisualColor m_gateTypeColor[GATE_TYPE_COUNT];

    KyFloat32 m_pathPosRadius;
    KyFloat32 m_turnInnerPosRadius;
    KyFloat32 m_leftDirArrowWidth;

    GateDefinitionPersistentDisplayListIds m_persistentDisplayListIds;
};


class GateDefinitionArray : public RefCountBase<GateDefinitionArray, MemStat_Channel>
{
public:
    GateDefinitionArray()
        : m_advancedVisualDebuggingEnabled(false)
    {}

    void Clear() { m_gateDefinitions.Clear(); }

    void PushBack(const GateDefinition& gateDefinition);

    bool                             IsEmpty()                       const { return m_gateDefinitions.IsEmpty();  }
    KyUInt32                         GetGateDefinitionCount()        const { return m_gateDefinitions.GetCount(); }
    const GateDefinition& GetGateDefinition(KyUInt32 idx) const { return m_gateDefinitions[idx];       }

    void SendVisualDebug(World* world, const GateDefinitionDisplayConfig& displayConfig, const char* listBaseName = "", const char* groupName = "GateDefinitionArray", KyUInt32 visualDebugId = KyUInt32MAXVAL) const;

private:
    KyArray<GateDefinition> m_gateDefinitions;

public:
    bool m_advancedVisualDebuggingEnabled;
};

} // namespace Kaim

#endif // Navigation_GateDefinition_H