displaylist.h

Go to the documentation of this file.

/*
* Copyright 2016 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.
*/

#pragma once

#include "gwnavruntime/visualsystem/displaylistblob.h"
#include "gwnavruntime/math/rotation.h"
#include "gwnavruntime/blob/blobhandler.h"
#include "gwnavruntime/base/types.h"
#include "gwnavruntime/base/memory.h"
#include "gwnavruntime/base/stringutils.h"
#include <utility>

namespace Kaim
{

class DisplayListData;
class IVisualGeometry;
class VisualDebugServer;
class Triangle3f;
class Vec3f;
class Box3f;
class Box2i;
class Transform;
class OrientedBox2d;
class DatabaseGenMetrics;

enum DisplayListActivation
{
    DisplayList_Disable, 
    DisplayList_Enable,  
};

} // namespace Kaim
// we close the namespace Kaim here to reopen it cleanly inside
// - #ifndef KY_DISABLE_DISPLAYLIST
// - #else // KY_DISABLE_DISPLAYLIST



// Define KY_DISABLE_DISPLAYLIST to disable DisplayList and DisplayListManager
// In that case these classes will be replaced by fully inlined classes, DisabledDisplayList and DisabledDisplayListManager,
// thanks to the define at the end of this file.
// If DisplayList and DisplayListManager are modified, please apply the changes into disableddisplaylist.inl as well.
#ifdef KY_CONFIG_RELEASE
# define KY_DISABLE_DISPLAYLIST
#endif

#ifndef KY_DISABLE_DISPLAYLIST

namespace Kaim
{

class DisplayListManager;

class DisplayList
{
    KY_DEFINE_NEW_DELETE_OPERATORS(MemStat_VisualSystem)

public:
    typedef DisplayFlags     Flags;
    typedef DisplayDataType  DataType;
    typedef DisplayPrecision Precision;
    typedef DisplayStyle     Style;

    static const DisplayPrecision::Enum DefaultPrecision = DisplayPrecision::_2cm;

    // --------------- Constructors -------------

    DisplayList() : m_displayListManager(nullptr), m_displayListData(nullptr) {}

    DisplayList(DisplayListManager* manager, DisplayListActivation activation = DisplayList_Enable);

    ~DisplayList(); // call SendDisplayListData() and ReleaseDisplayListData()

private:
    // when we drop vc11, let's use the = delete syntax
    // DisplayList(const DisplayList&) = delete;
    // DisplayList& operator=(const DisplayList&) = delete;
    DisplayList(DisplayList&);
    DisplayList& operator=(DisplayList&);

public:
    DisplayList(DisplayList&& moved) : m_displayListManager(moved.m_displayListManager), m_displayListData(moved.m_displayListData)
    {
        moved.m_displayListManager = nullptr;
        moved.m_displayListData = nullptr;
    }

    DisplayList& operator=(DisplayList&& moved)
    {
        FlushAndClear();
        m_displayListManager = moved.m_displayListManager;
        m_displayListData    = moved.m_displayListData;
        moved.m_displayListManager = nullptr;
        moved.m_displayListData    = nullptr;
        return *this;
    }

    void FlushAndClear(); // call SendDisplayListData() and ReleaseDisplayListData()
    void Flush();         // call SendDisplayListData()

    DisplayListManager* GetManager() const { return m_displayListManager; }

    // --------------- Init for DisplayList stored only in the frame it was sent -------------

    void InitSingleFrameLifespan(const char listName[64], const char groupName[64]); 
    void InitSingleFrameLifespan(const char listName[64], KyUInt32 worldElementId);  
    void InitSingleFrameLifespan(const char listName[64], const char groupName[64], KyUInt32 worldElementId);  


    //static DisplayList Make(const char group[64], const char name[64]);

    // --------------- Do not call these functions, use DisplayListManager::MakeMultiFrame() instead -------------

    KyUInt32 InitUserControlledLifespan(const char listName[64], const char groupName[64], KyUInt32 displayListId);
    KyUInt32 InitUserControlledLifespan(const char listName[64], KyUInt32 worldElementId, KyUInt32 displayListId);
    KyUInt32 InitUserControlledLifespan(const char listName[64], const char groupName[64], KyUInt32 worldElementId, KyUInt32 displayListId);
    void InitUserControlledLifespan(const char listName[64], const char groupName[64]);
    void InitUserControlledLifespan_AssociateWithWorldElement(const char listName[64], const char groupName[64], KyUInt32 worldElementId);

