Constraint3dCoreApi.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------+
|
|   Supplied under applicable software license agreement.
|
|   Copyright (c) 2018 Bentley Systems, Incorporated. All rights reserved.
|
+---------------------------------------------------------------------------------------*/
#pragma once

#if !defined (mdl_type_resource_generator) && !defined (mdl_resource_compiler)

#include    <DgnPlatform/DgnPlatformApi.h>


/*=================================================================================**/
#ifdef __CONSTRAINT3DCORE_BUILD__
    #define CONSTRAINT3DCORE_EXPORT __declspec(dllexport)
#else
    #define CONSTRAINT3DCORE_EXPORT __declspec(dllimport)
#endif

#define BEGIN_CONSTRAINT3D_NAMESPACE        BEGIN_BENTLEY_DGNPLATFORM_NAMESPACE namespace Constraint3d {
#define END_CONSTRAINT3D_NAMESPACE                }}}
#define USING_NAMESPACE_CONSTRAINT3D        using namespace Bentley::DgnPlatform::Constraint3d;

#define CONSTRAINT3D_CORE_TYPEDEFS(t) \
    BEGIN_CONSTRAINT3D_NAMESPACE struct t; END_CONSTRAINT3D_NAMESPACE \
    ADD_BENTLEY_TYPEDEFS (DgnPlatform::Constraint3d,t);


CONSTRAINT3D_CORE_TYPEDEFS (Constraint3dBase)
CONSTRAINT3D_CORE_TYPEDEFS (DistanceDimension3d)
CONSTRAINT3D_CORE_TYPEDEFS (GeometryId)
CONSTRAINT3D_CORE_TYPEDEFS (FaceGeometryId)
CONSTRAINT3D_CORE_TYPEDEFS (EdgeGeometryId)
CONSTRAINT3D_CORE_TYPEDEFS (CurveGeometryId)
CONSTRAINT3D_CORE_TYPEDEFS (Constraint3dBodyCache)


class g_node;
enum  DCM3_g_type;

BEGIN_CONSTRAINT3D_NAMESPACE

#endif

enum class   Constraint3dStorageVersion
    {
    Initial      = 0,
    Latest       = 0,
    };

enum class Constraint3dXAttributeIndex
    {
    Data                = 0,
    VariableDependency  = 1
    };

//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
enum class Constraint3dType
    {
    DCM3_DISTANCE                                   = 0,                       // ...dcmtypes.hxx
    DCM3_ANGLE                                      = 1,
    DCM3_CONCENTRIC                                 = 2,
    DCM3_RADIUS                                     = 3,
    DCM3_PARALLEL                                   = 4,
    DCM3_PERPENDICULAR                              = 5,
    DCM3_COINCIDENT                                 = 6,
    DCM3_TANGENT                                    = 7,
    DCM3_MAJOR_RADIUS                               = 10,
    DCM3_MINOR_RADIUS                               = 11,
    DCM3_EQUAL_RADIUS                               = 12,
    DCM3_MIDPOINT                                   = 14,
    DCM3_DEPENDENCE                                 = 15,
    DCM3_EQUAL_PARAMETER                            = 17,
    DCM3_EQUAL_DIRECTION                            = 19,
    DCM3_EQUAL_CURVATURE                            = 20,
    DCM3_EQUAL_FIRST_DERIVATIVE                     = 21,
    DCM3_EQUAL_SECOND_DERIVATIVE                    = 22,
    DCM3_CURVE_LENGTH                               = 25,
    DCM3_SYMMETRIC                                  = 50,
    DCM3_HALF_ANGLE                                 = 51,
    DCM3_COINCIDENT_AROUND_SPINE                    = 52,
    DCM3_COINCIDENT_WITH_SPINE                      = 53,
    DCM3_EQUAL_HALF_ANGLE                           = 56,
    DCM3_EQUAL_CURVATURE_VECTOR                     = 59,
    Fixed                                           = 0xfffe,
    Unspecified                                     = 0xffff,
    };


//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
enum   class SurfaceOrientation         // DCM3_surface_orientation
    {                                           
    NotSpecified                                    = 0,
    Aligned,        
    AntiAligned,     
    };

//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
enum class   Constraint3dHalfSpace                  // DCM3_half_space
    {
    NotSpecified                                     = 0,
    Positive,
    Negative,
    };


#if !defined (mdl_type_resource_generator) && !defined (mdl_resource_compiler)


typedef RefCountedPtr <struct Constraint3dBase>     Constraint3dPtr;
typedef RefCountedPtr <struct GeometryId>           GeometryIdPtr;
typedef RefCountedPtr <struct SolverGeometry>       SolverGeometryPtr;

typedef bvector <GeometryIdPtr>                     T_GeometryIds;
typedef bvector <Constraint3dPtr>                   T_Constraints;
typedef bmap <ElementRefP, Transform>               T_ElementTransformMap;


//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
struct  SolverGeometry : RefCountedBase
{
    g_node*                 m_dcmNode;
    Transform               m_transform;
    GeometryIdP             m_geometryId;
    bool                    m_reversed;


    virtual DCM3_g_type     _Identify() = 0;
    virtual                 ~SolverGeometry () { }

                            SolverGeometry (GeometryIdP geometryId) : m_geometryId (geometryId), m_dcmNode (NULL), m_reversed (false)  { m_transform.InitIdentity(); }
    virtual void            _Transform (TransformCR transform)                                                            { m_transform = Transform::FromProduct (m_transform, transform); }
    virtual void            _AddToSolver (class DCM3_dimension_system* dimensionSystem); 

