Display.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "Core/System.h"
#include "Core/Types.h"
#include "Geo/GeoEnum.h"
#include "Math/Point.h"
#include "UI/Visu.h"
 
#ifdef CADKERNEL_DEV
#include "UI/DefineForDebug.h"
#endif
 
class FString;
 
namespace UE::CADKernel
{
 
class FAABB2D;
class FAABB;
class FBody;
class FCurve;
class FEdgeMesh;
class FEdgeMesh;
class FEntity;
class FFaceMesh;
class FFaceMesh;
class FGroup;
class FMesh;
class FModel;
class FModelMesh;
class FRestrictionCurve;
class FShell;
class FSurface;
class FTopologicalEdge;
class FTopologicalFace;
class FTopologicalLoop;
class FTopologicalVertex;
class FVertexMesh;
class FVertexMesh;
struct FLinearBoundary;
 
#ifdef CADKERNEL_DEBUG
void Wait(bool bMakeWait = true);
void Open3DDebugSession(FString name, const TArray<FIdent>& idList = TArray<FIdent>());
inline void Open3DDebugSession(bool bIsDisplayed, FString name, const TArray<FIdent>& idList = TArray<FIdent>())
{
    if (bIsDisplayed)
    {
        Open3DDebugSession(name, idList);
    }
};
void Close3DDebugSession(bool bIsDisplayed = true);
#else
inline void Wait(bool bMakeWait = true) {};
inline void Open3DDebugSession(bool bIsDisplayed, FString name, const TArray<FIdent>& idList = TArray<FIdent>()) {};
inline void Open3DDebugSession(FString name, const TArray<FIdent>& idList = TArray<FIdent>()) {};
inline void Close3DDebugSession(bool bIsDisplayed = true) {};
#endif
 
class CADKERNEL_API F3DDebugSession
{
private:
    bool bDisplay = true;
 
public:
    F3DDebugSession(FString Name, const TArray<FIdent>& Idents = TArray<FIdent>())
    {
#ifdef CADKERNEL_DEBUG
        Open3DDebugSession(Name, Idents);
#endif
    }
 
    F3DDebugSession(bool bInDisplay, FString Name, const TArray<FIdent>& Idents = TArray<FIdent>())
        : bDisplay(bInDisplay)
    {
#ifdef CADKERNEL_DEBUG
        if (bDisplay)
        {
            Open3DDebugSession(Name, Idents);
        }
#endif
    }
 
    ~F3DDebugSession()
    {
#ifdef CADKERNEL_DEBUG
        if (bDisplay)
        {
            Close3DDebugSession();
        }
#endif
    }
};
 
CADKERNEL_API void Open3DDebugSegment(FIdent Ident);
CADKERNEL_API void Close3DDebugSegment();
 
class CADKERNEL_API F3DDebugSegment
{
public:
    F3DDebugSegment(FIdent Ident)
    {
#ifdef CADKERNEL_DEBUG
        Open3DDebugSegment(Ident);
#endif
    }
 