    // --------------- Optional post-Init functions -------------

    void ShowInLabWhenSelected(bool showInLabWhenSelected);

    void ShowInLabWhenNotSelected(bool showInLabWhenNotSelected);

    void ShowInLab(bool showInLab);

    // --------------- Text -------------

    void PushTextVarg(const Vec3f& pos, const Color& color, const char* textFmt, ...); 
    void PushText(    const Vec3f& pos, const Color& color, const char* text, KyUInt32 textLength = 0); 
    void PushText(    const Vec3f& pos, const Color& color, const StringSpan& s) { PushText(pos, color, s.ptr, (KyUInt32)s.size); }

    // --------------- Point -------------

    void PushPoint(const Vec3f& P, const ShapeColor& shapeColor, Flags flags);
    void PushPoint(const Vec3f& P, const ShapeColor& shapeColor, Style::Enum style = Style::LineCross3d) { PushPoint(P, shapeColor, Flags::P(style)); }

    void PushPointLine3d(const Vec3f& P, Color color)                  { PushPoint(P, color, Style::LineCross3d); }
    void PushPointLine2d(const Vec3f& P, Color color)                  { PushPoint(P, color, Style::LineCross2d); }
    void PushPointFlag(  const Vec3f& P, const ShapeColor& shapeColor) { PushPoint(P, shapeColor, Style::VerticalFlag); }

    // --------------- PointRadius-------------

    void PushPoint(const Vec3f& P, KyFloat32 radius, const ShapeColor& shapeColor, Flags flags);
    void PushPoint(const Vec3f& P, KyFloat32 radius, const ShapeColor& shapeColor, Style::Enum style = Style::LineCross3d) { PushPoint(P, radius, shapeColor, Flags::P(style)); }

    void PushPointLine3d(    const Vec3f& P, KyFloat32 radius, Color color) { PushPoint(P, radius, color, Style::LineCross3d); }
    void PushPointLine2d(    const Vec3f& P, KyFloat32 radius, Color color) { PushPoint(P, radius, color, Style::LineCross2d); }
    void PushDiagonalCross2d(const Vec3f& P, KyFloat32 radius, Color color) { PushPoint(P, radius, color, Style::DiagonalCross2d); }

    void PushQuad2d(                const Vec3f& P, KyFloat32 radius, const ShapeColor& shapeColor) { PushPoint(P, radius, shapeColor, Style::Quad2d); }
    void PushQuadAndCross2d(        const Vec3f& P, KyFloat32 radius, const ShapeColor& shapeColor) { PushPoint(P, radius, shapeColor, Style::QuadAndCross2d); }
    void PushQuadAndDiagonalCross2d(const Vec3f& P, KyFloat32 radius, const ShapeColor& shapeColor) { PushPoint(P, radius, shapeColor, Style::QuadAndDiagonalCross2d); }

    void PushDiamond2d(        const Vec3f& P, KyFloat32 radius, const ShapeColor& shapeColor) { PushPoint(P, radius, shapeColor, Style::Diamond2d); }
    void PushDiamondAndCross2d(const Vec3f& P, KyFloat32 radius, const ShapeColor& shapeColor) { PushPoint(P, radius, shapeColor, Style::DiamondAndCross2d); }

    void PushPentagon2d(const Vec3f& P, KyFloat32 radius, const ShapeColor& shapeColor) { PushPoint(P, radius, shapeColor, Style::Pentagon2d); }
    void PushHexagon2d( const Vec3f& P, KyFloat32 radius, const ShapeColor& shapeColor) { PushPoint(P, radius, shapeColor, Style::Hexagon2d); }

    void PushOctogon2d(        const Vec3f& P, KyFloat32 radius, const ShapeColor& shapeColor) { PushPoint(P, radius, shapeColor, Style::Octogon2d); }
    void PushOctogonAndCross2d(const Vec3f& P, KyFloat32 radius, const ShapeColor& shapeColor) { PushPoint(P, radius, shapeColor, Style::OctogonAndCross2d); }

    void PushArrowCross2d(const Vec3f& P, KyFloat32 radius, const ShapeColor& shapeColor) { PushPoint(P, radius, shapeColor, Style::ArrowCross2d); }

    void PushPointBox(       const Vec3f& P, KyFloat32 radius, const ShapeColor& shapeColor) { PushPoint(P, radius, shapeColor, Style::Box); }
    void PushPointPyramidInv(const Vec3f& P, KyFloat32 radius, const ShapeColor& shapeColor) { PushPoint(P, radius, shapeColor, Style::PyramidInv); }