    virtual double          GetParameter () const;
    virtual void            SetParameter (double parameter);
    virtual void            GetParameter (DPoint2dR parameter) const;
    virtual void            SetParameter (DPoint2dCR parameter);


};  //  SolverGeometry


//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
struct GeometryId  : RefCountedBase
{
public:
    enum class Type
        {
        Curve           = 1,
        Face            = 2,
        Element         = 3,
        Edge            = 4,
        RegionPlane     = 5,
        BRepVertex      = 6,
        CurvePoint      = 7,
        BCurve          = 8,
        FaceAxis        = 9,
        CurveArcAxis    = 10,
        EdgeArcAxis     = 11,
        InvalidElement  = 0xff,
        };

    enum class Status
        {
        DCM3_G_UNKNOWN,                         /* unknown status (newly added to system)*/
        DCM3_G_FIXED,                           /* geometry has been declared fixed */
        DCM3_G_OVER_DEFINED,                    /* geometry is over defined by dimensions */
        DCM3_G_NOT_CONSISTENT,                  /* geometry inconsistently defined by dimensions */
        DCM3_G_NOT_CONSISTENT_DIMENSIONS,       /* geometry inconsistently defined by dimensions - change model */
        DCM3_G_NOT_CONSISTENT_OTHER,            /* geometry inconsistently defined by dimensions - try changing solving mode */
        DCM3_G_NOT_CONSISTENT_UNKNOWN,          /* geometry inconsistently defined by dimensions - cannot ascertain what to recommend */
        DCM3_G_NOT_CHANGED,                     /* geometry was not changed */
        DCM3_G_WELL_DEFINED,                    /* geometry is well defined by dimensions */
        DCM3_G_UNDER_DEFINED,                   /* geometry is underdefined by dimensions */
        DCM3_G_WITHIN_BOUNDS,                   /* geometry is underdefined but only due to a bounded dimension */ 
        };


    enum    class DimensionToComponent      // Matches dcmtypes.hxx.
        {
        DCM3_DIMENSION_TO_NOT_SPECIFIED = 0,
        DCM3_DIMENSION_TO_EXTERIOR      = 1,
        DCM3_DIMENSION_TO_CENTRE_POINT  = 2,
        DCM3_DIMENSION_TO_AXIS          = 3,
        DCM3_DIMENSION_TO_PLANE         = 4,
        DCM3_DIMENSION_TO_SPINE         = 5,
        DCM3_DIMENSION_TO_APEX          = 6
        };

    enum FlagMasks
        {
        FlagMask_ParamX         = 0x0001,
        FlagMask_ParamY         = 0x0001 << 1,
        FlagMask_EntityIndex    = 0x0001 << 2,
        };



protected:
    Type                            m_type;
    Status                          m_status;
    ElementHandle                   m_eh;
    PersistentElementPath           m_pep;
    DPoint2d                        m_parameter;
    UInt32                          m_entityIndex;
    Constraint3dBodyCacheP          m_bodyCache;
    

    GeometryId (ElementHandle eh, PersistentElementPathCR pep, Type type, Status status) : m_eh (eh), m_pep (pep), m_type (type), m_status (status), m_entityIndex(0), m_bodyCache (NULL) { m_parameter.Zero();  }

public:
    GeometryId () { m_parameter.Zero(); }
    
    CONSTRAINT3DCORE_EXPORT static GeometryIdPtr            Create (Type type, Status status, DataInternalizer& source, DgnModelRefR modelRef, Constraint3dBodyCacheP bodyCache = NULL);

    Type                                                    GetType() const                             { return m_type; }
    Status                                                  GetStatus () const                          { return m_status; }
    void                                                    SetStatus (Status status)                   { m_status = status; }
    ElementRefP                                             GetElementRef () const                      { return m_eh.GetElementRef(); }
    ElementHandleCR                                         GetElement () const                         { return m_eh; }
    PersistentElementPathCR                                 GetRootPep () const                         { return m_pep; }
    void                                                    SetRootPep (PersistentElementPathCR pep)    { m_pep = pep; }
    void                                                    SetElementRef (ElementRefP elementRef)      { m_eh = ElementHandle (elementRef); }
    void                                                    SetBodyCache (Constraint3dBodyCacheP cache) { m_bodyCache = cache; }
    BentleyStatus                                           GetBody (ISolidKernelEntityPtr& body) const;
    CONSTRAINT3DCORE_EXPORT BentleyStatus                   Extract (DataInternalizer& source);
    CONSTRAINT3DCORE_EXPORT BentleyStatus                   GetRootRange (DRange3dR range) const;
    CONSTRAINT3DCORE_EXPORT BentleyStatus                   SaveOptional (DataExternalizer& sink);

    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus           _Save (DataExternalizer& sink);
    CONSTRAINT3DCORE_EXPORT virtual bool                    _LessThan (GeometryIdCR id0, GeometryIdCR id1) const;
                            virtual BentleyStatus           _GetMarkerLocation (DPoint3dR point) const  { return ERROR; }
                            virtual BentleyStatus           _Flash (ViewContextR viewContext) const     { return ERROR; }
                            virtual bool                    _ValidateRootChange () const                { return false; }
                            virtual SolverGeometryPtr       _CreateSolverGeometry (ISolidKernelEntityCR body, TransformCR dgnToSolverTransform, TransformCR solverToDgnTransform) { return NULL; }
                            virtual SolverGeometryPtr       _CreateSolverGeometry (CurveVectorCR curveVector, TransformCR dgnToSolverTransform, TransformCR solverToDgnTransform) { return NULL; }
                            virtual BentleyStatus           _GetSolidSubEntity (ISubEntityPtr& subEntity, ISolidKernelEntityPtr& body) const { return ERROR; }

