displaylist.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.
*/

// primary contact: BRGR - secondary contact: GUAL
#ifndef Navigation_DisplayList_H
#define Navigation_DisplayList_H

#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"

namespace Kaim
{

class DisplayListData;
class IVisualGeometry;
class VisualDebugServer;
class World;
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 ScopedDisplayList and DisplayListManager
// In that case these classes will be replaced by fully inlined classes, DisabledScopedDisplayList and DisabledDisplayListManager, 
// thanks to the define at the end of this file.
// If ScopedDisplayList and DisplayListManager are modified, please apply the changes into disableddisplaylist.inl as well.
#ifdef KY_BUILD_SHIPPING
# define KY_DISABLE_DISPLAYLIST
#endif

#ifndef KY_DISABLE_DISPLAYLIST

namespace Kaim
{

class DisplayListManager;

class ScopedDisplayList
{
    KY_DEFINE_NEW_DELETE_OPERATORS(MemStat_VisualSystem)
    KY_CLASS_WITHOUT_COPY(ScopedDisplayList)

public:
    // --------------- Constructors -------------

    ScopedDisplayList(DisplayListManager* manager, DisplayListActivation activation = DisplayList_Enable);
    ScopedDisplayList(World* world, DisplayListActivation activation = DisplayList_Enable); 

    // --------------- Init for ScopedDisplayList 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);  


    // --------------- Init for ScopedDisplayList with User-Controlled Lifespan -------------

    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);

    // --------------- Shapes -------------

    void PushTextVarg( const Vec3f& pos, const VisualColor& color, const char* textFmt, ...);
    void PushText(const Vec3f& pos, const VisualColor& color, const char* text, KyUInt32 textLength = 0);

    void PushLine(const Vec3f& P, const Vec3f& Q, const VisualColor& color, KyFloat32 pixelWidth = 1.f);

    void PushTriangle(const Vec3f& A, const Vec3f& B, const Vec3f& C, const VisualShapeColor& color);

    void PushTriangle(const Triangle3f& triangle, const VisualShapeColor& color);

    void PushVerticalCylinder(const Vec3f& P, KyFloat32 radius, KyFloat32 height, KyUInt32 subdivisions, const VisualShapeColor& color);

    void PushSegment(const Vec3f& A, const Vec3f& B, KyFloat32 radius, const VisualShapeColor& color);

    void PushQuad(const Vec3f& A, const Vec3f& B, KyFloat32 radius, const VisualShapeColor& color);

    void PushQuad(const Vec3f& A, const Vec3f& B, const Vec3f& C, const Vec3f& D, const VisualShapeColor& color);

    void PushPoint(const Vec3f& P, const VisualShapeColor& color) { PushPoint(P, 0.1f, color); }

    void PushPoint(const Vec3f& P, KyFloat32 radius, const VisualShapeColor& color);

    void PushPyramid(const Vec3f& P, const Vec3f& Q, KyFloat32 halfWidth, const VisualShapeColor& color);

    void PushSquareTubeSegment( const Vec3f& P, const Vec3f& Q, KyFloat32 halfWidth, const VisualShapeColor& color);

    void PushArrow(const Vec3f& P, const Vec3f& Q, KyFloat32 bodyHalfWidth, const VisualShapeColor& color, KyFloat32 headWidthRatio = 3.0f, KyFloat32 headLengthRatio = 0.33f);

    void PushBezierArrow(const Vec3f& P, const Vec3f& Q, KyFloat32 bodyHalfWidth, const VisualShapeColor& color, KyFloat32 headWidthRatio = 3.0f, KyUInt32 directionnality = 0);

    void PushChristmasTree(const Vec3f& P, const Vec3f& Q, KyFloat32 bodyHalfWidth, const VisualShapeColor& color);

    void PushSilex(const Vec3f& P, const Vec3f& Q, KyFloat32 bodyHalfWidth, const VisualShapeColor& color);

    void PushDoubleSilex(const Vec3f& P, const Vec3f& Q, KyFloat32 bodyHalfWidth, const VisualShapeColor& color);

    void PushCrossedRectangles(const Vec3f& P, const Vec3f& Q, KyFloat32 bodyHalfWidth, const VisualShapeColor& color);

    void PushColumn(const Vec3f& P, KyFloat32 halfWidth, KyFloat32 height, const VisualShapeColor& color);