    void PushDisk(          const Vec3f& P, KyFloat32 radius, const ShapeColor& shapeColor, Precision::Enum p = DefaultPrecision) { PushPoint(P, radius, shapeColor, Flags::P(Style::Disk2d).Set(p)); }
    void PushDiskAndCross2d(const Vec3f& P, KyFloat32 radius, const ShapeColor& shapeColor, Precision::Enum p = DefaultPrecision) { PushPoint(P, radius, shapeColor, Flags::P(Style::DiskAndCross2d).Set(p)); }

    // --------------- Segment -------------

    void PushSegment(const Vec3f& P, const Vec3f& Q, const ShapeColor& shapeColor, Flags flags);
    void PushSegment(const Vec3f& P, const Vec3f& Q, const ShapeColor& shapeColor, Style::Enum style) { PushSegment(P, Q, shapeColor, Flags::PQ(style)); }

    void PushLine(               const Vec3f& P, const Vec3f& Q, const Color& color)           { PushSegment(P, Q, color     , Style::Line); }
    void PushArrow2d5(           const Vec3f& P, const Vec3f& Q, const Color& color)           { PushSegment(P, Q, color     , Style::Arrow2d5); }
    void PushArrow2d5_Double(    const Vec3f& P, const Vec3f& Q, const Color& color)           { PushSegment(P, Q, color     , Style::Arrow2d5_Double); }
    void PushArrowPyramid(       const Vec3f& P, const Vec3f& Q, const ShapeColor& shapeColor) { PushSegment(P, Q, shapeColor, Style::ArrowPyramid); }
    void PushArrowPyramid_Double(const Vec3f& P, const Vec3f& Q, const ShapeColor& shapeColor) { PushSegment(P, Q, shapeColor, Style::ArrowPyramid_Double); }

    // --------------- SegmentRadius -------------

    void PushSegment(const Vec3f& P, const Vec3f& Q, KyFloat32 radius, const ShapeColor& shapeColor, Flags flags);
    void PushSegment(const Vec3f& P, const Vec3f& Q, KyFloat32 radius, const ShapeColor& shapeColor, Style::Enum style, DisplayFaces::Enum faces = DisplayFaces::All)
    { PushSegment(P, Q, radius, shapeColor, Flags::PQ(style).Set(faces)); }

    void PushSegmentPyramid(      const Vec3f& P, const Vec3f& Q, KyFloat32 radius, const ShapeColor& shapeColor) { PushSegment(P, Q, radius, shapeColor, Style::Pyramid); }
    void PushSegmentTriangleCross(const Vec3f& P, const Vec3f& Q, KyFloat32 radius, const ShapeColor& shapeColor) { PushSegment(P, Q, radius, shapeColor, Style::TriangleCross); }
    void PushSegmentBox(          const Vec3f& P, const Vec3f& Q, KyFloat32 radius, const ShapeColor& shapeColor, DisplayFaces::Enum faces = DisplayFaces::All) { PushSegment(P, Q, radius, shapeColor, Style::Box, faces); }
    void PushSegmentSquareTube(   const Vec3f& P, const Vec3f& Q, KyFloat32 radius, const ShapeColor& shapeColor) { PushSegment(P, Q, radius, shapeColor, Style::SquareTube); }

    void PushSegmentTriangle2d5(  const Vec3f& P, const Vec3f& Q, KyFloat32 radius, const ShapeColor& shapeColor) { PushSegment(P, Q, radius, shapeColor, Style::Triangle2d5); }
    void PushSegmentQuad2d5(      const Vec3f& P, const Vec3f& Q, KyFloat32 radius, const ShapeColor& shapeColor) { PushSegment(P, Q, radius, shapeColor, Style::SegmentQuad2d5); }
    void PushSegmentCapsule2d5(   const Vec3f& P, const Vec3f& Q, KyFloat32 radius, const ShapeColor& shapeColor, Precision::Enum p = DefaultPrecision)
    { PushSegment(P, Q, radius, shapeColor, Flags::PQ(Style::Capsule2d5).Set(p)); }

    void PushArrowTube(           const Vec3f& P, const Vec3f& Q, KyFloat32 radius, const ShapeColor& shapeColor) { PushSegment(P, Q, radius, shapeColor, Style::ArrowTube); }
    void PushArrowTube_Double(    const Vec3f& P, const Vec3f& Q, KyFloat32 radius, const ShapeColor& shapeColor) { PushSegment(P, Q, radius, shapeColor, Style::ArrowTube_Double); }