                            virtual FaceId const*           _GetFaceId () const                         { return NULL; }
                            virtual EdgeId const*           _GetEdgeId() const                          { return NULL; }
                            virtual VertexId const*         _GetVertexId() const                        { return NULL; }
                            virtual DimensionToComponent    _DimensionToComponent() const               { return DimensionToComponent::DCM3_DIMENSION_TO_NOT_SPECIFIED; }
                            virtual bool                    _OmitSolverGeometry ()                      { return false; }


    double          GetParameter () const                                                           { return m_parameter.x; }
    void            SetParameter (double parameter)                                                 { m_parameter.x = parameter; }
    void            GetParameter (DPoint2dR parameter) const                                        { parameter = m_parameter; }
    void            SetParameter (DPoint2dCR parameter)                                             { m_parameter = parameter; }
    UInt32          GetEntityIndex () const                                                         { return m_entityIndex; }
    void            SetEntityIndex (UInt32 entityIndex)                                             { m_entityIndex = entityIndex; }


    bool            LessThanWithoutParams (GeometryIdCR id0, GeometryIdCR id1) const;

    CONSTRAINT3DCORE_EXPORT bool operator  < (GeometryIdCR otherId) const { return _LessThan (*this, otherId); }


};  // GeometryId


//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
struct CompareGeometryIds 
{ 
    bool operator () (GeometryIdCP const& id0, GeometryIdCP const& id1) const { return *id0 < *id1; } 
};




//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
struct FaceGeometryId : GeometryId
{
    DEFINE_T_SUPER (GeometryId)

protected:   
    FaceId          m_faceId;

    FaceGeometryId (ElementHandleCR eh, PersistentElementPathCR pep, Status status, FaceId const& faceId) : GeometryId (eh, pep, Type::Face, status), m_faceId (faceId) { }

public:
    CONSTRAINT3DCORE_EXPORT static GeometryIdPtr        Create (ElementHandleCR eh, ISubEntityCR subEntity);
    CONSTRAINT3DCORE_EXPORT static GeometryIdPtr        Create (ElementHandleCR eh, PersistentElementPathCR pep, Status status, DataInternalizer& source);
                            
    
    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus       _Save (DataExternalizer& sink);
    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus       _GetMarkerLocation (DPoint3dR pointh) const override;
    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus       _Flash (ViewContextR viewContext) const override;
    CONSTRAINT3DCORE_EXPORT virtual bool                _ValidateRootChange () const override;
    CONSTRAINT3DCORE_EXPORT virtual SolverGeometryPtr   _CreateSolverGeometry (ISolidKernelEntityCR body, TransformCR dgnToSolverTransform, TransformCR solverToDgnTransform) override;
    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus       _GetSolidSubEntity (ISubEntityPtr& subEntity, ISolidKernelEntityPtr& body) const override;
    CONSTRAINT3DCORE_EXPORT virtual bool                _LessThan (GeometryIdCR id0, GeometryIdCR id1) const override;
                                    FaceId const*       _GetFaceId () const { return &m_faceId; }

    
};  // FaceGeometryId

//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
struct FixedElementId : GeometryId           // NO LONGER CREATED -- For beta compatibility only.
{
    DEFINE_T_SUPER (GeometryId)

protected:
    FixedElementId (ElementHandleCR eh, PersistentElementPathCR pep, Status status) : GeometryId (eh, pep, Type::Element, status) { }

public:
    static GeometryIdPtr Create (ElementHandleCR eh, PersistentElementPathCR pep, Status status) { return new FixedElementId (eh, pep, status); }
    static GeometryIdPtr Create (ElementHandleCR eh) { return new FixedElementId (eh, PersistentElementPath(), Status::DCM3_G_UNKNOWN); }

    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus   _GetMarkerLocation (DPoint3dR point) const override;
    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus   _Flash (ViewContextR viewContext) const override;
    CONSTRAINT3DCORE_EXPORT virtual bool            _ValidateRootChange() const override;  
                            virtual bool            _OmitSolverGeometry () { return true; }           

    
};  // FixedElementId

//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
struct EdgeGeometryId : GeometryId
{
    DEFINE_T_SUPER (GeometryId)

protected:   
    EdgeId          m_edgeId;

    EdgeGeometryId (ElementHandleCR eh, PersistentElementPathCR pep, Status status, EdgeId const& edgeId) : GeometryId (eh, pep, Type::Edge, status), m_edgeId (edgeId) { }

public:
    CONSTRAINT3DCORE_EXPORT static GeometryIdPtr        Create (ElementHandleCR eh, ISubEntityCR subEntity);
    CONSTRAINT3DCORE_EXPORT static GeometryIdPtr        Create (ElementHandleCR eh, PersistentElementPathCR pep, Status status, DataInternalizer& source);

    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus       _Save (DataExternalizer& sink);
    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus       _GetMarkerLocation (DPoint3dR point) const override;
    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus       _Flash (ViewContextR viewContext) const override;
    CONSTRAINT3DCORE_EXPORT virtual bool                _ValidateRootChange () const override;
    CONSTRAINT3DCORE_EXPORT virtual SolverGeometryPtr   _CreateSolverGeometry (ISolidKernelEntityCR body, TransformCR dgnToSolverTransform, TransformCR solverToDgnTransform) override;
    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus       _GetSolidSubEntity (ISubEntityPtr& subEntity, ISolidKernelEntityPtr& body) const override;
    CONSTRAINT3DCORE_EXPORT virtual bool                _LessThan (GeometryIdCR id0, GeometryIdCR id1) const override;
                                   EdgeId const*        _GetEdgeId () const { return &m_edgeId; }

                         
    BentleyStatus GetEdge (ISubEntityPtr& edge, ISolidKernelEntityPtr& body) const;
    BentleyStatus GetEdgePoint (DPoint3dR point, double fraction) const;

    
};  // EdgeGeometryId


