Ge.h

Go to the documentation of this file.

// Copyright (C) 2002-2024, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2024 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
 
 
 
 
#ifndef OD_GEGBLGE_H
#define OD_GEGBLGE_H 
 
#include "TD_PackPush.h"
 
#include "Ge/GeExport.h"
#include "Ge/GeLibVersion.h"

struct OdGe
{
  static const OdGeLibVersion gLibVersion;
 
  //unused
  //DOM-IGNORE-BEGIN
  enum 
  { 
    eGood, 
    eBad 
  };
  //DOM-IGNORE-END

  enum EntityId 
  {
    kEntity2d,
    kEntity3d,
    kPointEnt2d,
    kPointEnt3d,
    kPosition2d,
    kPosition3d,
    kPointOnCurve2d,
    kPointOnCurve3d,
    kPointOnSurface,
    kBoundedPlane,
    kCircArc2d,
    kCircArc3d,
    kConic2d,
    kConic3d,
    kCurve2d,
    kCurve3d,
    kEllipArc2d,
    kEllipArc3d,
    kLine2d,
    kLine3d,
    kLinearEnt2d,
    kLinearEnt3d,
    kLineSeg2d,
    kLineSeg3d,
    kPlanarEnt,
    kPlane,
    kRay2d,
    kRay3d,
    kSurface,
    kSphere,
    kCylinder,
    kTorus,
    kCone,
    kSplineEnt2d,
    kPolyline2d,
    kAugPolyline2d,
    kNurbCurve2d,
    kDSpline2d,
    kCubicSplineCurve2d,
    kSplineEnt3d,
    kPolyline3d,
    kAugPolyline3d,
    kNurbCurve3d,
    kDSpline3d,
    kCubicSplineCurve3d,
    kTrimmedCrv2d,
    kCompositeCrv2d,
    kCompositeCrv3d,
    kExternalSurface,
    kNurbSurface,
    kTrimmedSurface,
    kOffsetSurface,
    kEnvelope2d,
    kCurveBoundedSurface,
    kExternalCurve3d,
    kExternalCurve2d,
    kSurfaceCurve2dTo3d,
    kSurfaceCurve3dTo2d,
    kExternalBoundedSurface,
    kCurveCurveInt2d,
    kCurveCurveInt3d,
    kBoundBlock2d,
    kBoundBlock3d,
    kOffsetCurve2d,
    kOffsetCurve3d,
    kPolynomCurve3d,
    kBezierCurve3d,
    kObject,
    kFitData3d,
    kHatch,
    kTrimmedCurve2d,
    kTrimmedCurve3d,
    kCurveSampleData,
    kEllipCone,
    kEllipCylinder,
    kIntervalBoundBlock,
    kClipBoundary2d,
    kExternalObject,
    kCurveSurfaceInt,
    kSurfaceSurfaceInt,
    kHelix,
    kSpunSurface,
    kSegmentChain2d,

    kRevolvedSurface,
    kRuled,
    kEdgeCurve,
    kInvalidEntity,
    kDummy1,
    kDummy2,
    kDummy3,
    kDummy4,
    kDummy5,
    kDummy6,
    kDummy7,
    kDummy8,
    kDummy9
  };

  enum ExternalEntityKind 
  {
    kAcisEntity              = 0,
    kGe3dCurveEntity         = 1,
    kGeSurfaceEntity         = 2,
    kExternalEntityUndefined,
    kBimEntity,
    kIfcEntity
  };
  
  enum PointContainment 
  {
    kInside,
    kOutside,
    kOnBoundary
  };
  
  enum NurbSurfaceProperties 
  {
    kUninit     = 0x00,
    kOpen       = 0x01,
    kClosed     = 0x02,
    kPeriodic   = 0x04,
    kRational   = 0x08,
    kNoPoles    = 0x10,
    kPoleAtMin  = 0x20,
    kPoleAtMax  = 0x40,
    kPoleAtBoth = 0x80
  };