    void PushLadder(              const Vec3f& P, const Vec3f& Q, KyFloat32 radius, const Color& color) { PushSegment(P, Q, radius, color, Style::Ladder); }

    // backward compatibility
    void PushArrow(const Vec3f& P, const Vec3f& Q, KyFloat32 radius, const ShapeColor& shapeColor, KyFloat32, KyFloat32) { PushArrowTube(P, Q, radius, shapeColor); }


    // --------------- SegmentHeight -------------

    void PushSegmentHeight(const Vec3f& P, const Vec3f& Q, KyFloat32 height, const ShapeColor& shapeColor, Flags flags);
    void PushSegmentHeight(const Vec3f& P, const Vec3f& Q, KyFloat32 height, const ShapeColor& shapeColor, Style::Enum style) { PushSegmentHeight(P, Q, height, shapeColor, Flags::PQ(style)); }

    void PushParabola(const Vec3f& P, const Vec3f& Q, KyFloat32 height, const Color& color) { PushSegmentHeight(P, Q, height, color, Style::Parabola); }

    // --------------- SegmentHeightRadius -------------

    void PushSegmentHeightRadius(const Vec3f& P, const Vec3f& Q, KyFloat32 height, KyFloat32 radius, const ShapeColor& shapeColor, Flags flags);
    void PushSegmentHeightRadius(const Vec3f& P, const Vec3f& Q, KyFloat32 height, KyFloat32 radius, const ShapeColor& shapeColor, Style::Enum style, DisplayFaces::Enum faces = DisplayFaces::All)
    { PushSegmentHeightRadius(P, Q, height, radius, shapeColor, Flags::PQ(style).Set(faces)); }

    void PushShearedBox(const Vec3f& P, const Vec3f& Q, KyFloat32 height, KyFloat32 radius, const ShapeColor& shapeColor, DisplayFaces::Enum faces = DisplayFaces::All)
    { PushSegmentHeightRadius(P, Q, height, radius, shapeColor, Style::ShearedBox, faces); }

    // --------------- PointHeight (VerticalSegment) -------------

    void PushVerticalSegment(const Vec3f& P, KyFloat32 height, const ShapeColor& shapeColor, Flags flags);
    void PushVerticalSegment(const Vec3f& P, KyFloat32 height, const ShapeColor& shapeColor, Style::Enum style) { PushVerticalSegment(P, height, shapeColor, Flags::PQ(style)); }

    void PushVerticalLine(const Vec3f& P, KyFloat32 height, Color color) { PushVerticalSegment(P, height, color, Style::Line); }

    // --------------- PointHeightRadius (VerticalSegment) -------------

    void PushVerticalSegment(const Vec3f& P, KyFloat32 height, KyFloat32 radius, const ShapeColor& shapeColor, Flags flags);
    void PushVerticalSegment(const Vec3f& P, KyFloat32 height, KyFloat32 radius, const ShapeColor& shapeColor, Style::Enum style, DisplayFaces::Enum faces = DisplayFaces::All)
    { PushVerticalSegment(P, height, radius, shapeColor, Flags::PQ(style).Set(faces)); }

    void PushVerticalPyramid(         const Vec3f& P, KyFloat32 height, KyFloat32 radius, const ShapeColor& shapeColor) { PushVerticalSegment(P, height, radius, shapeColor, Style::Pyramid); }
    void PushVerticalPyramidInv(      const Vec3f& P, KyFloat32 height, KyFloat32 radius, const ShapeColor& shapeColor) { PushVerticalSegment(P, height, radius, shapeColor, Style::PyramidInv); }
    void PushVerticalBox(             const Vec3f& P, KyFloat32 height, KyFloat32 radius, const ShapeColor& shapeColor, DisplayFaces::Enum faces = DisplayFaces::All) { PushVerticalSegment(P, height, radius, shapeColor, Style::Box, faces); }
    void PushVerticalTriangleCross(   const Vec3f& P, KyFloat32 height, KyFloat32 radius, const ShapeColor& shapeColor) { PushVerticalSegment(P, height, radius, shapeColor, Style::TriangleCross); }
    void PushVerticalTriangleCrossInv(const Vec3f& P, KyFloat32 height, KyFloat32 radius, const ShapeColor& shapeColor) { PushVerticalSegment(P, height, radius, shapeColor, Style::TriangleCrossInv); }