//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
struct EdgeArcAxisGeometryId : EdgeGeometryId
{
    DEFINE_T_SUPER (EdgeGeometryId)

    EdgeArcAxisGeometryId (ElementHandleCR eh, PersistentElementPathCR pep, Status status, EdgeId const& edgeId) : EdgeGeometryId (eh, pep, status, edgeId) { m_type = Type::EdgeArcAxis; }

public:
    CONSTRAINT3DCORE_EXPORT static GeometryIdPtr            Create (ElementHandleCR eh, EdgeId const& edgeId);
    CONSTRAINT3DCORE_EXPORT static GeometryIdPtr            Create (ElementHandleCR eh, PersistentElementPathCR pep, Status status, DataInternalizer& source);

    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus           _GetMarkerLocation (DPoint3dR point) const override;
    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus           _Flash (ViewContextR viewContext) const override;
    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus           _GetSolidSubEntity (ISubEntityPtr& subEntity, ISolidKernelEntityPtr& body) const override;
                            virtual DimensionToComponent    _DimensionToComponent() const override { return  DimensionToComponent::DCM3_DIMENSION_TO_AXIS; }

   
};  // EdgeArcAxisGeometryId

//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
struct BRepVertexGeometryId : GeometryId
{
    DEFINE_T_SUPER (GeometryId)

protected:
    VertexId        m_vertexId;

    BRepVertexGeometryId (ElementHandleCR eh, PersistentElementPathCR pep, Status status, VertexId const& vertexId) : GeometryId (eh, pep, Type::BRepVertex, status), m_vertexId (vertexId) { }
            
                                                        
        
public:
    CONSTRAINT3DCORE_EXPORT static GeometryIdPtr        Create (ElementHandleCR eh, ISubEntityCR subEntity);
    CONSTRAINT3DCORE_EXPORT static GeometryIdPtr        Create (ElementHandleCR eh, PersistentElementPathCR pep, Status status, DataInternalizer& source);

    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus       _Save (DataExternalizer& sink);
    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus       _GetMarkerLocation (DPoint3dR point) const override;
    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus       _Flash (ViewContextR viewContext) const override;
    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus       _GetSolidSubEntity (ISubEntityPtr& subEntity, ISolidKernelEntityPtr& body) const override;
    CONSTRAINT3DCORE_EXPORT virtual SolverGeometryPtr   _CreateSolverGeometry (ISolidKernelEntityCR body, TransformCR dgnToSolverTransform, TransformCR solverToDgnTransform) override;
    CONSTRAINT3DCORE_EXPORT virtual bool                _ValidateRootChange () const override;
    CONSTRAINT3DCORE_EXPORT virtual bool                _LessThan (GeometryIdCR id0, GeometryIdCR id1) const override;
                                   VertexId const*      _GetVertexId () const { return &m_vertexId; }



};  // EdgePointGeometryId


//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
struct CurveGeometryId : GeometryId
{
    DEFINE_T_SUPER (GeometryId)

    CurvePrimitiveIdPtr     m_curveId;
    UInt32                  m_segmentIndex;             // Segment index for linestrings.

protected:
    CurveGeometryId (ElementHandleCR eh, PersistentElementPathCR pep, Status status, CurvePrimitiveIdPtr& curveId, UInt32 segmentIndex, double fraction) : GeometryId (eh, pep, Type::Curve, status), m_curveId (curveId), m_segmentIndex (segmentIndex)  { SetParameter (fraction); }

public:
    CONSTRAINT3DCORE_EXPORT static GeometryIdPtr        Create (ElementHandleCR eh, CurveLocationDetailCR curveLocationDetail);
    CONSTRAINT3DCORE_EXPORT static GeometryIdPtr        Create (ElementHandleCR eh, PersistentElementPathCR pep, Status status, DataInternalizer& source);

    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus       _Save (DataExternalizer& sink);
    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus       _GetMarkerLocation (DPoint3dR point) const override;
    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus       _Flash (ViewContextR viewContext) const override;
    CONSTRAINT3DCORE_EXPORT virtual bool                _ValidateRootChange() const override;  
    CONSTRAINT3DCORE_EXPORT virtual SolverGeometryPtr   _CreateSolverGeometry (CurveVectorCR curveVector, TransformCR dgnToSolverTransform, TransformCR solverToDgnTransform) override;
    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus       _GetSolidSubEntity (ISubEntityPtr& subEntity, ISolidKernelEntityPtr& body) const override;
    CONSTRAINT3DCORE_EXPORT virtual bool                _LessThan (GeometryIdCR id0, GeometryIdCR id1) const override;

    static  BentleyStatus Extract (CurvePrimitiveIdPtr& curveId, UInt32& subindex, DataInternalizer& source);
            BentleyStatus GetCurve (ICurvePrimitivePtr& curve) const;
            BentleyStatus GetCurve (ICurvePrimitivePtr& curve, CurveVectorCR curveVector) const;
            BentleyStatus GetCurvePoint (DPoint3dR point, double fraction) const;
    
};  // CurveGeometryId