    void PushOrientedBox(const Transform& transform, const Box3f& extents, const VisualShapeColor& color);
    void PushOrientedBox2d(const OrientedBox2d& orientedBox2d, const VisualShapeColor& color);

    void PushPoint_Tetrahedron(const Vec3f& P, KyFloat32 halfWidth, const VisualShapeColor& color);

    void PushDisk(const Vec3f& P, KyFloat32 radius, KyUInt32 subdivisions, const VisualShapeColor& color);

    void PushDiskSector(const Vec3f& P, KyFloat32 radius, const Vec3f& startPos, const Vec3f& endPos, const RotationDirection rotDir, KyUInt32 subdivisionCount, const VisualShapeColor& color);

    void PushCorona(const Vec3f& P, KyFloat32 innerRadius, KyFloat32 outerRadius, KyUInt32 subdivisions, const VisualShapeColor& color);

    void PushStadium(const Vec3f& P, const Vec3f& Q, KyFloat32 radius, KyUInt32 subdivisions, const VisualShapeColor& color);

    void PushBox(const Box3f& box, const VisualShapeColor& color);

    void PushCellBox(const Box2i& cellBox, const KyFloat32 altitudeMinMax[/*2*/], const DatabaseGenMetrics& genMetrics, const VisualShapeColor& color);

    void PushTriangleTubeSegment(const Vec3f& P, const Vec3f& Q, KyFloat32 halfWidth, const VisualShapeColor& color);

    void PushWall(const Vec3f& P, const Vec3f& Q, KyFloat32 upHeight, KyFloat32 downHeight, KyFloat32 halfWidth, const VisualShapeColor& color);

    void PushLadder(const Transform& transform, const Box3f& entrances, KyFloat32 ladderWidth, KyFloat32 rungsThickness, KyFloat32 rungsGapSize, const VisualShapeColor& shapeColor);

    void PushParabola(const Kaim::Vec3f& P, const Kaim::Vec3f& Q, KyFloat32 heightBias, KyUInt32 subdivisions, const VisualShapeColor& color);

    void PushFlag(const Vec3f& P, KyFloat32 height, KyFloat32 radius, const VisualShapeColor& color);

    // ...


private:
    void PushSegmentBasedShape(const Vec3f& P, const Vec3f& Q, KyFloat32 size, const VisualShapeColor& color, KyUInt32 displayShapeType);
    void PushCurveBasedShape(const Vec3f& P, const Vec3f& Q, KyFloat32 size, KyFloat32 subdivisions, const VisualShapeColor& color, KyUInt32 displayShapeType);
    void PushText(DisplayText& text);
    void PushShape(DisplayShape& shape);
    KyUInt32 SetLifespanIdentifier(KyUInt32 displayListId);

private:
    KyArrayPOD<char> m_tmpTextBuffer;

public: // internal
    ~ScopedDisplayList(); // call SendDisplayListData() and ReleaseDisplayListData()
    void Flush();         // call SendDisplayListData()
    DisplayListManager* GetManager() { return m_displayListManager; }

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


class DisplayListManager
{
    KY_DEFINE_NEW_DELETE_OPERATORS(MemStat_VisualSystem)

public:
    DisplayListManager();
    ~DisplayListManager();

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

    KyUInt32 GenerateDisplayListId();
    
    void RemoveDisplayList(KyUInt32 displayListId);

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

private:
    // Game side
    VisualDebugServer* m_visualDebugServer;
    KyUInt32 m_currentDisplayListId;
    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 != KY_NULL; }

    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

// 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"

// This allows to forward declare DisplayListManager and ScopedDisplayList
// and to use DisabledDisplayListManager and DisabledScopedDisplayList separately in unit tests
namespace Kaim
{

class DisplayListManager : public DisabledDisplayListManager
{
};

class ScopedDisplayList : public DisabledScopedDisplayList
{
    KY_CLASS_WITHOUT_COPY(ScopedDisplayList)

public:
    ScopedDisplayList(DisplayListManager* manager, DisplayListActivation activation = DisplayList_Disable)
        : DisabledScopedDisplayList(manager, activation)
    {}

    ScopedDisplayList(World* world, DisplayListActivation activation = DisplayList_Disable)
        : DisabledScopedDisplayList(world, activation)
    {}

    ~ScopedDisplayList()
    {}
};

} // namespace Kaim

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

#endif // Navigation_DisplayList_H