    void PushVerticalPentagon(        const Vec3f& P, KyFloat32 height, KyFloat32 radius, const ShapeColor& shapeColor) { PushVerticalSegment(P, height, radius, shapeColor, Style::VerticalPentagon); }
    void PushVerticalHexagon(         const Vec3f& P, KyFloat32 height, KyFloat32 radius, const ShapeColor& shapeColor) { PushVerticalSegment(P, height, radius, shapeColor, Style::VerticalHexagon); }
    void PushVerticalOctogon(         const Vec3f& P, KyFloat32 height, KyFloat32 radius, const ShapeColor& shapeColor) { PushVerticalSegment(P, height, radius, shapeColor, Style::VerticalOctogon); }

    void PushVerticalCylinder(const Vec3f& P, KyFloat32 height, KyFloat32 radius, const ShapeColor& shapeColor,
                              Precision::Enum precision = DefaultPrecision, DisplayFaces::Enum faces = DisplayFaces::All)
    { PushVerticalSegment(P, height, radius, shapeColor, Flags::PQ(Style::VerticalCylinder).Set(faces).Set(precision)); }

    void PushVerticalFlag(const Vec3f& P, KyFloat32 height, KyFloat32 radius, const ShapeColor& shapeColor) { PushVerticalSegment(P, height, radius, shapeColor, Style::VerticalFlag); }

    // --------------- Triangle, Quad, Box -------------

    void PushTriangle(const Vec3f& A, const Vec3f& B, const Vec3f& C, const ShapeColor& shapeColor);
    void PushTriangle(const Triangle3f& triangle, const ShapeColor& shapeColor) { PushTriangle(triangle.A, triangle.B, triangle.C, shapeColor); }
    void PushQuad(const Vec3f& A, const Vec3f& B, const Vec3f& C, const Vec3f& D, const ShapeColor& shapeColor);
    void PushBox(const Box3f& box, const ShapeColor& shapeColor, DisplayFaces::Enum faces = DisplayFaces::All);

    // --------------- Other shapes -------------

    void PushDonut(const Vec3f& P, KyFloat32 innerRadius, KyFloat32 outerRadius, const ShapeColor& shapeColor, Precision::Enum precision = DefaultPrecision);
    void PushSegmentVerticalQuad(const Vec3f& P, const Vec3f& Q, KyFloat32 above, KyFloat32 below, const ShapeColor& shapeColor);
    void PushOrientedBox(const Transform& transform, const Box3f& box, const ShapeColor& shapeColor);
    void PushOrientedBox2d(const OrientedBox2d& orientedBox2d, const ShapeColor& shapeColor);
    void PushDiskSector(const Vec3f& P, KyFloat32 radius, const Vec3f& startPos, const Vec3f& endPos, const RotationDirection rotDir, const ShapeColor& shapeColor, Precision::Enum precision = DefaultPrecision);

    // nothing to do here because specific to genMetrics/navmesh
    void PushCellBox(const Box2i& cellBox, const KyFloat32 altitudeMinMax[/*2*/], const DatabaseGenMetrics& genMetrics, const ShapeColor& shapeColor);

private:
    DisplayText& NewText();

    KyUInt32 SetDisplayListId(KyUInt32 displayListId);
    void PushShape(DisplayShape& shape);

public: // internal
    DisplayListManager* m_displayListManager;
    DisplayListData*    m_displayListData;
};


class DisplayListManager
{
    KY_DEFINE_NEW_DELETE_OPERATORS(MemStat_VisualSystem)
    KY_CLASS_WITHOUT_COPY(DisplayListManager)

public:
    DisplayListManager(VisualDebugServer* visualDebugServer = nullptr);
    ~DisplayListManager();

    void SetVisualDebugServer(VisualDebugServer* visualDebugServer) { m_visualDebugServer = visualDebugServer; }
    bool IsVisualDebugSupported();

    // ---------- Create a DisplayList that will be displayed 1 frame ----------
    DisplayList Make(const char group[64], const char name[64]);
    DisplayList Make(KyUInt32 worldElementId, const char name[64]);
    DisplayList Make(KyUInt32 worldElementId, const char group[64], const char name[64]);

    // ---------- Create a DisplayList that will be displayed multiple frames, until RemoveDisplayList() is called ----------
    DisplayList MakeMultiFrame(KyUInt32& displayListId, const char group[64], const char name[64]);