//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
struct CurveArcAxisGeometryId : CurveGeometryId
{
    DEFINE_T_SUPER (CurveGeometryId)

    CurveArcAxisGeometryId (ElementHandleCR eh, PersistentElementPathCR pep, Status status, CurvePrimitiveIdPtr& curveId) : CurveGeometryId (eh, pep, status, curveId, 0, 0.0) { m_type = Type::CurveArcAxis; }

public:
    CONSTRAINT3DCORE_EXPORT static GeometryIdPtr            Create (ElementHandleCR eh, CurvePrimitiveIdCR curvePrimitiveId);
    CONSTRAINT3DCORE_EXPORT static GeometryIdPtr            Create (ElementHandleCR eh, PersistentElementPathCR pep, Status status, DataInternalizer& source);

    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus           _GetMarkerLocation (DPoint3dR point) const override;
    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus           _Flash (ViewContextR viewContext) const override;
    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus           _GetSolidSubEntity (ISubEntityPtr& subEntity, ISolidKernelEntityPtr& body) const override;
                            virtual DimensionToComponent    _DimensionToComponent() const override { return  DimensionToComponent::DCM3_DIMENSION_TO_AXIS; }

   
};  // CurveArcAxisGeometryId


//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
struct CurvePointGeometryId : CurveGeometryId
{
    DEFINE_T_SUPER (CurveGeometryId)

protected:
    CurvePointGeometryId (ElementHandleCR eh, PersistentElementPathCR pep, Status status, CurvePrimitiveIdPtr& curveId, UInt32 segmentIndex, double fraction) : CurveGeometryId (eh, pep, status, curveId, segmentIndex, fraction) { m_type = Type::CurvePoint; }
            
public:
    CONSTRAINT3DCORE_EXPORT static GeometryIdPtr        Create (ElementHandleCR eh, CurveLocationDetailCR curveLocationDetail);
    CONSTRAINT3DCORE_EXPORT static GeometryIdPtr        Create (ElementHandleCR eh, PersistentElementPathCR pep, Status status, DataInternalizer& source);

    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus       _GetMarkerLocation (DPoint3dR point) const override;
    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus       _Flash (ViewContextR viewContext) const override;
    CONSTRAINT3DCORE_EXPORT virtual SolverGeometryPtr   _CreateSolverGeometry (CurveVectorCR curveVector, TransformCR dgnToSolverTransform, TransformCR solverToDgnTransform) override;
    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus       _GetSolidSubEntity (ISubEntityPtr& subEntity, ISolidKernelEntityPtr& body) const override;

};  // CurvePointGeometryId


//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
struct RegionPlaneId : GeometryId
{
    DEFINE_T_SUPER (GeometryId)

protected:
    RegionPlaneId (ElementHandleCR eh, PersistentElementPathCR pep, Status status) : GeometryId (eh, pep, Type::RegionPlane, status) { }

public:
    static GeometryIdPtr Create (ElementHandleCR eh, PersistentElementPathCR pep, Status status) { return new RegionPlaneId (eh, pep, status); }
    static GeometryIdPtr Create (ElementHandleCR eh) { return new RegionPlaneId (eh, PersistentElementPath(), Status::DCM3_G_UNKNOWN); }


    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus       _GetMarkerLocation (DPoint3dR point) const override;
    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus       _Flash (ViewContextR viewContext) const override;
    CONSTRAINT3DCORE_EXPORT virtual bool                _ValidateRootChange () const override;
    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus       _GetSolidSubEntity (ISubEntityPtr& subEntity, ISolidKernelEntityPtr& body) const override;
    CONSTRAINT3DCORE_EXPORT virtual SolverGeometryPtr   _CreateSolverGeometry (CurveVectorCR curveVector, TransformCR dgnToSolverTransform, TransformCR solverToDgnTransform) override;
    
    BentleyStatus   GetCurveVector (CurveVectorPtr& curveVector) const;

    
};  // RegionPlaneId


//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
struct FaceAxisGeometryId : FaceGeometryId
{
    DEFINE_T_SUPER (FaceGeometryId)

protected:   
    FaceId          m_faceId;

    FaceAxisGeometryId (ElementHandleCR eh, PersistentElementPathCR pep, Status status, FaceId const& faceId) : FaceGeometryId (eh, pep, status, faceId)  { m_type = Type::FaceAxis; }

public:
    CONSTRAINT3DCORE_EXPORT static GeometryIdPtr            Create (ElementHandleCR eh, FaceId const& faceId);
    CONSTRAINT3DCORE_EXPORT static GeometryIdPtr            Create (ElementHandleCR eh, PersistentElementPathCR pep, Status status, DataInternalizer& source);
                            
    
    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus           _GetMarkerLocation (DPoint3dR pointh) const override;
    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus           _Flash (ViewContextR viewContext) const override;
    CONSTRAINT3DCORE_EXPORT virtual BentleyStatus           _GetSolidSubEntity (ISubEntityPtr& subEntity, ISolidKernelEntityPtr& body) const override;
                            virtual DimensionToComponent    _DimensionToComponent() const override;
                                    FaceId const*           _GetFaceId () const override        { return &m_faceId; }

                                    BentleyStatus           GetAxis (ICurvePrimitivePtr& axis) const;

    
};  // FaceGeometryId