    ~F3DDebugSegment()
    {
#ifdef CADKERNEL_DEBUG
        Close3DDebugSegment();
#endif
    }
};
 
CADKERNEL_API void FlushVisu();
 
template<typename TPoint>
void DrawPoint(const TPoint& InPoint, EVisuProperty Property = EVisuProperty::BluePoint)
{
#ifdef CADKERNEL_DEBUG
    FSystem::Get().GetVisu()->DrawPoint(InPoint, Property);
#endif
}
 
CADKERNEL_API void DrawElement(int32 Dimension, TArray<FVector>& Points, EVisuProperty Property = EVisuProperty::Element);
 
template<typename TPoint>
void Draw(const TArray<TPoint>& Points, EVisuProperty Property = EVisuProperty::BlueCurve)
{
#ifdef CADKERNEL_DEBUG
    FSystem::Get().GetVisu()->DrawPolyline(Points, Property);
#endif
}
 
CADKERNEL_API void DrawMesh(const TSharedPtr<FMesh>& mesh);
 
CADKERNEL_API void DisplayEdgeCriteriaGrid(int32 EdgeId, const TArray<FVector>& Points3D);
 
template<typename TPoint>
void DisplayPoint(const TPoint& Point, FIdent Ident)
{
#ifdef CADKERNEL_DEBUG
    F3DDebugSegment G(Ident);
    DrawPoint(Point);
#endif
}
 
template<typename TPoint>
void DisplayPoint(const TPoint& Point, EVisuProperty Property = EVisuProperty::BluePoint)
{
#ifdef CADKERNEL_DEBUG
    DrawPoint(Point, Property);
#endif
}
 
template<typename TPoint>
void DisplayPoint(const TPoint& Point, EVisuProperty Property, FIdent Ident)
{
#ifdef CADKERNEL_DEBUG
    F3DDebugSegment G(Ident);
    DrawPoint(Point, Property);
#endif
}
 
static void DisplayPoint2DWithScale(const FVector2d& Point, EVisuProperty Property = EVisuProperty::BluePoint)
{
#ifdef CADKERNEL_DEBUG
    DrawPoint(Point * DisplayScale, Property);
#endif
}
 
static void DisplayPoint2DWithScale(const FVector2d& Point, EVisuProperty Property, FIdent Ident)
{
#ifdef CADKERNEL_DEBUG
    F3DDebugSegment G(Ident);
    DrawPoint(Point * DisplayScale, Property);
#endif
}
 
template<typename TPoint>
void DisplayPoints(FString Message, const TArray<TPoint>& Points, EVisuProperty Property = EVisuProperty::BluePoint, bool bDisplay = true)
{
#ifdef CADKERNEL_DEBUG
    if (!bDisplay)
    {
        return;
    }
 
    Open3DDebugSession(Message);
    for (int32 Index = 0; Index < Points.Num(); ++Index)
    {
        DisplayPoint(Points[Index], Property);
    }
    Close3DDebugSession();
#endif
}
 
CADKERNEL_API void DisplayProductTree(const FEntity& RootId);
CADKERNEL_API void DisplayProductTree(const FModel& Model);
CADKERNEL_API void DisplayProductTree(const FBody& Body);
CADKERNEL_API void DisplayProductTree(const FShell& Shell);
 
CADKERNEL_API void DisplayAABB(const FAABB& aabb, FIdent Ident = 0);
CADKERNEL_API void DisplayAABB2D(const FAABB2D& aabb, FIdent Ident = 0);
 
CADKERNEL_API void DisplayEntity(const FEntity& Entity);
CADKERNEL_API void DisplayEntity2D(const FEntity& Entity);
 
CADKERNEL_API void DisplayLoop(const FTopologicalFace& Entity);
CADKERNEL_API void DisplayIsoCurve(const FSurface& CarrierSurface, double Coordinate, EIso Type);
 
CADKERNEL_API void Display(const FPlane& plane, FIdent Ident = 0);
 
CADKERNEL_API void Display(const FCurve& Curve);
CADKERNEL_API void Display(const FSurface& CarrierSurface);
 
CADKERNEL_API void Display(const FGroup& Group);
CADKERNEL_API void Display(const FModel& Model);
CADKERNEL_API void Display(const FBody& Body);
CADKERNEL_API void Display(const FShell& Shell);
CADKERNEL_API void Display(const FTopologicalEdge& Edge, EVisuProperty Property = EVisuProperty::BlueCurve);
CADKERNEL_API void Display(const FTopologicalFace& Face);
CADKERNEL_API void Display(const FTopologicalLoop& Loop);
CADKERNEL_API void Display(const FTopologicalVertex& Vertex, EVisuProperty Property = EVisuProperty::BluePoint);
 
CADKERNEL_API void Display2D(const FTopologicalEdge& Edge, EVisuProperty Property = EVisuProperty::BlueCurve);
CADKERNEL_API void Display2D(const FTopologicalFace& Face);
CADKERNEL_API void Display2D(const FTopologicalLoop& Loop);
CADKERNEL_API void Display2D(const FSurface& CarrierSurface);
 
CADKERNEL_API void Display2DWithScale(const FTopologicalEdge& Edge, EVisuProperty Property = EVisuProperty::BlueCurve);
CADKERNEL_API void Display2DWithScale(const FTopologicalFace& Face);
CADKERNEL_API void Display2DWithScale(const FTopologicalLoop& Loop);
CADKERNEL_API void Display2DWithScale(const FSurface& CarrierSurface);
 
CADKERNEL_API void DisplayMesh(const FFaceMesh& Mesh);
CADKERNEL_API void DisplayMesh(const FEdgeMesh& Mesh);
CADKERNEL_API void DisplayMesh(const FVertexMesh& Mesh);
 
CADKERNEL_API void DisplayMesh(const FModel& Model);
CADKERNEL_API void DisplayMesh(const FBody& Body);
CADKERNEL_API void DisplayMesh(const FShell &Shel);
 
CADKERNEL_API void Display(const FModelMesh& MeshModel);
 
CADKERNEL_API void DisplayControlPolygon(const FCurve& Entity);
CADKERNEL_API void DisplayControlPolygon(const FSurface& Entity);
 
template<typename TPoint>
void DisplaySegment(const TPoint& Point1, const TPoint& Point2, FIdent Ident = 0, EVisuProperty Property = EVisuProperty::BlueCurve, bool bWithOrientation = false)
{
#ifdef CADKERNEL_DEBUG
    F3DDebugSegment G(Ident);
    if (bWithOrientation)
    {
        DrawSegmentOrientation(Point1, Point2, Property);
    }
    DrawSegment(Point1, Point2, Property);
 #endif
};
 
template<typename TPoint>
void DisplaySegmentWithScale(const TPoint& Point1, const TPoint& Point2, FIdent Ident = 0, EVisuProperty Property = EVisuProperty::BlueCurve, bool bWithOrientation = false)
{
#ifdef CADKERNEL_DEBUG
    F3DDebugSegment G(Ident);
    if (bWithOrientation)
    {
        DrawSegmentOrientation(Point1 * DisplayScale, Point2 * DisplayScale, Property);
    }
    DrawSegment(Point1 * DisplayScale, Point2 * DisplayScale, Property);
#endif
};
 
template<typename TPoint>
void DisplayPolyline(const TArray<TPoint>& Points, EVisuProperty Property)
{
#ifdef CADKERNEL_DEBUG
    Open3DDebugSegment(0);
    Draw(Points, Property);
    Close3DDebugSegment();
#endif
}
 
static void DisplayPolylineWithScale(const TArray<FVector2d>& Points, EVisuProperty Property)
{
#ifdef CADKERNEL_DEBUG
    TArray<FVector2d> PointsWithScale = Points;
    for (FVector2d& Point : PointsWithScale)
    {
        Point *= DisplayScale;
    }
 
    Open3DDebugSegment(0);
    Draw(PointsWithScale, Property);
    Close3DDebugSegment();
#endif
}
 
template<typename TPoint>
void DisplayOrientedPolyline(const TArray<TPoint>& Points, EVisuProperty Property)
{
#ifdef CADKERNEL_DEBUG
    Open3DDebugSegment(0);
    for (int32 Index = 1; Index < Points.Num(); ++Index)
    {
        DisplaySegment(Points[Index - 1], Points[Index], Index, Property, true);
    }
    Close3DDebugSegment();
#endif
}
 
CADKERNEL_API void DrawQuadripode(double Height, double Base, FVector& Centre, FVector& Direction, EVisuProperty Property);
 
CADKERNEL_API void Draw(const FTopologicalEdge& Edge, EVisuProperty Property = EVisuProperty::BlueCurve);
CADKERNEL_API void Draw(const FTopologicalFace& Face);
CADKERNEL_API void Draw2D(const FTopologicalFace& Face);
CADKERNEL_API void Draw2DWithScale(const FTopologicalFace& Face);
CADKERNEL_API void Draw(const FShell& Shell);
 
CADKERNEL_API void Draw(const FCurve& Curve, EVisuProperty Property = EVisuProperty::BlueCurve);
CADKERNEL_API void Draw(const FCurve& Curve, const FLinearBoundary& Boundary, EVisuProperty Property = EVisuProperty::BlueCurve);
CADKERNEL_API void Draw(const FLinearBoundary& Boundary, const FRestrictionCurve& Curve, EVisuProperty Property = EVisuProperty::BlueCurve);
 
template<typename TPoint>
void DrawSegment(const TPoint& Point1, const TPoint& Point2, EVisuProperty Property = EVisuProperty::Element)
{
#ifdef CADKERNEL_DEBUG
    TArray<FVector> Points;
    Points.Add(Point1);
    Points.Add(Point2);
    Draw(Points, Property);
#endif
}
 
template<typename TPoint>
void DrawSegmentOrientation(const TPoint& Point1, const TPoint& Point2, EVisuProperty Property = EVisuProperty::Element)
{
#ifdef CADKERNEL_DEBUG
    double Length = Point1.Distance(Point2);
    double Height = Length / 10.0;
    double Base = Height / 2;
 
    FVector Middle = (Point1 + Point2) / 2.;
    FVector Tangent = Point2 - Point1;
    DrawQuadripode(Height, Base, Middle, Tangent, Property);
#endif
}
 
CADKERNEL_API void DrawIsoCurves(const FTopologicalFace& Face);
 
 
} // namespace UE::CADKernel