    DisplayList MakeMultiFrame(KyUInt32& displayListId, KyUInt32 worldElementId, const char name[64]);

    DisplayList MakeMultiFrame(KyUInt32& displayListId, KyUInt32 worldElementId, const char group[64], const char name[64]);

    KyUInt32 GenerateDisplayListId();

    void RemoveDisplayList(KyUInt32 displayListId);

    void RemoveDisplayList(const char* displayListName, const char* displayListGroupName, KyUInt32 worldElementId = KyUInt32MAXVAL);

    void NewFrame();

private:
    // Game side
    VisualDebugServer* m_visualDebugServer;
    KyUInt32 m_currentDisplayListId; // used to generate unique ids in GenerateDisplayListId()
    BlobHandler<DisplayListBlob> m_workingDisplayListBlobHandler; // reusable handler used to create all display list blobs
    KyArray<DisplayListData*> m_displayListDataPool;

    // NavigationLab side
    // buffer containing all the display list blobs packed one after each other
    KyArrayPOD<char> m_displayListBlobsToRenderBuffer; // [blobSize_1 : KyUInt32][blob_1....][blobSize_2 : KyUInt32][blob_2....]...
    Ptr<IVisualGeometry> m_visualGeometry;

public: // internal
    DisplayListData* GetNewDisplayListData(); // return the first unused DisplayListData in m_displayListDataPool
    void SendDisplayListData(DisplayListData* displayListData); // Send DisplayListData to the VisualDebug (and possibly to the VisualGeometry if m_visualGeometry!=NULL)
    void ReleaseDisplayListData(DisplayListData* displayListData); // Clear this displayListData so that it can be reused by another display list

    // NavigationLab side : DisplayListBlobToRender management
    void AddDisplayListBlobToRender(const char* displayListBlob, KyUInt32 blobsize);
    DisplayListBlob* GetNextDisplayListBlobToRender(KyUInt32& sizeRead);
    void ClearDisplayListBlobsToRender();

    // NavigationLab side : DisplayListBlobToRender => VisualGeometry
    void SetVisualGeometry(IVisualGeometry* visualGeometry); // in cpp to avoid including IVisualGeometry
    IVisualGeometry* GetVisualGeometry() { return m_visualGeometry; }
    bool IsVisualGeometrySupported()     { return m_visualGeometry != nullptr; }

    void BuildVisualGeometry(); // fill the m_visualGeometry with the content of m_displayLists.

public: // DEPRECATED
    KY_DEPRECATED(void SubmitToRenderer()) { BuildVisualGeometry(); } 
};


} // namespace Kaim

//------------------------------------------------------------------------------------------------------------------------------------------------
#else // KY_DISABLE_DISPLAYLIST is defined

// Here we use a separated file in order to easily maintain both versions by comparing the two files (displaylist.h and disableddisplaylist.inl)
// Note that disableddisplaylist.inl has its own namespace Kaim {}
# include "gwnavruntime/visualsystem/disableddisplaylist.inl"


namespace Kaim
{

// We derive DisplayListManager from DisabledDisplayListManager (instead of typedef) because this allows
// to test DisabledDisplayListManager in Debug/Dev mode
class DisplayListManager : public DisabledDisplayListManager
{
};

// We derive DisplayList from DisabledDisplayList (instead of typedef) because this allows
// to test DisabledDisplayList in Debug/Dev mode
class DisplayList : public DisabledDisplayList
{
public:
    DisplayList(DisplayListManager* manager, DisplayListActivation activation = DisplayList_Disable)
        : DisabledDisplayList(manager, activation)
    {}

    // in Release DisplayListManager::Make returns a DisabledDisplayList, so we need a way to construct a DisplayList from it
    DisplayList(DisabledDisplayList) {}

    // when we drop vc11, let's use the = delete syntax
    // DisplayList(const DisplayList&) = delete;
    // DisplayList& operator=(const DisplayList&) = delete;
private:
    DisplayList(DisplayList&);
    DisplayList& operator=(DisplayList&);
public:

    DisplayList(DisplayList&&) {}
    DisplayList& operator=(DisplayList&&) { return *this; }

    ~DisplayList() {}
};

} // namespace Kaim

#endif // KY_DISABLE_DISPLAYLIST
//------------------------------------------------------------------------------------------------------------------------------------------------


namespace Kaim
{

typedef KY_DEPRECATED(DisplayList ScopedDisplayList); // ScopedDisplayList deprecated since 2.17.0, use DisplayList instead

} // namespace Kaim