//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
struct  Constraint3dBase : RefCountedBase
{

public:
    enum class Status 
        {
        DCM3_D_UNKNOWN,                         /* unknown status (newly added to system) */
        DCM3_D_OVER_DEFINED,                    /* dimension specification is over-defined or too complex to solve */
        DCM3_D_NOT_CONSISTENT,                  /* given dimension value is inconsistent */
        DCM3_D_NOT_CONSISTENT_DIMENSIONS,       /* given dimension value is inconsistent - change model */
        DCM3_D_NOT_CONSISTENT_OTHER,            /* given dimension value is inconsistent - try changing solving mode */
        DCM3_D_NOT_CONSISTENT_UNKNOWN,          /* given dimension value is inconsistent -  cannot ascertain what to recommend */
        DCM3_D_NOT_CHANGED,                     /* given dimension not changed */
        DCM3_D_BETWEEN_SET_MEMBERS,             /* given dimension between set members -  has not solved - could also be between fixed geometry */
        DCM3_D_BETWEEN_FIXED,                   /* given dimension between fixed geometry -   has not solved */
        DCM3_D_NOT_SOLVED,                      /* given dimension has not solved */
        DCM3_D_SOLVED,                          /* dimension value is satisfied by solution */
        Redundant = 0xffff,
        };

    enum    FlagMasks
        {
        FlagMask_SurfaceOrientation   = 0x0003 << 0,
        FlagMask_GroupLock            = 0x0001 << 2,
        FlagMask_HalfSpace1           = 0x0003 << 4,
        FlagMask_HalfSpace2           = 0x0003 << 6,
        };
        

    CONSTRAINT3DCORE_EXPORT static Constraint3dPtr Create (Constraint3dType type);
    CONSTRAINT3DCORE_EXPORT static Constraint3dPtr Create (Constraint3dType type, T_GeometryIds const& geometryIds, UInt32 flags);

    virtual BentleyStatus                       _Extract (DataInternalizer& source, DgnModelRefR modelRef, Constraint3dBodyCacheP bodyCache);
    virtual BentleyStatus                       _Save (DataExternalizer& sink);
    virtual bool                                _DoEditValue () const                                       { return false; }
    virtual bool                                _IsDirected () const                                        { return false; }
    virtual bool                                _IsDimension () const                                       { return false; }
    virtual void                                _Draw (ViewContextR viewContext, DgnModelRefR) const        {  }
    virtual double                              _GetValue () const                                          {  return 0.0; }
    virtual void                                _SetValue (double value)                                    { BeAssert (false); }
    virtual WString                             _GetVariableAccess () const                                 { return WString(); }
    virtual void                                _SetVariableAccess (WStringCR variableAccess)               { BeAssert (false); }
    virtual bool                                _DisplayMarkers (ViewContextR viewContext) const            { return true; }

    Constraint3dType                            GetType () const                                            { return m_type; }
    Status                                      GetStatus () const                                          { return m_status; }
    void                                        SetStatus (Status status)                                   { m_status = status; }
    UInt32                                      GetFlags () const                                           { return m_flags; }
    void                                        SetFlags (UInt32 flags)                                     { m_flags = flags; }
    T_GeometryIds const&                        GetGeometryIds() const                                      { return m_geometryIds; }
    void                                        SetGeometryIds (T_GeometryIds const& geometryIds)           { m_geometryIds = geometryIds; }
    SurfaceOrientation                          GetSurfaceOrientation() const                               { return  (SurfaceOrientation) (m_flags & FlagMask_SurfaceOrientation); }
    void                                        SetSurfaceOrientation(SurfaceOrientation orientation)       { m_flags &= ~FlagMask_SurfaceOrientation; m_flags |= (UInt32) orientation; }
    Constraint3dHalfSpace                       GetHalfSpace1() const                                       { return  (Constraint3dHalfSpace) ((m_flags & FlagMask_HalfSpace1) >> 4); }
    Constraint3dHalfSpace                       GetHalfSpace2() const                                       { return  (Constraint3dHalfSpace) ((m_flags & FlagMask_HalfSpace2) >> 6); }
    void                                        SetHalfSpace1(Constraint3dHalfSpace halfSpace)              { m_flags &= ~FlagMask_HalfSpace1; m_flags |= ((UInt32) halfSpace  << 4); }
    void                                        SetHalfSpace2(Constraint3dHalfSpace halfSpace)              { m_flags &= ~FlagMask_HalfSpace2; m_flags |= ((UInt32) halfSpace  << 6); }

    bool                                        GetGroupLock () const                                       { return 0 != (m_flags & m_flags & FlagMask_GroupLock); }
    CONSTRAINT3DCORE_EXPORT void                SetGroupLock (bool groupLock);
    bool                                        HasBoundVariable() const                                    { return !_GetVariableAccess().empty(); }
    CONSTRAINT3DCORE_EXPORT bool                IsRedundant (Constraint3dBaseCR other) const;
    CONSTRAINT3DCORE_EXPORT bool                HasElementRef (ElementRefP elementRef) const;
    CONSTRAINT3DCORE_EXPORT void                GetElementRefs (T_StdElementRefSet& elementRefs) const;
    CONSTRAINT3DCORE_EXPORT BentleyStatus       GetRootRange (DRange3dR range) const;

        
protected:
    Constraint3dBase (Constraint3dType type) : m_type (type), m_status (Status::DCM3_D_UNKNOWN), m_flags (0) { }
      
    Constraint3dType            m_type;
    Status                      m_status;
    T_GeometryIds               m_geometryIds;
    UInt32                      m_flags;
                                                                                                                                                                                            
};  // Constraint3dBase


//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
struct  TangentConstraint3d : Constraint3dBase
{
    DEFINE_T_SUPER (Constraint3dBase)