  enum OffsetCrvExtType {
    kFillet,
    kChamfer,
    kExtend
  };

  enum OdGeXConfig 
  {
    kNotDefined      = 1 << 0,
    kUnknown         = 1 << 1,
    kLeftRight       = 1 << 2,
    kRightLeft       = 1 << 3,
    kLeftLeft        = 1 << 4,
    kRightRight      = 1 << 5,
    kPointLeft       = 1 << 6,
    kPointRight      = 1 << 7,
    kLeftOverlap     = 1 << 8,
    kOverlapLeft     = 1 << 9,
    kRightOverlap    = 1 << 10,
    kOverlapRight    = 1 << 11,
    kOverlapStart    = 1 << 12,
    kOverlapEnd      = 1 << 13,
    kOverlapOverlap  = 1 << 14
  };

  enum BooleanType 
  {
    kUnion,
    kSubtract,
    kCommon
  };

  enum ClipError 
  {
    eOk,
    eInvalidClipBoundary,
    eNotInitialized
  };
  
  enum ClipCondition 
  {
    kInvalid,
    kAllSegmentsInside,
    kSegmentsIntersect,
    kAllSegmentsOutsideZeroWinds,
    kAllSegmentsOutsideOddWinds,
    kAllSegmentsOutsideEvenWinds
  };

  enum ErrorCondition 
  {
    kOk,
    k0This,
    k0Arg1,
    k0Arg2,
    kPerpendicularArg1Arg2,
    kEqualArg1Arg2,
    kEqualArg1Arg3,
    kEqualArg2Arg3,
    kLinearlyDependentArg1Arg2Arg3,
    kArg1TooBig,
    kArg1OnThis,
    kArg1InsideThis,
    kNonCoplanarGeometry,
    kDegenerateGeometry,
    kSingularPoint
  };

  enum csiConfig 
  {
    kXUnknown,
    kXOut,
    kXIn,
    kXTanOut,
    kXTanIn,
    kXCoincident,
    kXCoincidentUnbounded
  };

  enum ssiType 
  {
    kSSITransverse,
    kSSITangent,
    kSSIAntiTangent
  };

  enum ssiConfig 
  {
    kSSIUnknown,
    kSSIOut,
    kSSIIn,
    kSSICoincident
  };

  enum OdGeIntersectError 
  {
    kXXOk,
    kXXIndexOutOfRange,
    kXXWrongDimensionAtIndex,
    kXXUnknown
  };

  enum OdGeKnotParameterization {
    kChord                  = 0x0,
    kSqrtChord              = 0x1,
    kUniform                = 0x2,
    kCustomParameterization = 0xF,
    kNotDefinedKnotParam    = 0x10
  };
};

typedef OdGe::ErrorCondition OdGeError;

typedef OdGe::OdGeIntersectError OdGeIntersectError;
typedef OdGe::OdGeKnotParameterization OdGeKnotParameterization;
 
//FELIX_CHANGE_BEGIN
/*
#define DECLARE_GE_RTTI() \
  virtual bool isKindOf (OdGe::EntityId entType) const;\
  virtual OdGe::EntityId type() const
*/
#define DECLARE_GE_RTTI() \
  virtual bool isKindOf (OdGe::EntityId entType) const;\
  virtual OdGe::EntityId type() const;\
  friend class CFxGeExtension;
 
GE_TOOLKIT_EXPORT bool IsGeProtectionEnabled();
GE_TOOLKIT_EXPORT void EnableGeProtection( bool bVal );
//FELIX_CHANGE_END
 
#define DEFINE_GE_RTTI(Class,Parent,TYPE) \
  bool Class::isKindOf(OdGe::EntityId entType) const\
  {\
    if ( entType == OdGe::TYPE ) return true;\
    return Parent::isKindOf( entType );\
  }\
  OdGe::EntityId Class::type() const { return OdGe::TYPE; }

GE_TOOLKIT_EXPORT void odgeHeapCleanup();
 
#include "TD_PackPop.h"
 
#endif  // AC_GEGBLGE_H