    virtual bool            _IsDirected () const override                                   { return true; }
    TangentConstraint3d () : Constraint3dBase (Constraint3dType::DCM3_TANGENT)              { }
    
};

//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
struct  ParallelConstraint3d : Constraint3dBase
{
    DEFINE_T_SUPER (Constraint3dBase)

    ParallelConstraint3d () : Constraint3dBase (Constraint3dType::DCM3_PARALLEL)           { }
};

//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
struct  PerpendicularConstraint3d : Constraint3dBase
{
    DEFINE_T_SUPER (Constraint3dBase)

    PerpendicularConstraint3d () : Constraint3dBase (Constraint3dType::DCM3_PERPENDICULAR)  { }
    
};

//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
struct  CoincidentConstraint3d : Constraint3dBase
{
    DEFINE_T_SUPER (Constraint3dBase)

    virtual bool            _IsDirected () const override                                   { return true; }
    CoincidentConstraint3d () : Constraint3dBase (Constraint3dType::DCM3_COINCIDENT)        { }
    
};

//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
struct  ConcentricConstraint3d : Constraint3dBase
{
    DEFINE_T_SUPER (Constraint3dBase)

    ConcentricConstraint3d () : Constraint3dBase (Constraint3dType::DCM3_CONCENTRIC) { }
    
};
//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
struct  FixedConstraint3d : Constraint3dBase
{
    DEFINE_T_SUPER (Constraint3dBase)

    FixedConstraint3d () : Constraint3dBase (Constraint3dType::Fixed) { }
    
};


//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
struct  Dimension3dBase : Constraint3dBase
{
    DEFINE_T_SUPER (Constraint3dBase)

protected:
    double      m_value;
    WString     m_variableAccess;     


public:    
    Dimension3dBase (Constraint3dType type) : Constraint3dBase (type) { }

    virtual BentleyStatus   _Extract (DataInternalizer& source, DgnModelRefR modelRef, Constraint3dBodyCacheP bodyCache) override;
    virtual BentleyStatus   _Save (DataExternalizer& sink) override;
    virtual bool            _DoEditValue () const override                                                                        { return true; }
    virtual bool            _DisplayMarkers (ViewContextR viewContext) const override                                             { return false; }
    virtual bool            _IsDimension () const override                                                                        { return true; }
    virtual double          _GetValue () const override                                                                           { return m_value; }
    virtual void            _SetValue (double value) override                                                                     { m_value = value; }
    virtual WString         _GetVariableAccess () const override                                                                  { return m_variableAccess; }
    virtual void            _SetVariableAccess (WStringCR variableAccess) override                                                { m_variableAccess = variableAccess;  }

};  // Dimension3dBase



//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
struct  DistanceDimension3d : Dimension3dBase
{
    DEFINE_T_SUPER (Dimension3dBase)

public:
    DistanceDimension3d () : Dimension3dBase (Constraint3dType::DCM3_DISTANCE) { }

    virtual void            _Draw (ViewContextR viewContext, DgnModelRefR modelRef) const override; 

    CONSTRAINT3DCORE_EXPORT void                   Draw (ViewContextR viewContext, DgnModelRefR modelRef, T_ElementTransformMap const* transformMap) const;
    CONSTRAINT3DCORE_EXPORT static Constraint3dPtr Create (T_GeometryIds const& geometryIds, UInt32 flags, double value, WStringCR variableAccess);
    CONSTRAINT3DCORE_EXPORT static BentleyStatus   CalculateDimensionDistance (double& value, Constraint3dHalfSpace halfSpaces[2], T_GeometryIds const& geometryIds, DgnModelRefR modelRef);

};  // DimensionConstraint3d

//=======================================================================================
// @bsistruct                                                   Diego.Pinate    09/16
//=======================================================================================
struct  Angle3dConstraint : Dimension3dBase
{
    DEFINE_T_SUPER (Constraint3dBase)

    enum AngleSettings
        {
        NO_INVERTED_AXIS    = 0,
        INVERTED_AXIS       = 1,
        };

    // Position of the arc shown to the user, this just represents the length from the intersection point of the planes 
    // to the arc that shows the value of the angle
    double  m_arcPosition;
    // The axis is regenerated each time DCubed solves it and origin is irrelevant
    DVec3d  m_axis;
    // These settings are for saving space for further enhancement of the angle constraint
    UInt32  m_settings;
    // Unused save data for potential enhancements later on
    double  m_unused0;
    double  m_unused1;

    Angle3dConstraint () : Dimension3dBase (Constraint3dType::DCM3_ANGLE) { }

    virtual void            _Draw (ViewContextR viewContext, DgnModelRefR modelRef) const override; 
    virtual bool            _IsDirected() const override { return true; }
    virtual BentleyStatus   _Extract (DataInternalizer& source, DgnModelRefR modelRef, Constraint3dBodyCacheP bodyCache) override;
    virtual BentleyStatus   _Save (DataExternalizer& sink) override;

    DVec3d                  GetAxis() { return m_axis; }
    void                    SetAxis(DVec3dCR axis);

    // Computes the axis and returns it
    DRay3d                  ComputeAxis(T_GeometryIds const& geometryIds, bool invert);

    CONSTRAINT3DCORE_EXPORT void                   ComputeArcPosition(DPoint3dCR point);
    CONSTRAINT3DCORE_EXPORT void                   ComputeDefaultArcPosition();
    CONSTRAINT3DCORE_EXPORT BentleyStatus          GetNormalPlane(DPlane3dR normalPlane);
    CONSTRAINT3DCORE_EXPORT void                   Draw (ViewContextR viewContext, DgnModelRefR modelRef, T_ElementTransformMap const* transformMap) const;
    CONSTRAINT3DCORE_EXPORT static Constraint3dPtr Create (T_GeometryIds const& geometryIds, DRay3dCR axis, UInt32 flags, double value, WStringCR variableAccess, UInt32 settings);
    CONSTRAINT3DCORE_EXPORT static BentleyStatus   CalculateAngle (double& value, T_GeometryIds const& geometryIds);

};  // Angle3dConstraint



//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
struct  Constraint3dUtil
{
    CONSTRAINT3DCORE_EXPORT static void             RemoveInvalidConstraints (size_t& nInvalid, T_Constraints& constraints, ElementRefP changed, ElementHandleCR hostEh);
    CONSTRAINT3DCORE_EXPORT static void             GetConstrainedElements (T_StdElementRefSet& elements, T_Constraints const& constraints, DgnModelRefP modelRef);
    CONSTRAINT3DCORE_EXPORT static BentleyStatus    GetNamedGroupMembers (T_StdElementRefSet& members, NamedGroupPtr& namedGroup);
    CONSTRAINT3DCORE_EXPORT static BentleyStatus    GetNamedGroupMembers (T_StdElementRefSet& members, ElementRefP elementRef, DgnModelRefP modelRef);
    CONSTRAINT3DCORE_EXPORT static BentleyStatus    GetFaceAxis (ICurvePrimitivePtr& axis, ISubEntityCR face);
    CONSTRAINT3DCORE_EXPORT static BentleyStatus    GetEdgeArcAxis (DRay3dR axis, ISubEntityCR edge);

};  //  Constraint3dUtil



/*=================================================================================**/
struct          Constraint3dBodyCache : ElementRefAppData
{
    static Key  s_key;

private:
        typedef bmap<UInt32, ISolidKernelEntityPtr>                             Constraint3dBodyCacheValueMap;
    bmap <ElementRefP, Constraint3dBodyCacheValueMap>       m_bodyMap;

protected:
    virtual void _OnCleanup (ElementRefP host, bool unloadingModel, HeapZoneR zone) override;

public:
    CONSTRAINT3DCORE_EXPORT static Constraint3dBodyCacheP  Get (ElementRefP host);
    CONSTRAINT3DCORE_EXPORT static void KernelRestarted (); 

    CONSTRAINT3DCORE_EXPORT ISolidKernelEntityPtr   GetBody (ElementRefP elementRef, UInt32 entityIndex);
    CONSTRAINT3DCORE_EXPORT void                    AddBody (ElementRefP elementRef, UInt32 entityIndex, ISolidKernelEntityPtr);
    CONSTRAINT3DCORE_EXPORT void                    RemoveBodies (T_StdElementRefSet elementRefs);

};


//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
struct  Constraint3dSolver
{
private:    
    struct  SolverImplementation*     m_solverImpl;

public:
    CONSTRAINT3DCORE_EXPORT Constraint3dSolver () : m_solverImpl (NULL) { }
    CONSTRAINT3DCORE_EXPORT ~Constraint3dSolver ();

    CONSTRAINT3DCORE_EXPORT BentleyStatus   Initialize (T_Constraints const& constraints, DgnModelRefR modelRef, bmap <ElementRefP, EditElementHandleP>* modifiedElements = NULL, char const* debugJournal = NULL);
    CONSTRAINT3DCORE_EXPORT BentleyStatus   Evaluate (T_ElementTransformMap& transformMap);
    CONSTRAINT3DCORE_EXPORT BentleyStatus   Evaluate (T_ElementTransformMap& transformMap, GeometryIdCR softReferenceId);
    CONSTRAINT3DCORE_EXPORT BentleyStatus   Evaluate (T_ElementTransformMap& transformMap, T_StdElementRefSet const& elementRefs);
    CONSTRAINT3DCORE_EXPORT BentleyStatus   DynamicEvaluate (T_ElementTransformMap& transformMap, T_StdElementRefSet const& elementRefs, TransformCR tranform);
    CONSTRAINT3DCORE_EXPORT BentleyStatus   DynamicEvaluate (T_ElementTransformMap& transformOutMap, T_ElementTransformMap& transformInMap);
    CONSTRAINT3DCORE_EXPORT BentleyStatus   GetDegreesOfFreedom (int& dof, int& removedDof, int& rigidDof);

};  // Constraint3dSolver


/*=================================================================================**/
struct Constraint3dTargetHostExtension : DgnPlatform::Handler::Extension
{
    ELEMENTHANDLER_EXTENSION_DECLARE_MEMBERS (Constraint3dTargetHostExtension, CONSTRAINT3DCORE_EXPORT);

protected:
    virtual BentleyStatus                   _ValidateConstraint3dTargets (WStringR cantAcceptReason, T_GeometryIds& geometryIds, ElementHandleCR eh, bool saveChanges) const = 0;
    virtual void                            _PreprocessTransforms (ElementHandleCR eh, T_ElementTransformMap& transformMap) const = 0;


public:
    CONSTRAINT3DCORE_EXPORT  BentleyStatus   ValidateConstraint3dTargets (WStringR cantAcceptReason, T_GeometryIds& geometryIds, ElementHandleCR eh, bool saveChanges) const;
    CONSTRAINT3DCORE_EXPORT  void            PreprocessTransforms (ElementHandleCR eh, T_ElementTransformMap& transformMap) const;

}; // Constraint3dTargetHostExtension

END_CONSTRAINT3D_NAMESPACE

#endif